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

ఈ రోజు మనం ఫాక్టోరియల్స్ మరియు కారకాన్ని కనుగొనే అత్యంత సాధారణ మార్గాల గురించి మాట్లాడబోతున్నాం. ప్రోగ్రామర్ తెలుసుకోవలసిన మరియు పని చేయగలిగిన అత్యంత ప్రాథమిక విధుల్లో ఇది ఒకటి. సరే, ప్రారంభిద్దాం. సంఖ్య n యొక్క కారకం, n!గా సూచించబడుతుంది, ఇది 1 నుండి n వరకు ఉన్న అన్ని సహజ సంఖ్యల ఉత్పత్తి (గుణకారం) యొక్క విలువ. ఇది ఎలా ఉంటుందో ఇక్కడ ఉంది (మీ గణిత పరిజ్ఞానాన్ని రిఫ్రెష్ చేద్దాం): మరియు 0కి మరో చిన్న నియమం ఉంది: మనం 6 మధ్య వ్యత్యాసాన్ని లెక్కించాలనుకుంటే! మరియు 4!: ప్రోగ్రామింగ్‌లో అమలు చేసినప్పుడు ఇది ఎలా ఉంటుందో చూద్దాం. మేము జావాలో కారకం యొక్క గణనలను ఎలా చేయాలో కొన్ని మార్గాలను అన్వేషిస్తాము.

ఫాక్టోరియల్ ప్రోగ్రామ్‌లో సాధారణ పరిష్కారం

లూప్‌ని ఉపయోగించే ఒక సాధారణ కారకం ప్రోగ్రామ్ ఇక్కడ ఉంది:

class FactorialExample{  
 public static void main(String args[]){  
  int i,fact=1;  
  int number=7;// our number to do the necessary calculations in class Factorial    
  for(i=1;i<=number;i++){    
      fact=fact*i;    
  }    
  System.out.println("Factorial of "+number+" is: "+fact);    
 }  
}

కన్సోల్‌లో మా అవుట్‌పుట్ ఇలా ఉంటుంది: మరియు విషయాలను క్రమబద్ధీకరించడానికి మరొక ఉదాహరణ:

public static int getFactorial(int f) {
  int result = 1;
  for (int i = 1; i <= f; i++) {
     result = result * i; // finding factorial of number using loops
  }
  return result;
}

ఇక్కడ కష్టం ఏమీ లేదు: మేము పాస్ చేసిన సంఖ్యను మా లూప్ పరిమాణంగా ఉపయోగిస్తాము, దీనిలో మేము fకి వచ్చే వరకు మునుపటి అన్ని సంఖ్యలతో గుణిస్తాము. మరియు ప్రధానంగా:

System.out.println(getFactorial(6) - getFactorial(4));

కోడ్‌ను పరీక్షిస్తున్నప్పుడు, మనకు కావలసిన ఫలితం లభిస్తుందని మేము చూస్తాము: 696.

పునరావృత పరిష్కారం

ఒక పద్ధతి తనను తాను పిలిచినప్పుడు పునరావృతమవుతుంది. ఇటువంటి పద్ధతిని పునరావృత పద్ధతి అంటారు. నియమం ప్రకారం, ఇది రెండు భాగాలను కలిగి ఉంటుంది:

1. ముగించే పరిస్థితి - ముగించే పరిస్థితి సంతృప్తి చెందినప్పుడు, పద్ధతి స్వయంగా కాల్ చేయడం ఆపివేసి, విలువలను పెంచడం ప్రారంభించాలి. అన్నింటికంటే, ముగించే పరిస్థితి లేకుంటే, మనకు StackOverflowError వచ్చే వరకు ఈ పద్ధతి పదేపదే కాల్ చేస్తూ అనంతమైన లూప్‌ని కలిగి ఉంటుంది .
2. ఏ లాజిక్ అయినా పరిస్థితికి అదనంగా రికర్సివ్ కాల్ అవసరం, కానీ వేరే ఇన్‌పుట్ విలువతో.

జావాలో ఫాక్టోరియల్‌ని కనుగొనడం అనేది రికర్షన్‌ను ఎప్పుడు ఉపయోగించాలో సరైన ఉదాహరణ:

public static int getFactorial(int f) { // finding factorial of number using recursive solution
  if (f <= 1) {
     return 1;
  }
  else {
     return f * getFactorial(f - 1);
  }
}

మేము 1కి చేరుకున్నప్పుడు మా పునరావృత ముగింపు పరిస్థితి ఉంటుంది. పరామితి 1 కాకపోతే, మేము పద్ధతికి తదుపరి పునరావృత కాల్ ఫలితం ద్వారా ప్రస్తుత విలువను గుణిస్తాము (దీనికి మనం ప్రస్తుత విలువ మైనస్ 1ని పాస్ చేస్తాము).

