व्यायाम - तरीकों से सरणियों को लौटाएं

  • 10 मिनट्स

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

परिवर्तन करने के लिए सिक्के खोजें

मान लीजिए कि आपके पास विभिन्न मूल्यों के कई सिक्के हैं। आपको दो सिक्के खोजने का काम सौंपा गया है जिनका योग लक्ष्य मूल्य के बराबर है। इस अभ्यास में, उपलब्ध सिक्कों को एक पूर्णांक सरणी में दर्शाया जाता है। आपको दो सिक्कों के सूचकांकों को एक नई सरणी में वापस करना होगा। आएँ शुरू करें!

  1. Visual Studio कोड संपादक में, पिछले अभ्यासों से किसी भी मौजूदा कोड हटाएँ।

  2. Visual Studio कोड संपादक में निम्न कोड दर्ज करें:

    int[] TwoCoins(int[] coins, int target) 
{
    return  new int[0];
}

    ऐसे मामले में जहां कोई दो सिक्के नहीं मिलते हैं, आपकी विधि एक खाली सरणी लौटाती है। लौटाए गए परिणाम के सिंटैक्स पर विचार करने के लिए कुछ समय निकालें। जब आप एक नई int[] सरणी को संग्रहीत करने और चर वापस करने के लिए एक चर बना सकते हैं, return तो कथन आपको एक साथ मान बनाने और वापस करने की अनुमति देता है।

  3. इस समस्या को हल करने के लिए कई दृष्टिकोण हैं। इस बात पर विचार करने के लिए कुछ समय निकालें कि आप किसी सरणी में दो संख्याओं की खोज कैसे कर सकते हैं जिनका योग किसी दिए गए मान के बराबर है।

    इस अभ्यास में, निम्नलिखित दृष्टिकोण का उपयोग किया जाएगा:

    1. सरणी से एक संख्या चुनें
    2. यह देखने के लिए कि क्या वे लक्ष्य मान में जुड़ते हैं, एक-एक करके अन्य संख्याओं की जाँच करें
    3. मैच मिलते ही रिजल्ट लौटाएं

  4. सरणी में प्रत्येक संख्या की जाँच करने के लिए, निम्न कोड के TwoCoins साथ विधि को अद्यतन करें:

    int[] TwoCoins(int[] coins, int target) 
{
    for (int curr = 0; curr < coins.Length; curr++) 
    {
        for (int next = curr + 1; next < coins.Length; next++) 
        {

        }
    }

    return  new int[0];
}

    यहां, curr एक निश्चित सिक्का सूचकांक का प्रतिनिधित्व करता है और next बाद के सिक्का सूचकांकों का प्रतिनिधित्व करता है। आप प्रत्येक next सिक्के को निश्चित curr सिक्के के साथ जोड़ने का प्रयास करेंगे यह देखने के लिए कि क्या वे लक्ष्य मूल्य के बराबर हैं।

  5. इसके बाद, लक्ष्य मूल्य के लिए दो सिक्कों के योग की जांच करने के लिए तर्क जोड़ें। ऐसा करने के लिए, निम्न कोड के साथ पिछले for छोरों को अद्यतन करें:

    for (int curr = 0; curr < coins.Length; curr++) 
{
    for (int next = curr + 1; next < coins.Length; next++) 
    {
        if (coins[curr] + coins[next] == target) 
        {
            return new int[]{curr, next};
        }

    }
}

    इस कोड में, आप जांच रहे हैं कि सरणी में currnext और सरणी में मानों का योग लक्ष्य मान के बराबर है या नहीं। यदि योग बराबर है, तो आप उन सूचकांकों को संग्रहीत करने और इसे वापस करने के लिए एक सरणी बनाते हैं। यदि वे समान नहीं हैं, तो आप उन्हें अनदेखा कर सकते हैं और जाँच कर सकते हैं।

अपने समाधान का परीक्षण करें

