Übung:Zurückgeben von Arrays aus Methoden

  • 10 Minuten

Beim Entwickeln von Anwendungen müssen Sie häufig Datasets erstellen und ändern. Methoden sind nützlich, um datenbasierte Vorgänge auszuführen, und sie sind besonders geeignet zum Erstellen der Datasets. Die Entwicklung von Methoden zum Erstellen von Arrays, die Ihr Dataset darstellen, trägt dazu bei, Ihren Code wiederverwendbar, organisiert und einfach zu halten. In dieser Übung üben Sie das Zurückgeben von Arrays mithilfe von Methoden.

Suchen von Münzen, um Wechselgeld zu geben

Stellen Sie sich vor, dass Sie verschiedene Münzen mit unterschiedlichem Wert besitzen. Sie haben die Aufgabe, zwei Münzen zu finden, deren Summe einem Zielwert genau entspricht. In dieser Übung werden die verfügbaren Münzen in einem ganzzahligen Array dargestellt. Sie müssen die Indizes der beiden Münzen in einem neuen Array zurückgeben. Jetzt geht‘s los!

  1. Löschen Sie im Visual Studio Code-Editor jeglichen vorhandenen Code aus den vorherigen Übungen.

  2. Geben Sie den folgenden Code in den Visual Studio Code-Editor ein:

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

    Wenn keine zwei Münzen gefunden werden, gibt Ihre Methode ein leeres Array zurück. Nehmen Sie sich einen Moment Zeit, um sich die Syntax des zurückgegebenen Ergebnisses anzusehen. Sie können zwar eine Variable erstellen, um ein neues int[]-Array zu speichern und die Variable zurückzugeben, aber mit der return-Anweisung können Sie gleichzeitig Werte erstellen und zurückgeben.

  3. Es gibt viele Ansätze, um dieses Problem zu lösen. Nehmen Sie sich einen Moment Zeit, um zu überlegen, wie Sie in einem Array nach zwei Zahlen suchen können, deren Summe einem bestimmten Wert entspricht.

    In dieser Übung wird der folgende Ansatz verwendet:

    1. Wählen Sie eine Zahl aus dem Array aus.
    2. Überprüfen Sie nacheinander andere Zahlen, um festzustellen, ob sie sich zum Zielwert addieren.
    3. Geben Sie das Ergebnis zurück, sobald eine Übereinstimmung gefunden wurde.

  4. Aktualisieren Sie die TwoCoins-Methode mit dem folgenden Code, um jede Zahl im Array zu überprüfen:

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

    Hier stellt curr einen festen Münzindex und next die nachfolgenden Münzindizes dar. Sie versuchen, jede next-Münze zur festgelegten curr-Münze zu addieren, um festzustellen, ob das Ergebnis dem Zielwert entspricht.

  5. Fügen Sie als Nächstes Logik hinzu, um die Summe der beiden Münzen auf den Zielwert zu überprüfen. Aktualisieren Sie dazu die vorherigen for-Schleifen mit dem folgenden Code:

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

    }
}

    Mit diesem Code überprüfen Sie, ob die Summe der Werte von curr und next im Array dem Zielwert entspricht. Wenn die Summe gleich ist, erstellen Sie ein Array, um diese Indizes zu speichern und zurückzugeben. Wenn sie nicht gleich ist, können Sie sie ignorieren und die Überprüfung fortsetzen.

Testen Ihrer Lösung

In diesem Schritt testen Sie Ihren Code, um sicherzustellen, dass er ordnungsgemäß ausgeführt wird. Zuerst initialisieren Sie einige Variablen, um die Eingabedaten zu speichern. Anschließend rufen Sie die Methode auf und geben die Ergebnisse aus.

  1. Fügen Sie über der Signatur der TwoCoins-Methode eine neue leere Codezeile hinzu. Geben Sie dann den folgenden Code ein:

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

    Denken Sie daran, dass die TwoCoins-Methode ein leeres Array zurückgibt, wenn keine Änderung gefunden wird. Sie müssen die Arraygröße überprüfen, bevor Sie versuchen, das result-Array auszugeben.

  2. Fügen Sie eine neue leere Codezeile hinzu. Geben Sie dann den folgenden Code ein:

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

  3. Öffnen Sie bei Bedarf das Visual Studio Code-Panel „Integriertes Terminal“.

  4. Geben Sie an der Terminal-Eingabeaufforderung dotnet run ein. Vergleichen Sie Ihre Ausgabe mit Folgendem:

    Change found at positions 2 and 5

    Wenn Ihr Code unterschiedliche Ergebnisse anzeigt, müssen Sie ihn überprüfen, um den Fehler zu finden und Updates vorzunehmen. Führen Sie den Code erneut aus, um festzustellen, ob Sie das Problem behoben haben. Fahren Sie mit dem Aktualisieren und Ausführen Ihres Codes fort, bis der Code die erwarteten Ergebnisse generiert.

Suchen nach mehreren Münzpaaren, um Wechselgeld zu geben