స్ట్రీమ్‌తో పరిష్కారం

జావా స్ట్రీమ్ ఫంక్షనాలిటీ గురించి తెలియని ఎవరైనా లేదా వారి మెమరీని రిఫ్రెష్ చేయాలనుకునే ఎవరైనా ఇక్కడ చదవడం ద్వారా ప్రయోజనం పొందుతారు .

public static int getFactorial(int f) { // finding factorial of number using Stream 
  if (f <= 1) {
     return 1;
  }
  else {
     return IntStream.rangeClosed(2, f).reduce((x, y) -> x * y).getAsInt();
  }
}

ఇక్కడ మేము ప్రత్యేక IntStream తరగతిని ఉపయోగిస్తాము, ఇది Int విలువల స్ట్రీమ్‌తో పని చేస్తున్నప్పుడు మాకు అదనపు సామర్థ్యాలను ఇస్తుంది. అటువంటి స్ట్రీమ్‌ను సృష్టించడానికి, మేము దాని స్టాటిక్ రేంజ్ క్లోజ్డ్ పద్ధతిని ఉపయోగిస్తాము, ఇది 2 నుండి f వరకు విలువలను 1 ఇంక్రిమెంట్‌లలో ఉత్పత్తి చేస్తుంది. తర్వాత, మేము అన్ని విలువలను కలపడానికి తగ్గింపు పద్ధతిని ఉపయోగిస్తాము. మరింత ప్రత్యేకంగా, మేము విలువలను ఎలా కలపాలనుకుంటున్నామో దాన్ని చూపుతాము. చివరగా, మేము టెర్మినల్ getAsInt పద్ధతిని ఉపయోగించి ఫలిత విలువను పొందుతాము.

BigIntegerని ఉపయోగిస్తోంది

జావాలో, బిగ్ఇంటెజర్ క్లాస్ తరచుగా సంఖ్యలను, ముఖ్యంగా పెద్ద సంఖ్యలను నిర్వహించడానికి ఉపయోగించబడుతుంది. నిజానికి, మనం int ఉపయోగిస్తే , డేటా నష్టం లేకుండా మనం నిర్వహించగల గరిష్ట కారకం 31. సుదీర్ఘ డేటా రకానికి, గరిష్ట కారకం 39. అయితే మనకు 100 కారకం అవసరమైతే? మునుపటి పరిష్కారాలను BigIntegerకి స్వీకరించండి.

సాధారణ పరిష్కారం

public static BigInteger getFactorial(int f) { // finding factorial of number using BigInteger
  BigInteger result = BigInteger.ONE;
  for (int i = 1; i <= f; i++)
     result = result.multiply(BigInteger.valueOf(i));
  return result;
}

అల్గోరిథం తప్పనిసరిగా ఒకే విధంగా ఉంటుంది, కానీ ఇక్కడ మేము BigInteger యొక్క సామర్థ్యాలను ఉపయోగిస్తాము: BigInteger.ONE అనేది ప్రారంభ విలువ 1, మరియు మునుపటి కారకం విలువ మరియు ప్రస్తుత సంఖ్యను గుణించడానికి గుణించడం() ఉపయోగించబడుతుంది.

పునరావృత పరిష్కారం

public static BigInteger getFactorial(int f) {
  if (f <= 1) {
     return BigInteger.valueOf(1);
  }
  else {
     return BigInteger.valueOf(f).multiply(getFactorial(f - 1));
  }
}

BigIntegerతో పని చేయడానికి కొన్ని పద్ధతులు జోడించబడ్డాయి తప్ప, పరిష్కారం యొక్క సాధారణ తర్కం మారదు.

స్ట్రీమ్‌తో పరిష్కారం

public static BigInteger getFactorial(int f) {
  if (f < 2) {
     return BigInteger.valueOf(1);
  }
  else {
     return IntStream.rangeClosed(2, f).mapToObj(BigInteger::valueOf).reduce(BigInteger::multiply).get();
  }
}

ప్రతిదీ తప్పనిసరిగా ఒకే విధంగా ఉంటుంది, కానీ BigIntegerతో. స్ట్రీమ్ క్లాస్ మాకు mapToObj పద్ధతిని అందజేస్తుంది, మేము పూర్ణాంక విలువలను BigIntegerకి మార్చడానికి ఉపయోగిస్తాము, ఆపై గుణించడం పద్ధతిని ఉపయోగించి వాటిని వాటితో గుణించడం కోసం (మరియు ఐచ్ఛిక రేపర్ నుండి ఒక వస్తువును పొందడానికి గెట్() జోడించబడింది ). మేము ఈ మూడు పద్ధతుల్లో దేనినైనా 100 ఆర్గ్యుమెంట్‌తో అమలు చేస్తే, మేము స్టాక్ ఓవర్‌ఫ్లోను నివారించి సరైన ఫలితాన్ని పొందుతాము: