Esercizio - Restituire matrici dai metodi

10 minuti

Quando si sviluppano applicazioni, spesso è necessario compilare e modificare set di dati. I metodi sono utili per eseguire operazioni sui dati e sono strumenti particolarmente potenti per creare i set di dati stessi. Lo sviluppo di metodi per creare matrici che rappresentano il set di dati aiuta a mantenere il codice riutilizzabile, organizzato e semplificato. In questo esercizio si farà pratica con la restituzione di matrici dai metodi.

Trovare le monete per fare il resto

Si supponga di avere varie monete di valore diverso. Il compito è quello di trovare due monete la cui somma sia uguale a un valore di destinazione. In questo esercizio le monete disponibili sono rappresentate in una matrice di numeri interi. Sarà necessario restituire gli indici delle due monete in una nuova matrice. È ora di iniziare.

Nell'editor di Visual Studio Code eliminare qualsiasi codice creato negli esercizi precedenti.
Immettere il codice seguente nel pannello Editor di Visual Studio Code:
```
int[] TwoCoins(int[] coins, int target) 
{
    return  new int[0];
}
```
Nel caso in cui non vengano trovate due monete, il metodo restituisce una matrice vuota. Esaminare la sintassi del risultato restituito. Sebbene sia possibile creare una variabile in cui archiviare una nuova matrice int[] e restituire la variabile, l'istruzione return consente di creare e restituire contemporaneamente valori.
Esistono diversi approcci per risolvere il problema. Considerare il modo in cui si potrebbero cercare in una matrice due numeri la cui somma è uguale a un valore dato.

In questo esercizio verrà usato l'approccio seguente:
1. Scegliere un numero dalla matrice
2. Controllare gli altri numeri uno alla volta per verificare se la somma corrisponde al valore di destinazione
3. Restituire il risultato non appena viene trovata una corrispondenza
Per controllare ogni numero nella matrice, aggiornare il metodo TwoCoins con il codice seguente:
```
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];
}
```
Nel codice, curr rappresenta un indice di moneta fisso e next rappresenta gli indici di moneta successivi. Si proverà a sommare ogni moneta next con la moneta curr fissa per vedere se la somma corrisponde al valore di destinazione.
Aggiungere quindi la logica per controllare che la somma delle due monete sia uguale al valore di destinazione. A questo scopo, aggiornare i cicli for precedenti con il codice seguente:
```
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};
        }

    }
}
```
In questo codice si verifica se la somma dei valori di curr e next nella matrice è uguale al valore di destinazione. Se la somma è uguale, si crea una matrice in cui archiviare tali indici e restituirla. Se non sono uguali, è possibile ignorarli e continuare a controllare.

Testare la soluzione personalizzata

In questo passaggio si testerà il codice per assicurarsi che venga eseguito correttamente. Prima di tutto si inizializzeranno alcune variabili in cui archiviare i dati di input, quindi si chiamerà il metodo e si stamperanno i risultati.

Creare una nuova riga di codice vuota sopra la firma del metodo TwoCoins. Immettere quindi il codice seguente:
```
int target = 60;
int[] coins = new int[] {5, 5, 50, 25, 25, 10, 5};
int[] result = TwoCoins(coins, target);
```
Ricordare che il metodo TwoCoins restituisce una matrice vuota se non rileva alcuna modifica. Occorrerà controllare le dimensioni della matrice prima di tentare di stampare la matriceresult.

Immettere una nuova riga di codice vuota. Immettere quindi il codice seguente:

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

Se necessario, aprire il pannello del terminale integrato di Visual Studio Code.
Al prompt dei comandi del terminale immettere dotnet run. Confrontare l'output con quanto segue:
```
Change found at positions 2 and 5
```
Se il codice visualizza risultati imprevisti, è necessario esaminarlo per trovare l'errore e apportare aggiornamenti. Eseguire di nuovo il codice per verificare se il problema è stato risolto. Continuare ad aggiornare ed eseguire il codice fino a quando non produce i risultati previsti.

Trovare più coppie di monete per fare il resto

In questo passaggio si estenderà il metodo TwoCoins per trovare più coppie di monete la cui somma è uguale al valore di destinazione. Per questo esercizio si troveranno al massimo cinque coppie. Ciò significa che il tipo restituito sarà una matrice 2D anziché una matrice 1D e sarà necessario modificare il modo in cui il codice restituisce i risultati. È ora di iniziare.

