சி இல் காரணி திட்டம்: ஒரு எண்ணின் காரணியாலைக் கணக்கிடுவது எப்படி?

நேர்மறை முழு எண்ணின் காரணி என்பது ஒரு முழு எண்ணின் தயாரிப்பு மற்றும் அதற்குக் கீழே உள்ள அனைத்து முழு எண்களும், அதாவது, எண் n இன் காரணியாலானது (n ஆல் குறிப்பிடப்படுகிறது) வழங்கப்படும்

n! = 1 * 2 * 3 * 4 *. . . . . * n

ஜாவாவில் ஒரு பொருளை குளோன் செய்வது எப்படி

0 இன் காரணியாலானது 1 என வரையறுக்கப்படுகிறது மற்றும் எதிர்மறை முழு எண்களுக்கு வரையறுக்கப்படவில்லை. கீழே பட்டியலிடப்பட்டுள்ள அதைக் கண்டுபிடிக்க பல வழிகள் உள்ளன-

• சி இல் காரணி திட்டம்For loop ஐப் பயன்படுத்துகிறது
• பயன்படுத்தி காரணி திட்டம்செயல்பாடுகள்
• காரணி திட்டம்மறுநிகழ்வைப் பயன்படுத்துகிறது

தொடங்குவோம்.

லூப்பிற்கான காரணி பயன்பாடு

ஒரு எண்ணின் காரணியைக் கண்டறிய இது எளிதான மற்றும் எளிமையான வழியாகும். முதலில் குறியீட்டைப் பார்ப்போம் -

# int int main () {int I, num, fact = 1 // காரணி 1 ஐ வரையறுப்பது குறைந்தபட்ச மதிப்பு 1 printf (“அதன் காரணியைக் கணக்கிட ஒரு எண்ணை உள்ளிடுக”) scanf (“% d”, & num) if (num<0) //if the input is a negative integer { printf (“Factorial is not defined for negative numbers.”) } else { for(i=1i0, therefore fact value remains 1 { fact = fact * i // keeps on multiplying and storing in the value of factorial till the input integer is reached } printf(“Factorial of %d = %dn”, num, fact) } return 0 //since we have defined the main() method with a return value of integer type }

வெளியீடு-

5 = 120 இன் காரணி

விளக்கம் -

அதன் காரணி கண்டுபிடிக்கப்பட வேண்டிய எண் உள்ளீடாக எடுத்து ஒரு மாறியில் சேமிக்கப்படுகிறது மற்றும் அது எதிர்மறையா இல்லையா என்று சோதிக்கப்படுகிறது. உள்ளிட்ட முழு எண் எதிர்மறையாக இருந்தால் பொருத்தமான செய்தி காண்பிக்கப்படும். காரணியாலின் மதிப்பு 1 ஆக வரையறுக்கப்படுகிறது, ஏனெனில் அதன் குறைந்தபட்ச மதிப்பு 1 ஆகும். நேர்மறை முழு எண்களுக்கு ஃபார் லூப் செயல்படுத்தப்படுகிறது (0 தவிர, சோதனை நிலை தவறானது, எனவே உண்மை பூஜ்ஜியமாகவே உள்ளது). ஃபார் லூப்பில், காரணியாலின் மதிப்பு ஒவ்வொரு முழு எண்ணுடன் பெருக்கப்பட்டு உள்ளீட்டு எண்ணை அடையும் வரை அடுத்தடுத்து சேமிக்கப்படும். எடுத்துக்காட்டாக, உள்ளீடு = 5 க்கு, ஓட்டம் வளையத்திற்குச் சென்று பின்வரும் படிகள் நடைபெறும்-

fact = 1, i = 1 -> fact = 1 * 1 = 1 -> i = 2
fact = 1, i = 2 -> உண்மை = 1 * 2 = 2 -> i = 3
fact = 2, i = 3 -> fact = 2 * 3 = 6 -> i = 4
fact = 6, i = 4 -> fact = 6 * 4 = 24 -> i = 5
fact = 24, i = 5 -> உண்மை = 24 * 5 = 120 -> i = 6

இப்போது 6> 5, எனவே சோதனை நிலை தவறானது மற்றும் வளையம் நிறுத்தப்படுகிறது. காரணியாலின் மதிப்பு காட்டப்படும்.

செயல்பாடுகளைப் பயன்படுத்தி காரணி

