जावा में रिकर्सन का उपयोग कर फैक्टोरियल

Question

मैं जावा: द पूर्ण संदर्भ पुस्तक का उपयोग कर जावा सीख रहा हूं। वर्तमान में मैं विषय रिकर्सन पर काम कर रहा हूं।

कृपया ध्यान दें: स्टैक ओवरफ्लो पर समान प्रश्न हैं। मैंने उन्हें खोजा लेकिन मुझे अपने प्रश्न का हल नहीं मिला। मैं निम्नलिखित कार्यक्रम में तर्क से उलझन में हूं।

यदि मैं नीचे दिया गया प्रोग्राम चलाता हूं, तो यह सही आउटपुट उत्पन्न करता है, लेकिन मुझे तर्क समझ में नहीं आया।

• मुझे निम्न पंक्ति में तर्क समझ में नहीं आया: परिणाम = तथ्य (एन -1) * एन;
मेरी जानकारी से
• , अगर हम n के मूल्य पारित = 4 के रूप में नीचे कार्यक्रम में दिखाया गया है,
• फिर, 3 * 4 परिणाम यानी, संग्रहीत किया जाता है 12.
• फिर, तथ्य (n- 1) कहा जाता है। फिर एन बन जाता है 3.
• फिर 2 * 3 पिछले 12 को बदलकर परिणाम में संग्रहीत किया जाता है।

• मुझे लगता है कि आप समझ गए हैं कि मैं कहां फंस गया/उलझन में हूं।

• धन्यवाद।

class Calculation 
{ 
    int fact(int n) 
    { 
     int result; 

     if(n==1) 
     return 1; 

     result = fact(n-1) * n; 
     return result; 
    } 
} 

public class Factorial 
{ 
    public static void main(String args[]) 
    { 
     Calculation obj_one = new Calculation(); 

     int a = obj_one.fact(4); 
     System.out.println("The factorial of the number is : " + a); 
    } 
} 

Answer 1

resultfact विधि का स्थानीय चर है। इसलिए प्रत्येक बार तथ्य विधि कहलाती है, परिणाम पिछले तथ्य आमंत्रण की तुलना में एक अलग चर में संग्रहीत किया जाता है।

तो जब तथ्य 3 के साथ शुरू हो जाती है तर्क के रूप में, आप कल्पना कर सकते है कि इसके परिणाम

result3 = fact(2) * 3 
result3 = result2 * 3 
result3 = 1 * 2 * 3 

Answer 2

आपका भ्रम, मुझे विश्वास है, इस तथ्य से आता आपको लगता है कि वहाँ केवल एक ही result चर, वास्तव में वहाँ प्रत्येक समारोह कॉल के लिए एक result चर रहा है, जबकि। इसके लिए, पुराने परिणाम प्रतिस्थापित नहीं किए जाते हैं, लेकिन लौट आए।

विस्तृत करने के:

int fact(int n) 
{ 
    int result; 

    if(n==1) 
    return 1; 

    result = fact(n-1) * n; 
    return result; 
} 

fact(2) के लिए एक कॉल मान लें:

int result; 
if (n == 1) // false, go to next statement 
result = fact(1) * 2; // calls fact(1): 
|  
|fact(1) 
| int result; //different variable 
| if (n == 1) // true 
|  return 1; // this will return 1, i.e. call to fact(1) is 1 
result = 1 * 2; // because fact(1) = 1 
return 2; 

आशा है कि यह अब स्पष्ट है।

Answer 3

प्रमुख मुद्दा है कि आप यहाँ याद आ रही है कि चर "परिणाम" एक ढेर चर रहा है, और इस तरह के रूप में है इसे "प्रतिस्थापित" नहीं मिलता है। विस्तृत करने के लिए, हर बार तथ्य कहलाता है, "परिणाम" नामक एक नया चरक दुभाषिया में आंतरिक रूप से बनाया जाता है और विधियों के उस आमंत्रण से जुड़ा होता है। यह ऑब्जेक्ट फ़ील्ड के विपरीत है जो ऑब्जेक्ट के उदाहरण से जुड़ा हुआ है और एक विशिष्ट विधि कॉल नहीं