Modificare il tipo restituito nella firma del metodo da int[] a int[,] aggiornando il codice come segue:
```
int[,] TwoCoins(int[] coins, int target)
```
Ora si creerà una matrice int[,] per archiviare e restituire i risultati e una variabile contatore per tenere traccia del numero di coppie aggiunte alla matrice.
Aggiornare il metodo TwoCoins con il codice seguente:
```
int[,] TwoCoins(int[] coins, int target) 
{
    int[,] result = {{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}};
    int count = 0;
```
Si noti che gli elementi della matrice di risultati sono stati inizializzati in -1. Questo sarà utile in un secondo momento per stampare le coppie trovate.

È il momento di usare la matrice resultper archiviare ogni coppia trovata anziché restituire la prima corrispondenza.

Aggiornare il metodo TwoCoins con il codice seguente:

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

        }
    }

Si noti che il valore count aumenta ogni volta che una coppia viene aggiunta alla matrice. Questo può causare un errore di indice non compreso nell'intervallo se vengono trovate più di cinque coppie. Per evitare questo errore, è possibile aggiungere codice per controllare il valore di count e restituire il risultato se la matrice result è piena.

Aggiornare il metodo TwoCoins con il codice seguente:

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

Infine, è necessario aggiornare l'istruzione return finale in modo da restituire il risultato corretto se non vengono trovate corrispondenze o se sono state trovate meno di cinque corrispondenze.

Passare all'istruzione return nel metodo TwoCoins. Modificare l'istruzione return in modo che corrisponda al codice seguente:
```
if (count == 0) 
{
    return new int[0,0];
}
return result;
```
È anche possibile abbreviare questo codice restituito usando l'operatore ternario in questo modo:
```
return (count == 0) ? new int[0,0] : result;
```
Importante

La flessibilità della parola chiave return permette di restituire il valore di un'espressione, purché il risultato corrisponda al tipo restituito specificato del metodo.

A questo punto, il metodo TwoCoins dovrebbe corrispondere al codice seguente:

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

Acquisire la nuova matrice restituita

Ora che il metodo restituisce una matrice 2D, è possibile aggiornare il codice in modo da recuperare e stampare i risultati. Poiché gli elementi della matrice di risultati sono stati inizializzati in -1, è possibile aggiungere un controllo per stampare tutte le coppie finché non viene trovato un valore -1.

Passare all'inizio del programma, dove viene definita la variabile target. Modificare il codice come segue:
```
int target = 30;
int[] coins = new int[] {5, 5, 50, 25, 25, 10, 5};
int[,] result = TwoCoins(coins, target);
```
Si aggiornerà ora la chiamata a Console.WriteLine per stampare correttamente i valori result.

Passare alla chiamata Console.WriteLine. Aggiornare il codice in modo che corrisponda all'esempio seguente:

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

Qui si mantiene il controllo di una matrice vuota così com'è e si stampano i valori della matrice 2D in un ciclo for. Quando viene trovato un valore -1, si interrompe il ciclo perché non sono presenti coppie successive.

Controlla il tuo lavoro

In questa attività si eseguirà l'applicazione dal terminale integrato e si verificherà che il codice funzioni correttamente. Iniziamo.

Confrontare il codice con il seguente per assicurarsi che sia corretto:

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

Salvare il lavoro premendo CTRL + S o il menu File di Visual Studio Code.
Se necessario, aprire il pannello del terminale integrato di Visual Studio Code.

Nel pannello ESPLORA RISORSE per aprire un terminale nel percorso della cartella TestProject, fare clic con il pulsante destro del mouse su TestProject e quindi scegliere Apri nel terminale integrato.
Al prompt dei comandi del terminale immettere dotnet run
Verificare che il codice produca l'output seguente:
```
Change found at positions:
0,3
0,4
1,3
1,4
3,6
```
Se il codice visualizza risultati diversi, è necessario esaminarlo per trovare l'errore e apportare aggiornamenti. Eseguire di nuovo il codice per verificare se il problema è stato risolto. Continuare ad aggiornare ed eseguire il codice fino a quando non produce i risultati previsti.
Aggiornare quindi il valore di target a 80:
```
int target = 80;
```
Salvare il lavoro e quindi immettere dotnet run al prompt dei comandi del terminale
Per verificare che il codice funzioni come previsto, confrontare l'output dell'applicazione con l'output seguente:
```
No two coins make change
```
Se il codice visualizza risultati diversi, è necessario esaminarlo per trovare l'errore e apportare aggiornamenti. Eseguire di nuovo il codice per verificare se il problema è stato risolto. Continuare ad aggiornare ed eseguire il codice fino a quando non produce i risultati previsti.

Commenti e suggerimenti

Questa pagina è stata utile?