In diesem Schritt erweitern Sie die TwoCoins-Methode, um weitere Münzpaare zu suchen, deren Summe dem Zielwert entspricht. Für diese Übung suchen Sie maximal fünf Paare. Das bedeutet, dass der Rückgabetyp ein 2D-Array anstelle eines 1D-Arrays ist. Sie zudem müssen ändern, wie der Code die Ergebnisse zurückgibt. Jetzt geht‘s los!

  1. Ändern Sie den Rückgabetyp in der Methodensignatur von int[] in int[,], indem Sie den Code wie folgt aktualisieren:

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

    Als Nächstes erstellen Sie ein int[,]-Array zum Speichern und Zurückgeben Ihrer Ergebnisse sowie eine Zählervariable, um die Anzahl der dem Array hinzugefügten Paare nachzuverfolgen.

  2. Aktualisieren Sie die TwoCoins-Methode mit folgendem Code:

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

    Beachten Sie, dass Sie die Ergebnisarrayelemente in -1initialisiert haben. Dies hilft Ihnen später, wenn Sie die gefundenen Paare ausgeben möchten.

    Als Nächstes verwenden Sie das result-Array, um jedes gefundene Paar zu speichern, anstatt die erste Übereinstimmung zurückzugeben.

  3. Aktualisieren Sie die TwoCoins-Methode mit folgendem Code:

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

        }
    }

    Beachten Sie, dass count jedes Mal erhöht wird, wenn dem Array ein Paar hinzugefügt wird. Das kann dazu führen, dass ein Index außerhalb des gültigen Bereichs liegt, wenn mehr als fünf Paare gefunden werden. Um diesen Fehler zu verhindern, können Sie Code hinzufügen, um den Wert von count zu überprüfen und das Ergebnis des result-Arrays zurückzugeben, wenn es voll ist.

  4. Aktualisieren Sie die Logik in der TwoCoins-Methode mit dem folgenden Code:

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

    Schließlich müssen Sie die letzte return-Anweisung anpassen, damit das richtige Ergebnis zurückgegeben wird, wenn keine oder weniger als fünf Übereinstimmungen gefunden wurden.

  5. Navigieren Sie zur return-Anweisung in der TwoCoins-Methode. Ändern Sie die return-Anweisung so, dass sie mit dem folgenden Code übereinstimmt:

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

    Sie können diesen Rückgabecode auch mit dem ternären Operator kürzen:

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

    Wichtig

    Die Flexibilität des return-Schlüsselworts ermöglicht es Ihnen, den Wert eines Ausdrucks zurückzugeben, solange das Ergebnis mit dem angegebenen Rückgabetyp der Methode übereinstimmt.

  6. An diesem Punkt sollte die TwoCoins-Methode mit dem folgenden Code übereinstimmen:

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

Erfassen des neuen Rückgabearrays

Nachdem Ihre Methode nun ein 2D-Array zurückgibt, können Sie Ihren Code aktualisieren, um die Ergebnisse abzurufen und auszugeben. Da die Ergebnisarrayelemente mit -1 initialisiert wurden, können Sie eine Überprüfung hinzufügen, um alle Paare auszugeben, bis ein -1-Wert gefunden wird.

  1. Navigieren Sie zum Anfang des Programms, wo die target-Variable definiert ist. Ändern Sie Ihren Code wie folgt:

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

    Als Nächstes aktualisieren Sie den Aufruf von Console.WriteLine, damit die result-Werte ordnungsgemäß ausgegeben werden.

  2. Navigieren Sie zum Aufruf von Console.WriteLine. Ändern Sie Ihren Code so, dass er dem folgenden entspricht:

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

    Hier behalten Sie die Überprüfung auf ein leeres Array unverändert bei und geben die Werte des 2D-Arrays in einer for-Schleife aus. Wenn ein -1-Wert gefunden wird, wird die Schleife beendet, da keine nächsten Paare vorhanden sind.

Arbeit überprüfen

In dieser Aufgabe führen Sie Ihre Anwendung über das integrierte Terminal aus und überprüfen, ob Ihr Code ordnungsgemäß funktioniert. Fangen wir also an.

  1. Vergleichen Sie Ihren Code mit dem folgenden Code, um sicherzustellen, dass er richtig ist:

    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. Speichern Sie Ihre Arbeit mit STRG + S oder mithilfe des Visual Studio Code File-Menüs.

  3. Öffnen Sie bei Bedarf das Visual Studio Code-Panel „Integriertes Terminal“.

    Klicken Sie im EXPLORER-Bereich auf "TestProject", um ein Terminal am Speicherort des TestProject-Ordners zu öffnen, klicken Sie mit der rechten Maustaste auf "TestProject", und wählen Sie dann "In integriertem Terminal öffnen" aus.

  4. Geben Sie an der Terminal-Eingabeaufforderung dotnet run ein.

  5. Stellen Sie sicher, dass Ihr Code die folgende Ausgabe erzeugt:

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

    Wenn Ihr Code unterschiedliche Ergebnisse anzeigt, müssen Sie ihn überprüfen, um den Fehler zu finden und Aktualisierungen vorzunehmen. Führen Sie den Code erneut aus, um festzustellen, ob Sie das Problem behoben haben. Fahren Sie mit dem Aktualisieren und Ausführen Ihres Codes fort, bis der Code die erwarteten Ergebnisse generiert.

  6. Ändern Sie als Nächstes den Wert von target in einen Wert von 80:

    int target = 80;

  7. Speichern Sie Ihre Arbeit und geben Sie dann dotnet run an der Terminal-Eingabeaufforderung ein.

  8. Um zu überprüfen, ob Ihr Code wie erwartet funktioniert, vergleichen Sie die Ausgabe Ihrer Anwendung mit der folgenden Ausgabe:

    No two coins make change

    Wenn Ihr Code unterschiedliche Ergebnisse anzeigt, müssen Sie ihn überprüfen, um den Fehler zu finden und Aktualisierungen vorzunehmen. Führen Sie den Code erneut aus, um festzustellen, ob Sie das Problem behoben haben. Fahren Sie mit dem Aktualisieren und Ausführen Ihres Codes fort, bis der Code die erwarteten Ergebnisse generiert.