Gyakorlat – Tömbök visszaadása metódusokból

  • 10 perc

Alkalmazások fejlesztésekor gyakran adatkészleteket kell létrehoznia és módosítania. A metódusok hasznosak az adatokon végzett műveletek végrehajtásához, és különösen hatékony eszközök az adathalmazok létrehozására. Az adatkészletet képviselő tömbök létrehozására szolgáló módszerek fejlesztése segít a kód újrafelhasználható, rendszerezett és egyszerűsített állapotban tartásában. Ebben a gyakorlatban a tömbök metódusokból való visszaadását fogja gyakorolni.

A módosításhoz keresse meg az érméket

Tegyük fel, hogy több különböző értékű érmével rendelkezik. Két érmét kell megtalálnia, amelyek összege megegyezik egy célértékkel. Ebben a gyakorlatban a rendelkezésre álló érmék egy egész számtömbben jelennek meg. A két érmének indexeit egy új tömbben kell visszaadnia. Lássunk is hozzá!

  1. A Visual Studio Code Editorban törölje a meglévő kódot az előző gyakorlatokból.

  2. Írja be a következő kódot a Visual Studio Code Editorba:

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

    Abban az esetben, ha nem talál két érmét, a metódus üres tömböt ad vissza. Szánjon egy kis időt a visszaadott eredmény szintaxisának figyelembevételére. Bár létrehozhat egy változót egy új int[] tömb tárolásához és a változó visszaadásához, az return utasítás lehetővé teszi, hogy egyszerre hozzon létre és adjon vissza értékeket.

  3. A probléma megoldására számos módszer létezik. Szánjon egy kis időt, és gondolja át, hogyan kereshet két számot egy tömbben, amelynek összege megegyezik egy adott értékkel.

    Ebben a gyakorlatban a következő megközelítést alkalmazzuk:

    1. Válasszon egy számot a tömbből
    2. A többi szám egyenkénti ellenőrzése annak ellenőrzéséhez, hogy hozzáadják-e a célértéket
    3. Adja vissza az eredményt, amint talál egyezést

  4. A tömb egyes számainak ellenőrzéséhez frissítse a metódust TwoCoins a következő kóddal:

    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];
}

    Itt egy rögzített érmeindexet jelöl, curr és next az azt követő érmeindexeket jelöli. Próbálja meg hozzáadni az egyes next érméket a rögzített curr érmével, hogy lássa, megegyeznek-e a célértékkel.

  5. Ezután adja hozzá a logikát a célérték két érmének összegének ellenőrzéséhez. Ehhez frissítse az előző for ciklusokat a következő kóddal:

    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};
        }

    }
}

    Ebben a kódban azt ellenőrzi, hogy a tömbben curr és next a tömbben lévő értékek összege megegyezik-e a célértékel. Ha az összeg egyenlő, létre kell hoznia egy tömböt az indexek tárolásához és visszaadásához. Ha nem egyenlők, figyelmen kívül hagyhatja őket, és továbbra is ellenőrizheti őket.

A megoldás tesztelése

Ebben a lépésben tesztelni fogja a kódot, hogy biztosan megfelelően fusson. Először inicializálni fog néhány változót a bemeneti adatok tárolásához, majd meghívja a metódust, és kinyomtatja az eredményeket.

  1. Hozzon létre egy új üres kódsort a TwoCoins metódus-aláírás felett. Ezután írja be a következő kódot:

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

    Ne feledje, hogy a TwoCoins metódus üres tömböt ad vissza, ha nem található változás. A tömb nyomtatásának megkísérlése előtt ellenőriznie kell a result tömb méretét.

  2. Adjon meg egy új üres kódsort. Ezután írja be a következő kódot:

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

  3. Szükség esetén nyissa meg a Visual Studio Code integrált terminálpaneljét.

  4. A Terminál parancssorában írja be a dotnet run parancsot. Hasonlítsa össze a kimenetet a következőkkel:

    Change found at positions 2 and 5

    Ha a kód váratlan eredményeket jelenít meg, át kell tekintenie a kódot a hiba megkereséséhez és a frissítések elvégzéséhez. Futtassa újra a kódot, és ellenőrizze, hogy kijavította-e a problémát. Folytassa a kód frissítését és futtatását, amíg a kód meg nem hozza a várt eredményeket.

Több olyan érempár keresése, amelyek módosítják a halmazt

