ফ্যাক্টরিয়াল জন্য জাভা প্রোগ্রাম

আজ আমরা ফ্যাক্টরিয়াল এবং ফ্যাক্টরিয়াল খুঁজে পাওয়ার সবচেয়ে সাধারণ উপায় সম্পর্কে কথা বলতে যাচ্ছি। এটি সবচেয়ে মৌলিক ফাংশনগুলির মধ্যে একটি যা একজন প্রোগ্রামারকে জানা এবং কাজ করতে সক্ষম হতে হবে। আচ্ছা, শুরু করা যাক. 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 পাস করি)।

একটি স্ট্রিম সঙ্গে সমাধান

Java এর স্ট্রীম কার্যকারিতার সাথে অপরিচিত যে কেউ, বা যারা তাদের স্মৃতি রিফ্রেশ করতে চান, তারা এখানে পড়ে উপকৃত হবেন ।

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 ক্লাস প্রায়ই সংখ্যাগুলি পরিচালনা করতে ব্যবহৃত হয়, বিশেষ করে BIG সংখ্যাগুলি। প্রকৃতপক্ষে, যদি আমরা int ব্যবহার করি , তাহলে ডেটা ক্ষতি ছাড়াই আমরা সর্বাধিক ফ্যাক্টোরিয়াল পরিচালনা করতে পারি 31। দীর্ঘ ডেটা টাইপের জন্য, সর্বাধিক ফ্যাক্টরিয়াল হল 39। কিন্তু যদি আমাদের 100 এর ফ্যাক্টোরিয়ালের প্রয়োজন হয় তবে কী হবে? আসুন বিগইনটেগারের পূর্ববর্তী সমাধানগুলিকে মানিয়ে নেওয়া যাক।

সাধারণ সমাধান

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, এবং multiply() পূর্ববর্তী ফ্যাক্টোরিয়াল মান এবং বর্তমান সংখ্যাকে গুণ করতে ব্যবহৃত হয়।

পুনরাবৃত্তিমূলক সমাধান

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

বিগইনটেগারের সাথে কাজ করার জন্য কিছু পদ্ধতি যোগ করা ছাড়া সমাধানের সাধারণ যুক্তি পরিবর্তন হয় না।

একটি স্ট্রিম সঙ্গে সমাধান

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 পদ্ধতি দেয়, যা আমরা int মানকে BigInteger-এ রূপান্তর করতে ব্যবহার করি যাতে গুণিত পদ্ধতি ব্যবহার করে তাদের নিজেদের সাথে গুণ করে (এবং ঐচ্ছিক মোড়ক থেকে একটি বস্তু পেতে get() যোগ করা হয়)। যদি আমরা 100 এর আর্গুমেন্ট সহ এই তিনটি পদ্ধতির যে কোনো একটি চালাই, তাহলে আমরা একটি স্ট্যাক ওভারফ্লো এড়াব এবং সঠিক ফলাফল পাব: