Oefening: matrices retourneren van methoden

10 minuten

Bij het ontwikkelen van toepassingen moet u vaak sets met gegevens bouwen en wijzigen. Methoden zijn handig voor het uitvoeren van bewerkingen op gegevens en zijn vooral krachtige hulpprogramma's voor het bouwen van de gegevenssets zelf. Door methoden te ontwikkelen voor het maken van matrices die uw gegevensset vertegenwoordigen, kunt u uw code herbruikbaar, georganiseerd en vereenvoudigd houden. In deze oefening oefent u met het retourneren van matrices van methoden.

Munten zoeken om te veranderen

Stel dat u meerdere munten met verschillende waarden hebt. U moet twee munten vinden waarvan de som gelijk is aan een doelwaarde. In deze oefening worden de beschikbare munten weergegeven in een matrix met gehele getallen. U moet de indexen van de twee munten in een nieuwe matrix retourneren. Laten we beginnen.

Verwijder in de Visual Studio Code-editor alle bestaande code uit de vorige oefeningen.
Voer de volgende code in de Visual Studio Code-editor in:
```
int[] TwoCoins(int[] coins, int target) 
{
    return  new int[0];
}
```
In het geval dat er geen twee munten worden gevonden, retourneert uw methode een lege matrix. Neem even de syntaxis van het geretourneerde resultaat in overweging. Hoewel u een variabele kunt maken om een nieuwe int[] matrix op te slaan en de variabele te retourneren, kunt u met de return instructie tegelijkertijd waarden maken en retourneren.
Er zijn veel benaderingen om dit probleem op te lossen. Neem even de tijd om na te gaan hoe u kunt zoeken naar twee getallen in een matrix waarvan de som gelijk is aan een bepaalde waarde.

In deze oefening wordt de volgende benadering gebruikt:
1. Kies één getal in de matrix
2. Controleer andere getallen één voor één om te zien of ze de doelwaarde optellen
3. Retourneer het resultaat zodra er een overeenkomst is gevonden
Als u elk getal in de matrix wilt controleren, werkt u de TwoCoins methode bij met de volgende code:
```
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 Hier vertegenwoordigt u één vaste muntindex en next vertegenwoordigt u de volgende muntindexen. U probeert elke next munt met de vaste curr munt toe te voegen om te zien of ze gelijk zijn aan de doelwaarde.
Voeg vervolgens logica toe om de som van de twee munten voor de doelwaarde te controleren. Werk hiervoor de vorige for lussen bij met de volgende 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};
        }

    }
}
```
In deze code controleert u of de som van de waarden op curr en next in de matrix gelijk is aan de doelwaarde. Als de som gelijk is, maakt u een matrix om deze indexen op te slaan en te retourneren. Als ze niet gelijk zijn, kunt u ze negeren en controleren.

Uw oplossing testen

In deze stap test u uw code om ervoor te zorgen dat deze correct wordt uitgevoerd. Eerst initialiseert u enkele variabelen om de invoergegevens op te slaan. Vervolgens roept u de methode aan en drukt u de resultaten af.

Maak een nieuwe lege coderegel boven de TwoCoins methodehandtekening. Voer vervolgens de volgende code in:
```
int target = 60;
int[] coins = new int[] {5, 5, 50, 25, 25, 10, 5};
int[] result = TwoCoins(coins, target);
```
Zoals u weet, retourneert de TwoCoins methode een lege matrix als er geen wijziging wordt gevonden. U moet de matrixgrootte controleren voordat u de result matrix probeert af te drukken.

Voer een nieuwe lege coderegel in. Voer vervolgens de volgende code in:

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

Open zo nodig het geïntegreerde terminalpaneel van Visual Studio Code.
Voer in de opdrachtprompt van Terminal dotnet run in. Vergelijk uw uitvoer met het volgende:
```
Change found at positions 2 and 5
```
Als uw code onverwachte resultaten weergeeft, moet u uw code controleren om uw fout te vinden en updates aan te brengen. Voer de code opnieuw uit om te zien of u het probleem hebt opgelost. Ga door met het bijwerken en uitvoeren van uw code totdat uw code de verwachte resultaten produceert.

Meerdere paar munten zoeken die verandering aanbrengen

In deze stap gaat u de TwoCoins methode uitbreiden om meer paren munten te vinden waarvan de som gelijk is aan de doelwaarde. Voor deze oefening vindt u maximaal vijf paren. Dit betekent dat het retourtype een 2D-matrix is in plaats van een 1D-matrix. U moet de manier wijzigen waarop de code de resultaten retourneert. Laten we beginnen.

