c# - Pow(x, y) फ़ंक्शन के वर्कफ़्लो क्या है?




recursion workflow (4)

इस पुनरावर्ती व्यवहार में प्रत्येक क्रिया को समझने में सक्षम होने के लिए सभी विवरणों को देखें कि वास्तव में क्या चल रहा है। जैसे कि :

using System;
namespace Tester
{
    class test 
    {
        // What Pow actually does:
        static double logPow(double x, int y) {
            var old = x; // Hold the x
            for (var i = 0; i < y; i++){ // do it y times
                x = old * x; // Multiply with it's first self
            }
            return x;
        }
        static int counter = 0;
        static double Pow(double x, int y) {
            counter++;
            Console.Write("Recursive action[" + counter + "] Y status ["+ y +"] : ");
            if (y == 0)
            {
                Console.Write("return 1.0 = " + logPow(x, y) + " \n");
                return 1.0;
            }
            else
            {
                Console.Write("return " + x + " * Pow(" + x + ", " + y + " - 1) = " + logPow(x,y-1) + " \n");
                return x * Pow(x, y - 1);
            }
        }
        static void Main() {
            Console.Write("Last Result : " + Pow(2, 5)); 
        }
    }
}

जो परिणाम देता है:

Recursive action[1] Y status [5] : return 2 * Pow(2, 5 - 1) = 32 
Recursive action[2] Y status [4] : return 2 * Pow(2, 4 - 1) = 16 
Recursive action[3] Y status [3] : return 2 * Pow(2, 3 - 1) = 8 
Recursive action[4] Y status [2] : return 2 * Pow(2, 2 - 1) = 4 
Recursive action[5] Y status [1] : return 2 * Pow(2, 1 - 1) = 2 
Recursive action[6] Y status [0] : return 1.0 = 2 
Last Result : 32

आप इन विवरणों को देखकर अपना कोड डीबग कर सकते हैं। इसके अलावा आप इस लिंक का उपयोग करके इसके साथ मज़े कर सकते हैं: https://onlinegdb.com/Bysbxat9H

मैं सी # सीखने की कोशिश करने के लिए "सोलोलन" और udemy पाठ्यक्रमों से गुजर रहा हूं। मैं चुनौतियां कर रहा हूं, लेकिन यह पता नहीं लगा सका कि नीचे दिया गया कोड 32 के साथ कैसे हुआ (32 के रूप में यहां सही उत्तर है और मैं यह पता लगाने की कोशिश कर रहा हूं कि क्यों)। क्या कोई मुझे इस प्रक्रिया को समझा सकता है, खुद को कॉल करने का तरीका मुझे लगता है कि मुझे फेंक रहा है।

static double Pow(double x, int y)
{
    if (y == 0)
    {
        return 1.0;
    }
    else
    {
        return x * Pow(x, y - 1);
    }
}

static void Main()
{
    Console.Write(Pow(2, 5));
} 

कृपया मेरी खराब कोडिंग का बहाना करें। मैं इसे मोबाइल पर करने की कोशिश कर रहा हूं, जो मुश्किल है, जवाब 32 था। क्या कोई समझा सकता है कि क्यों?

संपादित करें: यहाँ मैं कैसे इसके माध्यम से काम करता है Aplogies। 2 और 5 को पास करें, जांचें कि क्या y == 0 जो गलत है, अब y == 5 इसलिए x * pow(x, y-1) फॉर्मूला सक्रिय होगा। X अभी भी 2 है, y अब 4 है जिसका अर्थ है कि यह फिर से चेक को विफल कर देता है कि क्या यह 0 के बराबर है, यह लूप 1.0 पर वापस आने तक जारी रहता है, x 2 पर बना हुआ है इसलिए 2 * 1.0 = 2 और 32 नहीं?


इसके पुनरावृत्ति को नमस्कार और यह y=1 तक दोहराता है, फिर 2 वापस लौटें, फिर 4, 8, 16, 32 को फिर से समाप्त करें। 2^5=32


पहली बात यह है कि यह नहीं है कि आप सामान्य रूप से एक पावर फंक्शन कैसे लागू करेंगे। यह पुनरावृत्ति प्रदर्शित करने के लिए इस तरह से किया जाता है।

उस रास्ते से, आइए देखें कि जब आप Pow(2, 5) कहते हैं तो क्या होता है:

Pow(x = 2, y = 5)
    -> return 2 * Pow(2, 4)
<- 2 * 16 = 32

  Pow(x = 2, y = 4)
      -> return 2 * Pow(2, 3)
  <- 2 * 8 = 16

    Pow(x = 2, y = 3)
        -> return 2 * Pow(2, 2)
    <- 2 * 4 = 8

      Pow(x = 2, y = 2)
          -> return 2 * Pow(2, 1)
      <- 2 * 2 = 4

        Pow(x = 2, y = 1)
            -> return 2 * Pow(2, 0)
        <- 2 * 1 = 2

          Pow(x = 2, y = 0)
              -> return 1 (because y == 0)
          <- 1

पुनरावर्ती कॉल स्टैक के इस प्रतिनिधित्व को पढ़ने के लिए, ऊपर से नीचे तक अपने तरीके से काम करें कि कैसे तर्क बदलते हैं; फिर वापस लौटने के मूल्यों (जो मैं <- साथ इंगित करता हूं) को देखते हुए नीचे से ऊपर तक अपना रास्ता बनाता हूं।


यह पद्धति मूल रूप से " x को y की शक्ति तक बढ़ाती है" की गणना करती है। यह एक पुनरावर्ती तरीके से करता है।

सबसे पहले, यह एक आधार मामले को परिभाषित करता है: 0 की शक्ति के लिए उठाया गया कुछ भी 1 है।

फिर, यह परिभाषित करता है कि अन्य सभी मामलों में क्या करना है: x * Pow(x, y - 1) । मान लें कि y बड़ा है, x * Pow(x, y - 1) क्या है? यह x * x * Pow(x, y - 2) , जो बदले में x * x * x * Pow(x, y - 3) । यहाँ पैटर्न देखें? आखिरकार, आप उस बिंदु पर पहुंच जाएंगे जहां दूसरा तर्क, y - N , 0 है, जिसे हमने स्थापित किया है, 1. वह बिंदु पर, हमें कितने x * मिले हैं? बिल्कुल y

आइए देखें कि यह कार्रवाई Pow(2, 5) :

Pow(2, 5)
2 * Pow(2, 4)
2 * 2 * Pow(2, 3)
2 * 2 * 2 * Pow(2, 2)
2 * 2 * 2 * 2 * Pow(2, 1)
2 * 2 * 2 * 2 * 2 * Pow(2, 0)
2 * 2 * 2 * 2 * 2 * 1

इसलिए परिणाम 32।





pow