இந்த அணுகுமுறை ஒரு மட்டு அணுகுமுறை என அழைக்கப்படுகிறது, மேலும் இது மிகவும் திறமையானதாக இருப்பதால் நிரலாக்கத்திற்காக பின்பற்றப்பட வேண்டும். அதன் ஒரு நன்மை என்னவென்றால், குறியீட்டில் மாற்றங்களைச் செய்ய வேண்டியிருக்கும் போது, ​​முழுமையான குறியீட்டை மாற்றுவதற்குப் பதிலாக, சம்பந்தப்பட்ட செயல்பாட்டை மாற்றலாம். இந்த அணுகுமுறையைப் பயன்படுத்தி ஒரு எண்ணின் காரணியைக் கண்டுபிடிப்பதற்கான குறியீடு கீழே காட்டப்பட்டுள்ளது

# ஒரு முழு மதிப்பை ஒரு அளவுருவாக எடுத்து ஒரு முழு எண்ணின் மதிப்பை அளிக்கும் காரணியாலைக் கணக்கிடுவதற்கான நீண்ட காரணியாலான (int num) // செயல்பாட்டைச் சேர்க்கவும் {int i long fact = 1 for (i = 1 i<= num i++) fact = fact * i return fact //returns to function call } int main() //execution begins from main() method { int num printf('Enter a number to calculate its factorialn') scanf('%d', &num) if(num<0) //if the input is a negative integer { printf('Factorial is not defined for negative numbers.') } printf('Factorial of %d = %dn', num, factorial(num)) //call to factorial function passing the input as parameter return 0 } 

வெளியீடு - 5 = 120 இன் காரணி

விளக்கம்-

காரணிக்கான கணக்கீடு மற்றும் மரணதண்டனை தொடங்கும் இடத்திலிருந்து முக்கிய முறைக்கு மதிப்பை திருப்புவதற்கு வெவ்வேறு செயல்பாடு பயன்படுத்தப்படுகிறது என்பதைத் தவிர நிரலுக்கான தர்க்கம் ஒன்றே.

மறுநிகழ்வைப் பயன்படுத்தும் காரணி

மறுநிகழ்வு என்பது ஒரு செயல்பாடு தன்னை அழைக்கும் செயல்முறை மற்றும் அதனுடன் தொடர்புடைய செயல்பாடு சுழல்நிலை செயல்பாடு என்று அழைக்கப்படுகிறது. இது இரண்டு பகுதிகளைக் கொண்டுள்ளது- ஒரு அடிப்படை நிலை மற்றும் ஒரு சுழல்நிலை அழைப்பு. அடிப்படை நிபந்தனைக்கான தீர்வு வழங்கப்படுகிறது, அதே நேரத்தில் பெரிய மதிப்பிற்கான தீர்வை சிறிய மதிப்புகளாக மாற்றுவதன் மூலம் தீர்க்க முடியும்.

மறுநிகழ்வைப் பயன்படுத்தி காரணிகளைக் கண்டுபிடிப்பதற்கான குறியீடு கீழே உள்ளது: -

# int int (int) // function prototype int main () {int num printf ('காரணி கண்டுபிடிக்கப்பட வேண்டிய எண்ணை உள்ளிடவும்:') scanf ('% d', & num) if (num<0) { printf('ERROR. Factorial is not defined for negative integers') } printf('Factorial of %d is %d', num, fact(num)) //first call is made return 0 } int fact(int num) { if(num==0) //base condition { return 1 } else{ return(num*fact(num-1)) //recursive call } } 

வெளியீடு - 5 = 120 இன் காரணி

விளக்கம் -பயனர் 5 ஐ உள்ளீடாக உள்ளிடுவார் என்று வைத்துக்கொள்வோம், பின்னர் பிரதான () முறையில் எண்ணின் மதிப்பு 5 ஆகும். Printf அறிக்கையில் (வரி 12) ஓட்டம் செல்லும்போது உண்மைக்கு அழைப்பு (5) செயல்பாடு செய்யப்படுகிறது. இப்போது உண்மைக்கு (5) எண் 5 ஆகும், இது 0 க்கு சமமாக இருக்காது, எனவே ஓட்டம் வேறு அறிக்கைக்குச் செல்கிறது, அங்கு அறிக்கையில் ஒரு சுழல்நிலை அழைப்பு வந்து உண்மை (4) செய்யப்படுகிறது. அடிப்படை நிலை வரை செயல்முறை மீண்டும் நிகழ்கிறது, அதாவது, எண் = 0 அடையும் மற்றும் 1 திரும்பும். இப்போது ஓட்டம் உண்மைக்கு (1) செல்கிறது, அங்கு 1 (உண்மையில் (1) எண் = 1) * 1 (உண்மையிலிருந்து திரும்பிய மதிப்பு (0)) திரும்பும். தேவையான மதிப்பு பெறும் வரை இந்த செயல்முறை மீண்டும் நிகழ்கிறது.