Answer 4

सबसे पहले आपको समझना चाहिए कि कैसे फैक्टोरियल काम करता है।

चलो 4 लेते हैं! उदहारण के लिए।

4! = 4 * 3 * 2 * 1 = 24 

हमें ऊपर के उदाहरण का उपयोग कर कोड अनुकरण:

int fact(int n) 
    { 
     int result; 
     if(n==0 || n==1) 
     return 1; 

     result = fact(n-1) * n; 
     return result; 
    } 

सबसे प्रोग्रामिंग भाषा में, हम जिसे हम function stack है। यह सिर्फ ताश के पत्तों के है, जहां प्रत्येक कार्ड अन्य ऊपर रखा गया है की तरह है - और प्रत्येक कार्ड विधि fact पर गुजर तो के रूप में एक समारोह के बारे में सोचा जा सकता है,:

ढेर स्तर 1: fact(4) // n = 4 and is not equal to 1. So we call fact(n-1)*n

ढेर स्तर 2: fact(3)

ढेर स्तर 3: fact(2)

ढेर स्तर 4: fact(1) // अब, एन = 1. इसलिए हम 1 इस समारोह से लौटने।

लौटने मूल्यों ...

ढेर स्तर 3: 2 * fact(1) = 2 * 1 = 2

ढेर स्तर 2: 3 * fact(2) = 3 * 2 = 6

ढेर स्तर 1: 4 * fact(3) = 4 * 6 = 24

तो हम 24.

लें मिला इन पंक्तियों का नोट:

result = fact(n-1) * n; 
      return result; 

या बस:

return fact(n-1) * n; 

इस समारोह में ही कहता है। एक उदाहरण के रूप में 4 का उपयोग करना ..

अनुक्रम में समारोह के अनुसार स्टैक्स,

return fact(3) * 4; 
return fact(2) * 3 * 4 
return fact(1) * 2 * 3 * 4 

परिणाम स्थानापन्न ...

return 1 * 2 * 3 * 4 = return 24 

मुझे आशा है कि आप समझ गए होंगे।

Answer 5

क्या होता है कि रिकर्सिव कॉल स्वयं और पुनरावर्ती व्यवहार में परिणाम देता है। यदि आप इसे लिखना चाहते हैं तो आपको यह मिलता है:

fact(4) 
fact(3) * 4; 
(fact(2) * 3) * 4; 
((fact(1) * 2) * 3) * 4; 
((1 * 2) * 3) * 4; 

Answer 6

हालांकि यह पुराना है, फिर भी यह Google में बहुत अच्छी तरह से आ रहा है। तो मैंने सोचा कि मैं इसका जिक्र करूंगा। x = 0 के लिए जांच करने के लिए कोई भी उल्लेख नहीं किया गया है।

0! और 1! दोनों = 1.

यह पिछले उत्तरों के साथ जांच नहीं किया जा रहा है, और यदि तथ्य (0) चलाया गया था, तो एक स्टैक ओवरफ़्लो का कारण बन जाएगा।वैसे भी उन्हें आसानी से ठीक:

public static int fact(int x){ 
    if (x==1 | x==0) 
     return 1; 
    return fact(x-1) * x; 
}// fact 

Answer 7

नहीं बनाते हैं एक और चर

परिणाम

बस

वापसी तथ्य (n-1) * n;

class Calculation 
{ 
    int fact(int n) 
    { 
     int result; 

     if(n==1) 
     return 1; 

     return fact(n-1) * n; 

    } 
} 

Answer 8

import java.util.Scanner; 

