আমি এখনও এটি পেলাম না। আমি কি কিছু রেখে গেলাম? আমি জানি যে একটি ফ্যাক্টরিয়াল পদ্ধতিটি নতুনদের জন্য একটি সাধারণ উদাহরণ প্রোগ্রাম। তবে এইটিকে পুনরায় ব্যবহারের জন্য কোনও মানক বাস্তবায়ন করা কি কার্যকর হবে না? আমি স্ট্যান্ডার্ড ধরণের (উদাহরণস্বরূপ, দীর্ঘ ...) এবং বিগআইন্টিজার / বিগডিসিমাল সহ এ জাতীয় পদ্ধতি ব্যবহার করতে পারি।
উত্তর:
আমি মনে করি না ফ্যাকটোরিয়াল জন্য একটি লাইব্রেরি ফাংশন রাখা দরকারী হবে। দক্ষ ফ্যাকটোরিয়াল বাস্তবায়নের জন্য গবেষণার একটি ভাল চুক্তি রয়েছে। এখানে কয়েকটি থাবা বাস্তবায়ন রয়েছে।
অ্যাপাচি কমন্স ম্যাথ ম্যাথ ইউটিলেস ক্লাসে কয়েকটি ফ্যাক্টরিয়াল পদ্ধতি রয়েছে ।
public class UsefulMethods {
public static long factorial(int number) {
long result = 1;
for (int factor = 2; factor <= number; factor++) {
result *= factor;
}
return result;
}
}হোল্ডঅফহ্যাঞ্জার দ্বারা বড় সংখ্যা সংস্করণ :
public static BigInteger factorial(BigInteger number) {
BigInteger result = BigInteger.valueOf(1);
for (long factor = 2; factor <= number.longValue(); factor++) {
result = result.multiply(BigInteger.valueOf(factor));
}
return result;
}খালি নগ্ন ফ্যাকটোরিয়ালগুলি অনুশীলনে খুব কমই প্রয়োজন হয়। প্রায়শই আপনার নিম্নলিখিতগুলির একটি প্রয়োজন:
1) একটি ফ্যাক্টরিয়াল অন্য দ্বারা ভাগ করুন, বা
2) আনুমানিক ভাসমান পয়েন্ট উত্তর।
উভয় ক্ষেত্রেই, আপনি সাধারণ কাস্টম সমাধানগুলির সাথে আরও ভাল হন।
ক্ষেত্রে (1), বলুন, যদি x = 90! / 85!, তারপরে আপনি ফলাফলটি x = 86 * 87 * 88 * 89 * 90 হিসাবে 90 গণনা করার প্রয়োজন ছাড়াই গণনা করবেন! স্মৃতিতে :)
ক্ষেত্রে (2), "স্ট্রিলিংয়ের সমীকরণ" এর জন্য গুগল।
BigIntegerMathনিম্নলিখিত হিসাবে পেয়ারা ব্যবহার করুন :
BigInteger factorial = BigIntegerMath.factorial(n);(এর জন্য অনুরূপ কার্যকারিতা int এবং longপাওয়া যায় IntMathএবং LongMathযথাক্রমে।)
যদিও ফ্যাটোরিয়ালগুলি প্রারম্ভিক প্রোগ্রামারটির জন্য একটি দুর্দান্ত অনুশীলন তৈরি করে, তবে বেশিরভাগ ক্ষেত্রে এগুলি খুব বেশি কার্যকর হয় না এবং সকলেই জানে যে কোনও ফ্যাক্টরিয়াল ফাংশন কীভাবে লিখতে হয়, তাই তারা সাধারণত গড় গ্রন্থাগারে নেই।
আমি বিশ্বাস করি এটি একটি সন্ধানের টেবিলের দ্বারা দ্রুততম উপায় হবে:
private static final long[] FACTORIAL_TABLE = initFactorialTable();
private static long[] initFactorialTable() {
final long[] factorialTable = new long[21];
factorialTable[0] = 1;
for (int i=1; i<factorialTable.length; i++)
factorialTable[i] = factorialTable[i-1] * i;
return factorialTable;
}
/**
* Actually, even for {@code long}, it works only until 20 inclusively.
*/
public static long factorial(final int n) {
if ((n < 0) || (n > 20))
throw new OutOfRangeException("n", 0, 20);
return FACTORIAL_TABLE[n];
}নেটিভ টাইপ long(8 বাইট) এর জন্য এটি কেবল ধরে রাখতে পারে20!
20! = 2432902008176640000(10) = 0x 21C3 677C 82B4 0000স্পষ্টতই, 21!ওভারফ্লো হতে হবে।
সুতরাং, নেটিভ ধরণের জন্য long, কেবলমাত্র সর্বাধিক 20!অনুমোদিত, অর্থবোধক এবং সঠিক।
কারণ ঘটনা এত তাড়াতাড়ি বৃদ্ধি পায়, যদি আপনি পুনরাবৃত্তি ব্যবহার করেন তবে স্ট্যাক ওভারফ্লো কোনও সমস্যা নয়। আসলে, 20 এর মান! একটি জাভা দীর্ঘ প্রতিনিধিত্ব করতে পারেন বৃহত্তম। সুতরাং নীচের পদ্ধতিটি হয় ফ্যাকটোরিয়াল (এন) গণনা করবে বা এন খুব বড় হলে একটি অবৈধআর্গুমেন্ট এক্সেকশন নিক্ষেপ করবে।
public long factorial(int n) {
if (n > 20) throw new IllegalArgumentException(n + " is out of range");
return (1 > n) ? 1 : n * factorial(n - 1);
}একই জিনিসটি করার আরেকটি (কুলার) উপায় জাভা 8 এর স্ট্রিম লাইব্রেরিটি এভাবে ব্যবহার করা:
public long factorial(int n) {
if (n > 20) throw new IllegalArgumentException(n + " is out of range");
return LongStream.rangeClosed(1, n).reduce(1, (a, b) -> a * b);
}জাভা 8 এর স্ট্রিম ব্যবহার করে কারখানাগুলিতে আরও পড়ুন
অ্যাপাচি কমন্স ম্যাথ প্যাকেজের একটি কল্পিত পদ্ধতি রয়েছে , আমি মনে করি আপনি এটি ব্যবহার করতে পারেন।
সংক্ষিপ্ত উত্তর হল: পুনরাবৃত্তি ব্যবহার করুন।
আপনি একটি পদ্ধতি তৈরি করতে পারেন এবং একই পদ্ধতিটির অভ্যন্তরে পুনরাবৃত্তভাবে সেই পদ্ধতিটি কল করতে পারেন:
public class factorial {
public static void main(String[] args) {
System.out.println(calc(10));
}
public static long calc(long n) {
if (n <= 1)
return 1;
else
return n * calc(n - 1);
}
}System.out.println(calc(10));করে দেখুন System.out.println(calc(Long.MAX_VALUE));আপনার পরিবর্তনটি বেশ দীর্ঘ স্ট্যাকট্রেস হওয়া উচিত :)
BigInteger। আমি সংখ্যা গৌণিক নিরূপণ করার চেষ্টা 8020যা আমাকে ফলাফলের দিলেন 613578884952214809325384...যা হয়েছে 27831দশমিক স্থান। সুতরাং এমন সংখ্যাগুলির সাথে কাজ করার সময়ও যে কোনও বিশাল Stackoverflowনিক্ষেপ করা হবে না। Youre অধিকার অবশ্যই শুনব কিন্তু আমি সন্দেহ নেই সংখ্যার একটি practial ব্যবহার সঙ্গে :-) বড়
এটা চেষ্টা কর
public static BigInteger factorial(int value){
if(value < 0){
throw new IllegalArgumentException("Value must be positive");
}
BigInteger result = BigInteger.ONE;
for (int i = 2; i <= value; i++) {
result = result.multiply(BigInteger.valueOf(i));
}
return result;
}i <= value। লুপটি কিছুটা অপ্টিমাইজড হতে পারে (int i = 2; i <= value; i++)।
আমি প্রায় অর্ধেকের প্রকৃত গুণাগুণগুলিতে ফ্যাক্টরিয়ালগুলি খুঁজে পেতে একটি আশ্চর্যজনক কৌশল পেয়েছি।
এটি দীর্ঘ পোস্টের সামান্য বিট হিসাবে ধৈর্য ধরুন।
এমনকি সংখ্যার জন্য: এমনকি সংখ্যার সাথে গুণকে অর্ধেক করতে, আপনি এন / 2 ফ্যাক্টর দিয়ে শেষ করবেন। প্রথম ফ্যাক্টরটি এমন সংখ্যার হবে যা আপনি ফ্যাক্টরিয়ালটি নিচ্ছেন, তারপরের পরেরটিটি হবে সেই সংখ্যার সাথে আরও দুটি নম্বর বিয়োগফল। পরের সংখ্যাটি পূর্বের সংখ্যাটি প্লাস হিসাবে শেষ সংযুক্ত নম্বর বিয়োগ দুটি হবে। আপনি যুক্ত করেছেন যখন আপনি যুক্ত করেছিলেন শেষ সংখ্যাটি দুটি (অর্থাত্ 2) । এটি সম্ভবত খুব বেশি অর্থবহ হয়নি, তাই আপনাকে একটি উদাহরণ দিন give
8! = 8 * (8 + 6 = 14) * (14 + 4 = 18) * (18 + 2 = 20)
8! = 8 * 14 * 18 * 20 which is **40320** নোট করুন যে আমি 8 দিয়ে শুরু করেছি, তারপরে আমি যুক্ত হওয়া প্রথম সংখ্যাটি ছিল 6, তারপরে 4, তারপরে 2, প্রতিটি সংখ্যা দুটি সংখ্যক কম হওয়ার পরে তার আগে সংখ্যাটি যুক্ত হয়েছিল। এই পদ্ধতিটি হ'ল সর্বাধিক সংখ্যার সাথে কম সংখ্যাকে, যেমন কম সংখ্যার সাথে গুন করার সমান:
8! = 1 * 2 * 3 * 4 * 5 * 6 * 7 *
8! = (1 * 8) * (2 * 7) * (3 * 6) * (4 * 5)
8! = 8 * 14 * 18 * 20সহজ এটা না :)
এখন বিজোড় সংখ্যাগুলির জন্য: যদি সংখ্যাটি বিজোড় হয় তবে অ্যাডিংটি একই হয়, আপনার মধ্যে প্রতিবার দুটি বিয়োগ করলেও আপনি তিনটি স্থানে থামবেন। কারণগুলির সংখ্যা পরিবর্তিত হয়। আপনি যদি সংখ্যাটি দুটি দিয়ে ভাগ করেন তবে আপনি কিছু নম্বর শেষ করবেন।। কারণটি হ'ল আমরা যদি শেষগুলি এক সাথে গুণ করি তবে আমাদের মাঝের সংখ্যাটি থাকবে with মূলত, দুটি ভাগ করে বিভক্ত সংখ্যার সমান সংখ্যক কারণের জন্য সমাধান করে এগুলি সব সমাধান করা যেতে পারে। গাণিতিক পটভূমি ব্যতীত এটি সম্ভবত মনের পক্ষে খুব একটা বোঝায় না, তাই আমাকে একটি উদাহরণ দেওয়া যাক:
9! = 9 * (9 + 7 = 16) * (16 + 5 = 21) * (21 + 3 = 24) * (roundUp(9/2) = 5)
9! = 9 * 16 * 21 * 24 * 5 = **362880**বিঃদ্রঃ: আপনি যদি এই পদ্ধতিটি পছন্দ না করেন তবে আপনি বিজোড় (এই ক্ষেত্রে আট) এর আগে এমনকি সমান সংখ্যার ফ্যাক্টরিয়ালটি নিতে পারেন এবং বিজোড় সংখ্যা দ্বারা (যেমন 9! = 8! * 9) দ্বারা এটি গুণতে পারেন।
এখন এটি জাভাতে প্রয়োগ করুন:
public static int getFactorial(int num)
{
int factorial=1;
int diffrennceFromActualNum=0;
int previousSum=num;
if(num==0) //Returning 1 as factorial if number is 0
return 1;
if(num%2==0)// Checking if Number is odd or even
{
while(num-diffrennceFromActualNum>=2)
{
if(!isFirst)
{
previousSum=previousSum+(num-diffrennceFromActualNum);
}
isFirst=false;
factorial*=previousSum;
diffrennceFromActualNum+=2;
}
}
else // In Odd Case (Number * getFactorial(Number-1))
{
factorial=num*getFactorial(num-1);
}
return factorial;
}isFirstস্থায়ী হিসাবে ঘোষিত একটি বুলিয়ান পরিবর্তনশীল; এটি 1 ম ক্ষেত্রে ব্যবহৃত হয় যেখানে আমরা আগের যোগফলটি পরিবর্তন করতে চাই না।
এমনকি অদ্ভুত সংখ্যার জন্য চেষ্টা করুন।
আপনি পুনরাবৃত্তি ব্যবহার করতে পারেন।
public static int factorial(int n){
if (n == 0)
return 1;
else
return(n * factorial(n-1));
}এবং তারপরে আপনি উপরের পদ্ধতিটি (ফাংশন) তৈরি করার পরে:
System.out.println(factorial(number of your choice));
//direct example
System.out.println(factorial(3));আমি যে কল্পনা সম্পর্কিত ভাবতে পারি তার একমাত্র ব্যবসায়িক ব্যবহার হ'ল এরলং বি এবং এরলং সি সূত্রগুলি, এবং প্রত্যেকেই কোনও কল সেন্টারে বা ফোন সংস্থার জন্য কাজ করে না। ব্যবসায়ের জন্য কোনও বৈশিষ্ট্যের উপযোগিতা প্রায়শই কোনও ভাষায় কী প্রদর্শিত হয় তা নির্ধারিত বলে মনে হয় - প্রধান ভাষাগুলিতে সমস্ত ডেটা হ্যান্ডলিং, এক্সএমএল এবং ওয়েব ফাংশনগুলি দেখুন।
এরকম কিছু করার জন্য একটি কল্পিত স্নিপেট বা লাইব্রেরি ফাংশন রাখা সহজ।
ফ্যাকটোরিয়াল গণনা করার জন্য একটি খুব সাধারণ পদ্ধতি:
private double FACT(double n) {
double num = n;
double total = 1;
if(num != 0 | num != 1){
total = num;
}else if(num == 1 | num == 0){
total = 1;
}
double num2;
while(num > 1){
num2 = num - 1;
total = total * num2;
num = num - 1;
}
return total;
}আমি ডাবল ব্যবহার করেছি কারণ তারা প্রচুর সংখ্যা ধরে রাখতে পারে তবে আপনি অন্য কোনও ধরণের যেমন ইনট, লং, ফ্লোট ইত্যাদি ব্যবহার করতে পারেন
পিএস এটি সর্বোত্তম সমাধান নাও হতে পারে তবে আমি কোডিংয়ে নতুন এবং আমার পক্ষে এমন একটি সাধারণ কোড খুঁজে পেতে আমার বয়স হয়েছিল যা ফ্যাক্টরিয়ালগুলি গণনা করতে পারে তাই আমাকে নিজেই পদ্ধতিটি লিখতে হয়েছিল তবে আমি এটি এখানে রেখে দিচ্ছি যাতে এটি আমার মতো অন্যান্য ব্যক্তিকে সহায়তা করে ।
আপনি পাশাপাশি পুনরাবৃত্তি সংস্করণ ব্যবহার করতে পারেন।
static int myFactorial(int i) {
if(i == 1)
return;
else
System.out.prinln(i * (myFactorial(--i)));
}পুনরাবৃত্তি সাধারণত পশ এবং পপ পুনরাবৃত্তি থাকার কারণে কম দক্ষ হয়, তাই পুনরাবৃত্তি দ্রুত হয়। অন্যদিকে, পুনরাবৃত্ত সংস্করণগুলি কম বা কোনও স্থানীয় ভেরিয়েবল ব্যবহার করে যা সুবিধা।
ফ্যাক্টরিয়াল অত্যন্ত বিচ্ছিন্ন ক্রিয়াকলাপ বৃদ্ধি করছে I সুতরাং আমি মনে করি বিগইন্টিজার ব্যবহার করা ইনট ব্যবহারের চেয়ে ভাল। আমি অ-নেতিবাচক পূর্ণসংখ্যার ফ্যাকটোরিয়াল গণনা করার জন্য নিম্নলিখিত কোডগুলি প্রয়োগ করেছি I আমি একটি লুপ ব্যবহারের জায়গায় পুনরাবৃত্তি ব্যবহার করেছি।
public BigInteger factorial(BigInteger x){
if(x.compareTo(new BigInteger("1"))==0||x.compareTo(new BigInteger("0"))==0)
return new BigInteger("1");
else return x.multiply(factorial(x.subtract(new BigInteger("1"))));
}এখানে বড় পূর্ণসংখ্যার পরিসীমা
-2^Integer.MAX_VALUE (exclusive) to +2^Integer.MAX_VALUE,
where Integer.MAX_VALUE=2^31.তবে উপরে বর্ণিত ফ্যাক্টরিয়াল পদ্ধতির পরিসীমাটি স্বাক্ষরবিহীন বিগইন্টিজার ব্যবহার করে দ্বিগুণ পর্যন্ত বাড়ানো যেতে পারে।
এটি গণনা করার জন্য আমাদের কাছে একটি লাইন রয়েছে:
Long factorialNumber = LongStream.rangeClosed(2, N).reduce(1, Math::multiplyExact);একটি মোটামুটি সহজ পদ্ধতি
for ( int i = 1; i < n ; i++ )
{
answer = answer * i;
} /**
import java liberary class
*/
import java.util.Scanner;
/* class to find factorial of a number
*/
public class factorial
{
public static void main(String[] args)
{
// scanner method for read keayboard values
Scanner factor= new Scanner(System.in);
int n;
double total = 1;
double sum= 1;
System.out.println("\nPlease enter an integer: ");
n = factor.nextInt();
// evaluvate the integer is greater than zero and calculate factorial
if(n==0)
{
System.out.println(" Factorial of 0 is 1");
}
else if (n>0)
{
System.out.println("\nThe factorial of " + n + " is " );
System.out.print(n);
for(int i=1;i<n;i++)
{
do // do while loop for display each integer in the factorial
{
System.out.print("*"+(n-i) );
}
while ( n == 1);
total = total * i;
}
// calculate factorial
sum= total * n;
// display sum of factorial
System.out.println("\n\nThe "+ n +" Factorial is : "+" "+ sum);
}
// display invalid entry, if enter a value less than zero
else
{
System.out.println("\nInvalid entry!!");
}System.exit(0);
}
}public static int fact(int i){
if(i==0)
return 0;
if(i>1){
i = i * fact(--i);
}
return i;
}আমাদের পুনরুক্তি প্রয়োগ করতে হবে। যদি আমরা পুনরাবৃত্তির সাথে প্রয়োগ করি তবে ইনপুট খুব বড় হয়ে গেলে (অর্থাত্ 2 বিলিয়ন) এটি স্ট্যাক ওভারফ্রোলার কারণ হয়ে দাঁড়ায়। আর যখন কোনও ফ্যাক্টরিয়াল সংখ্যা একটি প্রদত্ত ধরণের সর্বাধিক সংখ্যার চেয়ে বড় হয়ে যায় (অর্থাত্ 2 বিলিয়ন ডলার) তখন গাণিতিক ওভারফ্লো এড়ানোর জন্য আমাদের বিগইন্টিজারের মতো আনবাউন্ড সাইজ নম্বর ব্যবহার করা উচিত। আপনি ওভারফ্লোয়ের পূর্বে সর্বাধিক 14 এর জন্য ইন্টিরিওরিয়াল এবং সর্বাধিক 20 টি ফ্যাকটোরিলের জন্য দীর্ঘ ব্যবহার করতে পারেন।
public BigInteger getFactorialIteratively(BigInteger input) {
if (input.compareTo(BigInteger.ZERO) <= 0) {
throw new IllegalArgumentException("zero or negatives are not allowed");
}
BigInteger result = BigInteger.ONE;
for (BigInteger i = BigInteger.ONE; i.compareTo(input) <= 0; i = i.add(BigInteger.ONE)) {
result = result.multiply(i);
}
return result;
}আপনি যদি BigInteger ব্যবহার করতে না পারেন তবে একটি ত্রুটি পরীক্ষা করে যুক্ত করুন।
public long getFactorialIteratively(long input) {
if (input <= 0) {
throw new IllegalArgumentException("zero or negatives are not allowed");
} else if (input == 1) {
return 1;
}
long prev = 1;
long result = 0;
for (long i = 2; i <= input; i++) {
result = prev * i;
if (result / prev != i) { // check if result holds the definition of factorial
// arithmatic overflow, error out
throw new RuntimeException("value "+i+" is too big to calculate a factorial, prev:"+prev+", current:"+result);
}
prev = result;
}
return result;
}public int factorial(int num) {
if (num == 1) return 1;
return num * factorial(num - 1);
}লুপ চলাকালীন (স্বল্প সংখ্যার জন্য)
public class factorial {
public static void main(String[] args) {
int counter=1, sum=1;
while (counter<=10) {
sum=sum*counter;
counter++;
}
System.out.println("Factorial of 10 is " +sum);
}
}পুনরাবৃত্তি সহ:
public static int factorial(int n)
{
if(n == 1)
{
return 1;
}
return n * factorial(n-1);
}লুপ লুপ সহ:
public static int factorial1(int n)
{
int fact=1;
while(n>=1)
{
fact=fact*n;
n--;
}
return fact;
}ডায়নামিক প্রোগ্রামার ব্যবহার করা কার্যকর IS
আপনি যদি বার বার গণনা করতে এটি ব্যবহার করতে চান (ক্যাশে করার মতো)
জাভা কোড:
int fact[]=new int[n+1]; //n is the required number you want to find factorial for.
int factorial(int num)
{
if(num==0){
fact[num]=1;
return fact[num];
}
else
fact[num]=(num)*factorial(num-1);
return fact[num];
}পুনরাবৃত্তি ব্যবহার করা সহজতম পদ্ধতি। যদি আমরা এন এর বর্ণনাকারী সন্ধান করতে চাই, আমাদের দুটি ক্ষেত্রে বিবেচনা করতে হবে যেখানে এন = 1 এবং এন> 1 যেহেতু বাস্তবিকভাবে আমরা N, N-1, N-2 ,,,,, 1 পর্যন্ত গুণ করি if N = 0 এ যান আমরা উত্তরের জন্য 0 পাই। ফ্যাক্টরিয়ালটি শূন্যে পৌঁছানো বন্ধ করতে, নিম্নলিখিত পুনরাবৃত্ত পদ্ধতিটি ব্যবহৃত হয়। ফ্যাক্টরিয়াল ফাংশনের অভ্যন্তরে, এন> 1 এ, রিটার্নের মানটি ফ্যাক্টরিয়াল ফাংশনের আরম্ভের সাথে গুণিত হয়। এটি কোডটি পুনরাবৃত্তভাবে কল্পনার () কল করে রাখবে যতক্ষণ না এটি এন = 1 কে পৌঁছায় ততক্ষণ এটি এন (= 1) নিজেই ফিরে আসে এবং বহুগুণিত রিটার্নের পূর্বে নির্মিত সমস্ত ফলাফল এন এর সাথে গুণিত হয় = 1। সুতরাং ঘটনাগত ফলাফল দেয়।
static int factorial(int N) {
if(N > 1) {
return n * factorial(N - 1);
}
// Base Case N = 1
else {
return N;
}