காரணிக்கான ஜாவா திட்டம்

இன்று நாம் காரணிகள் மற்றும் காரணிகளைக் கண்டுபிடிப்பதற்கான பொதுவான வழிகளைப் பற்றி பேசப் போகிறோம். ஒரு புரோகிராமர் தெரிந்து கொள்ள வேண்டிய மற்றும் வேலை செய்யக்கூடிய மிக அடிப்படையான செயல்பாடுகளில் இதுவும் ஒன்றாகும். சரி, ஆரம்பிக்கலாம். 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 ஐப் பயன்படுத்துதல்

ஜாவாவில், எண்களை குறிப்பாக பெரிய எண்களைக் கையாள 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 ஆக மாற்றுவதற்குப் பயன்படுத்துகிறது, பின்னர் பெருக்கல் முறையைப் பயன்படுத்தி அவற்றைத் தங்களுடன் பெருக்கப் பயன்படுகிறது (மேலும் விருப்பப் போர்வையிலிருந்து ஒரு பொருளைப் பெறுவதற்கு get() சேர்க்கப்பட்டது ). இந்த மூன்று முறைகளில் ஏதேனும் ஒன்றை 100 வாதத்துடன் இயக்கினால், ஸ்டாக் ஓவர்ஃப்ளோவைத் தவிர்த்து, சரியான முடிவைப் பெறுவோம்: