Exercițiu - Returnarea matricelor de la metode

  • 10 minute

Atunci când dezvoltați aplicații, va trebui adesea să construiți și să modificați seturi de date. Metodele sunt utile pentru efectuarea de operațiuni asupra datelor și sunt instrumente deosebit de puternice pentru construirea seturilor de date propriu-zise. Dezvoltarea de metode pentru a crea matrice reprezentând setul de date vă ajută să păstrați codul reutilizabil, organizat și simplificat. În acest exercițiu, veți exersa returnarea matricelor din metode.

Găsiți monede pentru a efectua modificări

Să presupunem că aveți mai multe monede de valori diferite. Vi se atribuie sarcina de a găsi două monede a căror sumă este egală cu o valoare țintă. În acest exercițiu, monedele disponibile sunt reprezentate într-o matrice întreagă. Va trebui să returnați indicii celor două monede într-o matrice nouă. Să începem!

  1. În Visual Studio Code Editor, ștergeți orice cod existent din exercițiile anterioare.

  2. Introduceți următorul cod în Visual Studio Code Editor:

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

    În cazul în care nu se găsesc două monede, metoda returnează o matrice goală. Gândiți-vă la sintaxa rezultatului returnat. Deși puteți să creați o variabilă pentru a stoca o matrice nouă int[] și a returna variabila, instrucțiunea return vă permite să creați și să returnați simultan valori.

  3. Există multe abordări pentru a rezolva această problemă. Gândiți-vă cum puteți căuta două numere într-o matrice a cărei sumă este egală cu o valoare dată.

    În acest exercițiu, se va utiliza următoarea abordare:

    1. Alegeți un număr din matrice
    2. Verificați alte numere pe rând pentru a vedea dacă adună până la valoarea țintă
    3. Returnarea rezultatului imediat ce se găsește o potrivire

  4. Pentru a verifica fiecare număr din matrice, actualizați TwoCoins metoda cu următorul cod:

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

    Aici, curr reprezintă un index fix al monedei și next reprezintă indicii monedei următoare. Veți încerca să adăugați fiecare next monedă cu moneda fixă curr pentru a vedea dacă sunt egale cu valoarea țintă.

  5. În continuare, adăugați logică pentru a verifica suma celor două monede pentru valoarea țintă. Pentru a face acest lucru, actualizați buclele anterioare for cu următorul cod:

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

    }
}

    În acest cod, verificați dacă suma valorilor de la curr și next din matrice este egală cu valoarea țintă. Dacă suma este egală, creați o matrice pentru a stoca acești indici și a o returna. Dacă acestea nu sunt egale, puteți să le ignorați și să continuați verificarea.

Testați soluția

În acest pas, veți testa codul pentru a vă asigura că rulează corect. Mai întâi, veți inițializa unele variabile pentru a stoca datele de intrare, apoi veți apela metoda și veți imprima rezultatele.

  1. Creați o linie de cod necompletată nouă deasupra semnăturii metodei TwoCoins . Apoi introduceți următorul cod:

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

    Rețineți că TwoCoins metoda returnează o matrice goală dacă nu se găsește nicio modificare. Va trebui să verificați dimensiunea matricei înainte de a încerca să imprimați matricea result .

  2. Introduceți o nouă linie de cod necompletată. Apoi introduceți următorul cod:

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

  3. Dacă este necesar, deschideți panoul Terminal integrat visual Studio Code.

  4. În linia de comandă Terminal, introduceți run dotnet. Comparați ieșirea cu următoarele:

    Change found at positions 2 and 5

    Dacă codul afișează rezultate neașteptate, va trebui să revizuiți codul pentru a găsi eroarea și a face actualizări. Rulați codul din nou pentru a vedea dacă ați remediat problema. Continuați actualizarea și rularea codului până când codul produce rezultatele așteptate.

Găsiți mai multe perechi de monede care fac modificări

În acest pas, veți extinde TwoCoins metoda pentru a găsi mai multe perechi de monede a căror sumă este egală cu valoarea țintă. Pentru acest exercițiu, veți găsi maximum cinci perechi. Aceasta înseamnă că tipul returnat va fi o matrice 2D în locul unei matrice 1D și va trebui să modificați modul în care codul returnează rezultatele. Să începem!

  1. Modificați tipul de returnare din semnătura metodei la int[]int[,] , actualizând codul la următoarele:

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

    În continuare, veți crea o int[,] matrice pentru a stoca și a returna rezultatele și o variabilă contor pentru a urmări numărul de perechi adăugate la matrice.

  2. Actualizați TwoCoins metoda cu următorul cod:

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

    Observați că ați inițializat elementele matrice de rezultate la -1. Acest lucru vă va ajuta mai târziu atunci când doriți să imprimați perechile care au fost găsite.

    În continuare, veți utiliza matricea result pentru a stoca fiecare pereche găsită în loc să returnați prima potrivire.

  3. Actualizați TwoCoins metoda cu următorul cod:

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

        }
    }

    Observați că count este incrementat de fiecare dată când se adaugă o pereche la matrice. Acest lucru poate cauza o eroare index în afara limitelor dacă se găsesc mai mult de cinci perechi. Pentru a preveni această eroare, puteți să adăugați cod pentru a verifica valoarea count și a returna rezultatul matricei result .

  4. Actualizați logica TwoCoins din metoda cu următorul cod:

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

    În sfârșit, va trebui să actualizați instrucțiunea finală de returnare pentru a returna rezultatul corect dacă nu se găsesc deloc potriviri sau dacă s-au găsit mai puțin de cinci potriviri.

  5. Navigați la instrucțiunea return din TwoCoins metodă. Modificați instrucțiunea return pentru a se potrivi cu următorul cod:

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

    De asemenea, puteți scurta acest cod de returnare utilizând operatorul ternar astfel:

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

    Important

    Flexibilitatea cuvântului return cheie vă permite să returnați valoarea unei expresii, atât timp cât rezultatul corespunde tipului specificat de returnare al metodei.

  6. În acest moment, TwoCoins metoda ar trebui să corespundă următorului cod:

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

Capturați noua matrice de returnare

Acum, că metoda returnează o matrice 2D, puteți actualiza codul pentru a regăsi și a imprima rezultatele. Deoarece elementele matrice rezultat au fost inițializate la -1, puteți adăuga o verificare pentru a imprima toate perechile până când se găsește o -1 valoare.

  1. Navigați la începutul programului unde este definită variabila target . Modificați codul după cum urmează:

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

    În continuare, veți actualiza apelul pentru a Console.WriteLine imprima result corect valorile.

  2. Navigați la Console.WriteLine apel. Actualizați codul pentru a se potrivi cu următoarele:

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

    Aici păstrați verificarea pentru o matrice goală as-isși imprimați valorile matricei 2D într-o buclă. Atunci când se găsește o -1 valoare, ieșiți din buclă, deoarece nu există perechi următoare.

Verificați-vă activitatea

În această activitate, veți rula aplicația de la Terminalul integrat și veți verifica dacă codul funcționează corect. Să începem.

  1. Comparați codul cu următoarele pentru a vă asigura că este corect:

    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. Salvați lucrul utilizând Ctrl + S sau utilizând meniul Fișier de cod Visual Studio.

  3. Dacă este necesar, deschideți panoul Terminal integrat visual Studio Code.

    În panoul EXPLORER, pentru a deschide un Terminal la locația folderului TestProject, faceți clic dreapta pe TestProject, apoi selectați Deschidere în terminal integrat.

  4. În linia de comandă Terminal, introduceți run dotnet

  5. Verificați dacă codul dvs. generează următoarea ieșire:

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

    Dacă codul afișează rezultate diferite, va trebui să revizuiți codul pentru a găsi eroarea și a face actualizări. Rulați codul din nou pentru a vedea dacă ați remediat problema. Continuați actualizarea și rularea codului până când codul produce rezultatele așteptate.

  6. În continuare, actualizați valoarea target la o valoare a 80:

    int target = 80;

  7. Salvați lucrul, apoi introduceți punctnet rulare în linia de comandă Terminal

  8. Pentru a verifica dacă codul funcționează conform așteptărilor, comparați rezultatul aplicației cu următorul rezultat:

    No two coins make change

    Dacă codul afișează rezultate diferite, va trebui să revizuiți codul pentru a găsi eroarea și a face actualizări. Rulați codul din nou pentru a vedea dacă ați remediat problema. Continuați actualizarea și rularea codului până când codul produce rezultatele așteptate.