इस चरण में, आप यह सुनिश्चित करने के लिए अपने कोड का परीक्षण करेंगे कि यह ठीक से चल रहा है। पहले आप इनपुट डेटा को स्टोर करने के लिए कुछ वेरिएबल्स को इनिशियलाइज़ करेंगे, फिर आप मेथड को कॉल करेंगे और परिणाम प्रिंट करेंगे।

  1. विधि हस्ताक्षर के ऊपर TwoCoins एक नई रिक्त कोड पंक्ति बनाएँ। फिर निम्न कोड दर्ज करें:

    int target = 60;
int[] coins = new int[] {5, 5, 50, 25, 25, 10, 5};
int[] result = TwoCoins(coins, target);

    याद रखें कि TwoCoins यदि कोई परिवर्तन नहीं मिलता है तो विधि एक खाली सरणी लौटाती है। सरणी को प्रिंट result करने का प्रयास करने से पहले आपको सरणी आकार की जांच करनी होगी।

  2. एक नई रिक्त कोड पंक्ति दर्ज करें। फिर निम्न कोड दर्ज करें:

    if (result.Length == 0) 
{
    Console.WriteLine("No two coins make change");
} 
else 
{
    Console.WriteLine($"Change found at positions {result[0]} and {result[1]}");
}

  3. यदि आवश्यक हो, तो Visual Studio Code का एकीकृत टर्मिनल पैनल खोलें।

  4. टर्मिनल कमांड प्रॉम्प्ट पर, dotnet run दर्ज करें। निम्नलिखित के साथ अपने आउटपुट की तुलना करें:

    Change found at positions 2 and 5

    अगर आपका कोड अनपेक्षित परिणाम दिखाता है, तो आपको अपनी गड़बड़ी ढूंढने और अपडेट करने के लिए अपने कोड की समीक्षा करनी होगी. यह देखने के लिए कोड फिर से चलाएं कि क्या आपने समस्या ठीक कर दी है। अपना कोड अपडेट करना और चलाना तब तक जारी रखें जब तक कि आपका कोड अपेक्षित परिणाम न दे।

परिवर्तन करने वाले सिक्कों के कई जोड़े खोजें