public class Factorial { 
    public static void main(String[] args) { 
     Scanner keyboard = new Scanner(System.in); 
     int n; 
     System.out.println("Enter number: "); 
     n = keyboard.nextInt(); 
     int number = calculatefactorial(n); 
     System.out.println("Factorial: " +number); 
    } 
    public static int calculatefactorial(int n){ 
     int factorialnumbers=1; 
     while(n>0){ 
     factorialnumbers=(int)(factorialnumbers*n--); 
     } 
     return factorialnumbers; 
    } 
} 

Answer 9

मेरी राय में, और कहा कि जावा की शुरुआत स्तर के ज्ञान के साथ किसी की राय जा रहा है, मुझे लगता है कि n == 1 एन < = 1 या परिवर्तित करने का सुझाव देते हैं (एन == 0) || (एन == 1) क्योंकि 0 की भाज्य 1.

Answer 10

public class Factorial2 { 
    public static long factorial(long x) { 
     if (x < 0) 
      throw new IllegalArgumentException("x must be >= 0"); 
     if (x <= 1) 
      return 1; // Stop recursing here 
     else 
      return x * factorial(x-1); // Recurse by calling ourselves 
    } 
} 

Answer 11

त्रिगुट ऑपरेटर का उपयोग करके एक पुनरावर्ती समाधान है।

public static int fac(int n) { 
    return (n < 1) ? 1 : n*fac(n-1); 
} 

Answer 12

सही एक है:

int factorial(int n) 
{ 
    if(n==0||n==1) 
     return 1; 
    else 
     return n*factorial(n-1); 
} 

यह भाज्य 0. के लिए 1 वापसी होगी यह मेरा विश्वास है। मैंने यह कठिन तरीका सीखा है। बस 0 की स्थिति को न रखने के लिए एक साक्षात्कार साफ़ नहीं किया जा सका।

Answer 13

यह समझने के लिए आपको सबसे आसान तरीका संभव में प्रणाली की घोषणा करने के लिए है और Martynas मई 6 वीं पोस्ट पर इसे किसी न किसी:

int fact(int n) { 
    if(n==0) return 1; 
    else return n * fact(n-1); 
} 

उपरोक्त क्रियान्वयन पढ़ सकते हैं और आप समझ जायेंगे।

Answer 14

public class Factorial { 

    public static void main(String[] args) { 
     System.out.println(factorial(4)); 
    } 

    private static long factorial(int i) { 

     if(i<0) throw new IllegalArgumentException("x must be >= 0"); 
     return i==0||i==1? 1:i*factorial(i-1); 
    } 
} 

Answer 15

यहाँ अभी तक कैसे भाज्य गणना का उपयोग कर प्रत्यावर्तन काम करता है की एक और व्याख्या है।

के स्रोत कोड में थोड़ा सा संशोधन करते हैं:

int factorial(int n) { 
     if (n <= 1) 
      return 1; 
     else 
      return n * factorial(n - 1); 
} 

यहाँ 3 की गणना है! विवरण में:

स्रोत: RECURSION (Java, C++) | Algorithms and Data Structures

Answer 16

public class Factorial { 
public static void main(String[] args) { 
    int n = 7; 
    int result = 1; 
    for (int i = 1; i <= n; i++) { 
     result = result * i; 
    } 
    System.out.println("The factorial of 7 is " + result); 
} 
} 

Answer 17

खैर यहाँ तर्क प्रत्यावर्तन का उपयोग कर किसी संख्या का फ़ैक्टोरियल को मिल रहा है,

static int factorialFunction(int n) 
{ 
    int result; 
    if(n == 1) 
    { 
     return 1; 
    } 
    // here we are calling the recursion function 
    result = factorialFunction(n - 1) * n; 
    return result; 
} 

इस बीच आप this संसाधन उल्लेख कर सकते हैं रिकर्सन का उपयोग करके किसी संख्या के फैक्टोरियल पर उदाहरण ढूंढने के लिए।