Ebben a lépésben kiterjeszti a TwoCoins metódust, hogy több olyan érmét találjon, amelynek összege megegyezik a célértékkel. Ebben a gyakorlatban legfeljebb öt pár található. Ez azt jelenti, hogy a visszatérési típus 1D tömb helyett 2D tömb lesz, és módosítania kell, hogy a kód hogyan adja vissza az eredményeket. Lássunk is hozzá!

  1. A metódus-aláírás int[] visszatérési típusának módosításához int[,] frissítse a kódot a következőre:

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

    Ezután létre fog hozni egy int[,] tömböt az eredmények tárolásához és visszaadásához, valamint egy számlálóváltozót, amely nyomon követi a tömbhöz hozzáadott párok számát.

  2. Frissítse a metódust TwoCoins a következő kóddal:

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

    Figyelje meg, hogy az eredménytömb elemeit a következőre inicializálta -1: . Ez később segít, ha ki szeretné nyomtatni a talált párokat.

    Ezután a tömböt fogja használni az result egyes talált párok tárolására az első egyezés visszaadása helyett.

  3. Frissítse a metódust TwoCoins a következő kóddal:

    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++;
            }

        }
    }

    Figyelje meg, hogy a rendszer minden alkalommal növekszik, count amikor egy pár hozzáadódik a tömbhöz. Ha ötnél több pár található, az index túllépheti a határokat. A hiba elkerülése érdekében kódot adhat hozzá, amely ellenőrzi a tömb értékét count , és visszaadja a result tömb eredményének kitöltését.

  4. Frissítse a metódus logikáját TwoCoins a következő kóddal:

    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;
    }
}

    Végül frissítenie kell a végső visszatérési utasítást, hogy a helyes eredményt adja vissza, ha egyáltalán nem található egyezés, vagy ha ötnél kevesebb találatot talált.

  5. Lépjen a return metódus utasítására TwoCoins . Módosítsa az utasítást return a következő kódnak megfelelően:

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

    Ezt a visszatérési kódot a ternáris operátorral is lerövidítheti a következőképpen:

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

    Fontos

    A kulcsszó rugalmassága return lehetővé teszi egy kifejezés értékének visszaadását mindaddig, amíg az eredmény megegyezik a metódus megadott visszatérési típusával.

  6. Ezen a ponton a metódusnak meg TwoCoins kell egyeznie a következő kóddal:

    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;
}

Az új visszatérési tömb rögzítése

Most, hogy a metódus egy 2D tömböt ad vissza, frissítheti a kódot az eredmények lekéréséhez és nyomtatásához. Mivel az eredménytömb elemeinek inicializálása -1megtörtént, az összes pár nyomtatásához hozzáadhat egy ellenőrzést, amíg meg nem talál egy -1 értéket.

  1. Lépjen a program elejére, ahol a target változó definiálva van. Módosítsa a kódot az alábbiak szerint:

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

    Ezután frissítenie kell a hívást, hogy Console.WriteLine helyesen nyomtassa ki az result értékeket.

  2. Lépjen a hívásra Console.WriteLine . Frissítse a kódot az alábbiaknak megfelelően:

    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]}");
    }
}

    Itt megtarthatja az üres tömbök ellenőrzését, és egy for-loopban kinyomtathatja a 2D tömb értékeit. -1 Amikor egy érték található, a ciklusból ki kell szakítania, mivel nincsenek következő párok.

Ellenőrizze munkáját

Ebben a feladatban futtatja az alkalmazást az integrált terminálról, és ellenőrzi, hogy a kód megfelelően működik-e. Lássunk neki!

  1. Hasonlítsa össze a kódot a következőkkel, hogy biztosan helyes legyen:

    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. Mentse a munkáját a CtrlS + vagy a Visual Studio Code File menüvel.

  3. Szükség esetén nyissa meg a Visual Studio Code integrált terminálpaneljét.

    Az EXPLORER panelen nyissa meg a Terminált a TestProject mappa helyén, kattintson a jobb gombbal a TestProject elemre, majd válassza a Megnyitás az integrált terminálban lehetőséget.

  4. A Terminál parancssorában adja meg a dotnet run

  5. Ellenőrizze, hogy a kód a következő kimenetet hozza-e létre:

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

    Ha a kód eltérő eredményeket jelenít meg, a hiba megkereséséhez és a frissítések elvégzéséhez át kell tekintenie a kódot. Futtassa újra a kódot, és ellenőrizze, hogy kijavította-e a problémát. Folytassa a kód frissítését és futtatását, amíg a kód meg nem hozza a várt eredményeket.

  6. Ezután frissítse a következő értékre target80:

    int target = 80;

  7. Mentse el a munkáját, majd írja be a dotnet run parancsot a terminálban található parancssorban.

  8. Annak ellenőrzéséhez, hogy a kód a várt módon működik-e, hasonlítsa össze az alkalmazás kimenetét a következő kimenettel:

    No two coins make change

    Ha a kód eltérő eredményeket jelenít meg, a hiba megkereséséhez és a frissítések elvégzéséhez át kell tekintenie a kódot. Futtassa újra a kódot, és ellenőrizze, hogy kijavította-e a problémát. Folytassa a kód frissítését és futtatását, amíg a kód meg nem hozza a várt eredményeket.