நேரம் மற்றும் விண்வெளி சிக்கலானது - மறுநிகழ்வு வி / எஸ் மறு செய்கை

மறுநிகழ்வுக்கு-

குறித்து நேரம் சிக்கலானது , காரணியாலான 0 மட்டுமே ஒப்பீடு என்பதை நாங்கள் அறிவோம். எனவே டி (0) = 1. வேறு எந்த எண்ணின் காரணியாலாகவும் இந்த செயல்முறை ஒரு ஒப்பீடு, ஒரு பெருக்கல், ஒரு கழித்தல் மற்றும் ஒரு செயல்பாட்டு அழைப்பை உள்ளடக்கியது. எனவே

டி (என்) = டி (என் -1) +3
= டி (என் -2) +6
= டி (என் -3) +9
= & ஹெலிப்.
= T (n-k) + 3k

T (0) = 1 மற்றும் k = n க்கு (n-k) = 0 நமக்குத் தெரியும் என்பதால்

எனவே T (n) = T (0) + 3n
= 1 + 3n

எனவே குறியீட்டின் நேர சிக்கலானது O (n) ஆகும்.

குறித்து விண்வெளி சிக்கலானது, ஒவ்வொரு அழைப்பிற்கும் ஒரு அடுக்கு உருவாக்கப்பட்டது, அதன் மதிப்பு இருக்கும் வரை பராமரிக்கப்படும்கணக்கிடப்பட்டு திரும்பியது. எடுத்துக்காட்டாக n = 5 க்கு பின்வரும் அடுக்குகள் பராமரிக்கப்பட வேண்டும்

f (5) -> f (4) -> f (3) -> f (2) -> f (1) -> f (0)

எஃப் (0) க்கு அழைப்பு வரும் வரை 5 அடுக்குகள் பராமரிக்கப்பட வேண்டும் என்பதை நாம் காணலாம்அறியப்பட்ட மற்றும் திரும்ப. எனவே n காரணிக்கு, n அடுக்குகள் பராமரிக்கப்பட வேண்டும். இதனால் விண்வெளி சிக்கலானதுO (n) ஆகும். N = 5 க்கு 5 அடுக்குகள் இருக்க வேண்டும் என்பதும் மேலே உள்ள படங்களிலிருந்து தெளிவாகிறதுபராமரிக்கப்படுகிறது. எனவே n காரணிக்கு, n அடுக்குகள் பராமரிக்கப்பட வேண்டும். இதனால் விண்வெளி சிக்கலானது O (n) ஆகும்.

மறுபரிசீலனைக்கு-

குறித்து நேர சிக்கலானது, வளையத்திற்குள் n மறு செய்கைகள் உள்ளன, எனவே நேர சிக்கலானது O (n) ஆகும்.

குறித்து விண்வெளி சிக்கலானது, செயல்பாட்டுத் தீர்வுக்கு ஒரே ஒரு அடுக்கு மட்டுமே பராமரிக்கப்பட வேண்டும் மற்றும் ஒரு முழு எண் மாறி பயன்படுத்தப்படுகிறது. எனவே விண்வெளி சிக்கலானது O (1) ஆகும்.

இந்த கட்டுரைக்கு அவ்வளவுதான். C இல் உள்ள காரணியாலான திட்டத்தின் கருத்தை நேர சிக்கல்களுடன் நீங்கள் புரிந்து கொண்டீர்கள் என்று நம்புகிறேன்.

நீங்கள் ஏதேனும் கேள்விகளைக் கண்டால், 'சி இன் காரணியாலான நிரலின்' கருத்துகள் பிரிவில் உங்கள் எல்லா கேள்விகளையும் கேட்க தயங்கவும், எங்கள் குழு பதிலளிப்பதில் மகிழ்ச்சி அடைகிறது.