इस चरण में, आप सिक्कों के अधिक जोड़े खोजने के लिए विधि का विस्तार TwoCoins करेंगे जिनका योग लक्ष्य मूल्य के बराबर है। इस अभ्यास के लिए, आपको अधिकतम पांच जोड़े मिलेंगे। इसका मतलब है कि रिटर्न प्रकार 1 डी सरणी के बजाय 2 डी सरणी होगा, और आपको अपने कोड के परिणाम देने के तरीके को संशोधित करने की आवश्यकता होगी। आएँ शुरू करें!

  1. विधि हस्ताक्षर में वापसी प्रकार को परिवर्तित करने के int[] लिए int[,] से अपने कोड को निम्न में अद्यतन करके:

    int[,] TwoCoins(int[] coins, int target)

    इसके बाद, आप अपने परिणामों को संग्रहीत करने और वापस करने के लिए एक int[,] सरणी बनाएंगे, और सरणी में जोड़े गए जोड़े की संख्या का ट्रैक रखने के लिए एक काउंटर चर बनाएंगे।

  2. TwoCoins विधि को निम्न कोड से अद्यतन करें:

    int[,] TwoCoins(int[] coins, int target) 
{
    int[,] result = {{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}};
    int count = 0;

    ध्यान दें कि आपने परिणाम सरणी तत्वों को -1. यह आपको बाद में मदद करेगा जब आप पाए गए जोड़े को प्रिंट करना चाहते हैं।

    इसके बाद, आप पहले मैच को वापस करने के result बजाय प्रत्येक पाए गए जोड़े को स्टोर करने के लिए सरणी का उपयोग करेंगे।

  3. TwoCoins विधि को निम्न कोड से अद्यतन करें:

    int[,] TwoCoins(int[] coins, int target) 
{
    int[,] result = {{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}};
    int count = 0;

    for (int curr = 0; curr < coins.Length; curr++) 
    {
        for (int next = curr + 1; next < coins.Length; next++) 
        {
            if (coins[curr] + coins[next] == target) 
            {
                result[count, 0] = curr;
                result[count, 1] = next;
                count++;
            }

        }
    }

    ध्यान दें कि count हर बार एक जोड़ी सरणी में जोड़ी जाने पर बढ़ जाती है। यह एक इंडेक्स आउट ऑफ बाउंड्स त्रुटि का कारण बन सकता है यदि पाँच से अधिक जोड़े पाए जाते हैं। इस त्रुटि को रोकने के लिए, आप मान की जांच करने के count लिए कोड जोड़ सकते हैं और सरणी का result परिणाम भर सकता है।

  4. विधि में TwoCoins तर्क को निम्न कोड के साथ अद्यतन करें:

    for (int next = curr + 1; next < coins.Length; next++) 
{
    if (coins[curr] + coins[next] == target) 
    {
        result[count, 0] = curr;
        result[count, 1] = next;
        count++;
    }
    if (count == result.GetLength(0)) 
    {
        return result;
    }
}

    अंत में, आपको सही परिणाम वापस करने के लिए अंतिम रिटर्न स्टेटमेंट को अपडेट करना होगा यदि कोई मिलान नहीं मिलता है, या यदि पांच से कम मैच पाए गए हैं।

  5. विधि में return कथन पर TwoCoins नेविगेट करें। निम्न कोड से मेल खाने के return लिए कथन को संशोधित करें:

    if (count == 0) 
{
    return new int[0,0];
}
return result;

    आप टर्नरी ऑपरेटर का उपयोग करके इस रिटर्न कोड को छोटा भी कर सकते हैं:

    return (count == 0) ? new int[0,0] : result;

    महत्वपूर्ण

    कीवर्ड का return लचीलापन आपको एक अभिव्यक्ति के मूल्य को वापस करने की अनुमति देता है, जब तक कि परिणाम विधि के निर्दिष्ट रिटर्न प्रकार से मेल खाता है।

  6. इस बिंदु पर, TwoCoins विधि निम्न कोड से मेल खाना चाहिए:

    int[,] TwoCoins(int[] coins, int target) 
{
    int[,] result = {{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}};
    int count = 0;

    for (int curr = 0; curr < coins.Length; curr++) 
    {
        for (int next = curr + 1; next < coins.Length; next++) 
        {
            if (coins[curr] + coins[next] == target) 
            {
                result[count, 0] = curr;
                result[count, 1] = next;
                count++;
            }
            if (count == result.GetLength(0)) 
            {
                return result;
            }
        }
    }
    return (count == 0) ? new int[0,0] : result;
}

नई वापसी सरणी कैप्चर करें

अब जब आपकी विधि 2D सरणी लौटा रही है, तो आप परिणामों को पुनः प्राप्त करने और प्रिंट करने के लिए अपना कोड अपडेट कर सकते हैं। चूंकि परिणाम सरणी तत्वों को इनिशियलाइज़ किया -1गया था, इसलिए आप मान मिलने तक सभी जोड़े प्रिंट करने के -1 लिए एक चेक जोड़ सकते हैं।

  1. अपने प्रोग्राम की शुरुआत में नेविगेट करें जहां target चर परिभाषित किया गया है। अपने कोड को निम्नानुसार संशोधित करें:

    int target = 30;
int[] coins = new int[] {5, 5, 50, 25, 25, 10, 5};
int[,] result = TwoCoins(coins, target);

    इसके बाद, आप मानों को सही ढंग से प्रिंट Console.WriteLine करने के लिए result कॉल को अपडेट करेंगे।

  2. कॉल पर Console.WriteLine नेविगेट करें। निम्न से मेल खाने के लिए अपना कोड अद्यतित करें:

    if (result.Length == 0) 
{
    Console.WriteLine("No two coins make change");
} 
else 
{
    Console.WriteLine("Change found at positions:");
    for (int i = 0; i < result.GetLength(0); i++) 
    {
        if (result[i,0] == -1) 
        {
            break;
        }
        Console.WriteLine($"{result[i,0]},{result[i,1]}");
    }
}

    यहां, आप एक खाली सरणी as-isके लिए चेक रखते हैं, और 2 डी सरणी के मूल्यों को फॉर-लूप में प्रिंट करते हैं। जब कोई -1 मान मिलता है, तो आप लूप से बाहर निकलते हैं क्योंकि कोई अगला जोड़ा नहीं होता है।

अपने काम की जाँच करें

इस कार्य में, आप एकीकृत टर्मिनल से अपना एप्लिकेशन चलाएंगे और सत्यापित करेंगे कि आपका कोड ठीक से काम कर रहा है। आएँ शुरू करें।

  1. यह सुनिश्चित करने के लिए अपने कोड की तुलना निम्नलिखित के साथ करें:

    int target = 30;
int[] coins = new int[] {5, 5, 50, 25, 25, 10, 5};
int[,] result = TwoCoins(coins, target);

if (result.Length == 0) 
{
    Console.WriteLine("No two coins make change");
} 
else 
{
    Console.WriteLine("Change found at positions:");
    for (int i = 0; i < result.GetLength(0); i++) 
    {
        if (result[i,0] == -1) 
        {
            break;
        }
        Console.WriteLine($"{result[i,0]},{result[i,1]}");
    }
}

int[,] TwoCoins(int[] coins, int target) 
{
    int[,] result = {{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}};
    int count = 0;

    for (int curr = 0; curr < coins.Length; curr++) 
    {
        for (int next = curr + 1; next < coins.Length; next++) 
        {    
            if (coins[curr] + coins[next] == target) 
            {
                result[count, 0] = curr;
                result[count, 1] = next;
                count++;
            }
            if (count == result.GetLength(0)) 
            {
                return result;
            }
        }
    }
    return (count == 0) ? new int[0,0] : result;
}

  2. Ctrl + का उपयोग करके या Visual Studio Code फ़ाइल मेनू का उपयोग करके अपना कार्य सहेजें.

  3. यदि आवश्यक हो, तो Visual Studio Code का एकीकृत टर्मिनल पैनल खोलें।

    EXPLORER पैनल में, अपने TestProject फ़ोल्डर स्थान पर कोई टर्मिनल खोलने के लिए, TestProject राइट-क्लिक करें, और उसके बाद एकीकृत टर्मिनल में खोलेंका चयन करें।

  4. टर्मिनल कमांड प्रॉम्प्ट पर, dotnet run दर्ज करें

  5. सत्यापित करें कि आपका कोड निम्न आउटपुट उत्पन्न करता है:

    Change found at positions:
0,3
0,4
1,3
1,4
3,6

    अगर आपका कोड अलग-अलग नतीजे दिखाता है, तो आपको अपनी गड़बड़ी ढूंढने और अपडेट करने के लिए अपने कोड की समीक्षा करनी होगी. यह देखने के लिए कोड फिर से चलाएं कि क्या आपने समस्या ठीक कर दी है। अपना कोड अपडेट करना और चलाना तब तक जारी रखें जब तक कि आपका कोड अपेक्षित परिणाम न दे।

  6. इसके बाद, के मान target को निम्न मान 80में अद्यतन करें:

    int target = 80;

  7. अपना काम सहेजें फिर टर्मिनल कमांड प्रॉम्प्ट पर डॉटनेट रन दर्ज करें

  8. सत्यापित करें कि आपका कोड अपेक्षा के अनुरूप काम कर रहा है करने के लिए, निम्न आउटपुट के साथ अपने अनुप्रयोग के आउटपुट की तुलना करें:

    No two coins make change

    अगर आपका कोड अलग-अलग नतीजे दिखाता है, तो आपको अपनी गड़बड़ी ढूंढने और अपडेट करने के लिए अपने कोड की समीक्षा करनी होगी. यह देखने के लिए कोड फिर से चलाएं कि क्या आपने समस्या ठीक कर दी है। अपना कोड अपडेट करना और चलाना तब तक जारी रखें जब तक कि आपका कोड अपेक्षित परिणाम न दे।