Wijzig het retourtype in de methodehandtekening van int[] naar int[,] door de code bij te werken naar het volgende:
```
int[,] TwoCoins(int[] coins, int target)
```
Vervolgens maakt u een int[,] matrix om uw resultaten op te slaan en te retourneren, en een tellervariabele om het aantal paren bij te houden dat aan de matrix is toegevoegd.
Werk de TwoCoins methode bij met de volgende code:
```
int[,] TwoCoins(int[] coins, int target) 
{
    int[,] result = {{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}};
    int count = 0;
```
U ziet dat u de resultaatmatrixelementen hebt geïnitialiseerd naar -1. Dit helpt u later wanneer u de gevonden paren wilt afdrukken.

Vervolgens gebruikt u de result matrix om elk gevonden paar op te slaan in plaats van de eerste overeenkomst te retourneren.

Werk de TwoCoins methode bij met de volgende 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++;
            }

        }
    }

U ziet dat count steeds wordt verhoogd wanneer een paar wordt toegevoegd aan de matrix. Dit kan leiden tot een indexfout die buiten de grenzen valt als er meer dan vijf paren zijn gevonden. Om deze fout te voorkomen, kunt u code toevoegen om de waarde te count controleren en het resultaat van de result matrix te retourneren.

Werk de logica in de TwoCoins methode bij met de volgende 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;
    }
}

Ten slotte moet u de definitieve retourinstructie bijwerken om het juiste resultaat te retourneren als er helemaal geen overeenkomsten worden gevonden of als er minder dan vijf overeenkomsten zijn gevonden.

Navigeer naar de return instructie in de TwoCoins methode. Wijzig de return instructie zodat deze overeenkomt met de volgende code:
```
if (count == 0) 
{
    return new int[0,0];
}
return result;
```
U kunt deze retourcode ook verkorten met behulp van de ternaire operator als volgt:
```
return (count == 0) ? new int[0,0] : result;
```
Belangrijk

Met de flexibiliteit van het return trefwoord kunt u de waarde van een expressie retourneren, zolang het resultaat overeenkomt met het opgegeven retourtype van de methode.

Op dit moment moet de TwoCoins methode overeenkomen met de volgende 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++;
            }
            if (count == result.GetLength(0)) 
            {
                return result;
            }
        }
    }
    return (count == 0) ? new int[0,0] : result;
}

De nieuwe retourmatrix vastleggen

Nu uw methode een 2D-matrix retourneert, kunt u uw code bijwerken om de resultaten op te halen en af te drukken. Omdat de resultaatmatrixelementen zijn geïnitialiseerd -1, kunt u een controle toevoegen om alle paren af te drukken totdat een -1 waarde is gevonden.

Navigeer naar het begin van uw programma waar de target variabele is gedefinieerd. Wijzig uw code als volgt:
```
int target = 30;
int[] coins = new int[] {5, 5, 50, 25, 25, 10, 5};
int[,] result = TwoCoins(coins, target);
```
Vervolgens werkt u de aanroep bij om de Console.WriteLine waarden correct af te result drukken.

Navigeer naar het Console.WriteLine gesprek. Werk uw code bij zodat deze overeenkomt met het volgende:

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 houdt u de controle op een lege matrix ongewijzigd en drukt u de waarden van de 2D-matrix af in een for-lus. Wanneer een -1 waarde wordt gevonden, breekt u de lus uit, omdat er geen volgende paren zijn.

Controleer uw werk

In deze taak voert u uw toepassing uit vanuit de Integrated Terminal en controleert u of uw code correct werkt. Laten we aan de slag gaan.

Vergelijk uw code met het volgende om te controleren of deze juist is:

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

Sla uw werk op met Ctrl + S of met het menu Visual Studio Code File.
Open zo nodig het geïntegreerde terminalpaneel van Visual Studio Code.

Klik in het deelvenster EXPLORER om een Terminal te openen op de locatie van de map TestProject met de rechtermuisknop op TestProject en selecteer Vervolgens Openen in geïntegreerde terminal.
Voer in de Terminal-opdrachtregel dotnet run in
Controleer of uw code de volgende uitvoer produceert:
```
Change found at positions:
0,3
0,4
1,3
1,4
3,6
```
Als uw code verschillende resultaten weergeeft, moet u uw code controleren om uw fout te vinden en updates aan te brengen. Voer de code opnieuw uit om te zien of u het probleem hebt opgelost. Ga door met het bijwerken en uitvoeren van uw code totdat uw code de verwachte resultaten produceert.
Werk vervolgens de waarde van target het volgende bij naar een waarde van 80:
```
int target = 80;
```
Sla uw werk op en voer dotnet-uitvoering in bij de Terminal-opdrachtprompt
Als u wilt controleren of uw code werkt zoals verwacht, vergelijkt u de uitvoer van uw toepassing met de volgende uitvoer:
```
No two coins make change
```
Als uw code verschillende resultaten weergeeft, moet u uw code controleren om uw fout te vinden en updates aan te brengen. Voer de code opnieuw uit om te zien of u het probleem hebt opgelost. Ga door met het bijwerken en uitvoeren van uw code totdat uw code de verwachte resultaten produceert.

Feedback

Is deze pagina nuttig?