సి లో కారకమైన ప్రోగ్రామ్: సంఖ్య యొక్క కారకాన్ని ఎలా లెక్కించాలి?

సానుకూల పూర్ణాంకం యొక్క కారకం ఒక పూర్ణాంకం యొక్క ఉత్పత్తి మరియు దాని క్రింద ఉన్న అన్ని పూర్ణాంకాలు, అనగా, సంఖ్య n యొక్క కారకమైనది (n చేత ప్రాతినిధ్యం వహిస్తుంది)

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

0 యొక్క కారకమైనది 1 గా నిర్వచించబడింది మరియు ప్రతికూల పూర్ణాంకాల కోసం నిర్వచించబడలేదు. దిగువ జాబితా చేయబడిన దాన్ని కనుగొనడానికి అనేక మార్గాలు ఉన్నాయి-

• సి లో కారకమైన కార్యక్రమంఫర్ లూప్ ఉపయోగించి
• ఉపయోగించి ఫ్యాక్టోరియల్ ప్రోగ్రామ్విధులు
• కారకమైన కార్యక్రమంపునరావృతం ఉపయోగించి

ప్రారంభిద్దాం.

లూప్ కోసం ఫ్యాక్టోరియల్ యూజింగ్

సంఖ్య యొక్క కారకాన్ని కనుగొనడానికి ఇది సులభమైన మరియు సరళమైన మార్గం. మొదట కోడ్‌ను సందర్శిద్దాం -

# 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 -> fact = 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 -> fact = 24 * 5 = 120 -> i = 6

ఇప్పుడు 6> 5, కాబట్టి పరీక్ష పరిస్థితి తప్పు అవుతుంది మరియు లూప్ ఆపివేయబడుతుంది. కారకమైన విలువ ప్రదర్శించబడుతుంది.

ఫంక్షనల్ యూజింగ్ ఫంక్షన్స్

ఈ విధానాన్ని మాడ్యులర్ విధానం అని పిలుస్తారు మరియు ప్రోగ్రామింగ్ కోసం ఇది చాలా సమర్థవంతంగా ఉంటుంది. దాని ప్రయోజనాల్లో ఒకటి ఏమిటంటే, మనం కోడ్‌లో మార్పులు చేయాల్సిన అవసరం వచ్చినప్పుడు పూర్తి కోడ్‌ను మార్చడానికి బదులుగా, సంబంధిత ఫంక్షన్‌ను సవరించవచ్చు. ఈ విధానాన్ని ఉపయోగించి సంఖ్య యొక్క కారకాన్ని కనుగొనటానికి కోడ్ క్రింద చూపబడింది

# పూర్ణాంక విలువను పరామితిగా తీసుకొని పూర్ణాంక రకం విలువను తిరిగి ఇచ్చే కారకమైన గణన కోసం పొడవైన కారకమైన (పూర్ణాంక సంఖ్య) // ఫంక్షన్‌ను చేర్చండి {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 fact (int) // ఫంక్షన్ ప్రోటోటైప్ 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. ప్రింట్ ఎఫ్ స్టేట్మెంట్ (లైన్ 12) లో ప్రవాహం వెళుతున్నప్పుడు కాల్ టు ఫాక్ట్ (5) ఫంక్షన్ చేయబడుతుంది. ఇప్పుడు వాస్తవానికి (5) సంఖ్య 5, ఇది 0 కి సమానం కాదు, కాబట్టి ప్రవాహం వేరే స్టేట్‌మెంట్‌కు వెళుతుంది, ఇక్కడ రిటర్న్ స్టేట్‌మెంట్‌లో పునరావృత కాల్ చేయబడుతుంది మరియు వాస్తవం (4) చేయబడుతుంది. బేస్ కండిషన్ వరకు ఈ ప్రక్రియ పునరావృతమవుతుంది, అనగా, num = 0 చేరుకుంటుంది మరియు 1 తిరిగి వస్తుంది. ఇప్పుడు ప్రవాహం వాస్తవం (1) నుండి 1 (వాస్తవానికి (1) సంఖ్య = 1) * 1 (వాస్తవం (0) నుండి తిరిగి వచ్చిన విలువ) తిరిగి వస్తుంది. అవసరమైన విలువను పొందే వరకు ఈ ప్రక్రియ పునరావృతమవుతుంది.

సమయం & అంతరిక్ష సంక్లిష్టత - పునరావృత V / S పునరావృతం

పునరావృతం కోసం-

సంబంధించి సమయం సంక్లిష్టత , కారకమైన 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 + 3 ఎన్

కాబట్టి కోడ్ యొక్క సమయ సంక్లిష్టత O (n).

సంబంధించి స్థల సంక్లిష్టత, ప్రతి కాల్ కోసం ఒక స్టాక్ సృష్టించబడుతుంది, దాని విలువ వచ్చేవరకు నిర్వహించబడుతుందిగణించి తిరిగి వచ్చింది. ఉదాహరణకు n = 5 కోసం ఈ క్రింది స్టాక్‌లను నిర్వహించాలి

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

మనం చూడగలిగినట్లుగా, f (0) కు కాల్ వచ్చేవరకు 5 స్టాక్‌లను నిర్వహించాల్సి ఉంటుందితెలిసిన మరియు తిరిగి. కాబట్టి n కారకమైన కోసం, n స్టాక్‌లను నిర్వహించాల్సి ఉంటుంది. అందువలన స్థలం సంక్లిష్టతO (n). పై చిత్రాల నుండి కూడా స్పష్టంగా తెలుస్తుంది n = 5 కొరకు, 5 స్టాక్‌లు ఉండాలినిర్వహించబడుతుంది. కాబట్టి n కారకమైన కోసం, n స్టాక్‌లను నిర్వహించాల్సి ఉంటుంది. అందువలన అంతరిక్ష సంక్లిష్టత O (n).

పునరావృతం కోసం-

సంబంధించి సమయం సంక్లిష్టత, లూప్ లోపల n పునరావృత్తులు ఉన్నాయి, కాబట్టి సమయ సంక్లిష్టత O (n).

సంబంధించి స్థల సంక్లిష్టత, పునరుత్పాదక పరిష్కారం కోసం ఒకే స్టాక్ మాత్రమే నిర్వహించాల్సిన అవసరం ఉంది మరియు పూర్ణాంక వేరియబుల్ ఉపయోగించబడుతుంది. కాబట్టి స్థల సంక్లిష్టత O (1).

ఈ వ్యాసం కోసం అంతే. సమయ సంక్లిష్టతలతో పాటు సి లోని కారకమైన ప్రోగ్రామ్ యొక్క భావనను మీరు అర్థం చేసుకున్నారని నేను ఆశిస్తున్నాను.

మీకు ఏవైనా ప్రశ్నలు వస్తే, “సిలోని కారకమైన ప్రోగ్రామ్” యొక్క వ్యాఖ్యల విభాగంలో మీ ప్రశ్నలన్నింటినీ అడగడానికి సంకోచించకండి మరియు మా బృందం సమాధానం ఇవ్వడానికి సంతోషిస్తుంది.