Ćwiczenie — zwracanie tablic z metod

  • 10 min

Podczas tworzenia aplikacji często trzeba tworzyć i modyfikować zestawy danych. Metody są przydatne do wykonywania operacji na danych i są szczególnie zaawansowanymi narzędziami do tworzenia samych zestawów danych. Tworzenie metod tworzenia tablic reprezentujących zestaw danych pomaga zachować wielokrotne użycie, organizowanie i upraszczanie kodu. W tym ćwiczeniu przećwiczyć będziesz zwracać tablice z metod.

Znajdź monety, aby dokonać zmian

Załóżmy, że masz kilka monet o różnych wartościach. Masz za zadanie znaleźć dwie monety, których suma jest równa wartości docelowej. W tym ćwiczeniu dostępne monety są reprezentowane w tablicy całkowitej. Musisz zwrócić indeksy dwóch monet w nowej tablicy. Zaczynamy!

  1. W edytorze programu Visual Studio Code usuń dowolny istniejący kod z poprzednich ćwiczeń.

  2. Wprowadź następujący kod w edytorze programu Visual Studio Code:

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

    W przypadku, gdy nie znaleziono dwóch monet, metoda zwraca pustą tablicę. Pośmiń chwilę, aby wziąć pod uwagę składnię zwróconego wyniku. Chociaż można utworzyć zmienną do przechowywania nowej int[] tablicy i zwracać zmienną, return instrukcja umożliwia jednoczesne tworzenie i zwracanie wartości.

  3. Istnieje wiele podejść do rozwiązania tego problemu. Pośmiń chwilę, aby zastanowić się, jak można wyszukać dwie liczby w tablicy, której suma jest równa danej wartości.

    W tym ćwiczeniu zostanie użyte następujące podejście:

    1. Wybierz jedną liczbę z tablicy
    2. Sprawdź inne liczby pojedynczo, aby sprawdzić, czy sumują się do wartości docelowej
    3. Zwróć wynik natychmiast po znalezieniu dopasowania

  4. Aby sprawdzić każdą liczbę w tablicy, zaktualizuj metodę TwoCoins przy użyciu następującego kodu:

    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 Tutaj reprezentuje jeden stały indeks monet i next reprezentuje kolejne indeksy monet. Spróbujesz dodać każdą next monetę ze stałą curr monetą, aby sprawdzić, czy są równe wartości docelowej.

  5. Następnie dodaj logikę, aby sprawdzić sumę dwóch monet dla wartości docelowej. W tym celu zaktualizuj poprzednie for pętle przy użyciu następującego kodu:

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

    }
}

    W tym kodzie sprawdzasz, czy suma wartości na curr i next w tablicy jest równa wartości docelowej. Jeśli suma jest równa, należy utworzyć tablicę do przechowywania tych indeksów i zwrócić ją. Jeśli nie są równe, możesz je zignorować i sprawdzić.

Testowanie rozwiązania

W tym kroku przetestujesz kod, aby upewnić się, że działa poprawnie. Najpierw zainicjujesz niektóre zmienne do przechowywania danych wejściowych, a następnie wywołasz metodę i wyświetlisz wyniki.

  1. Utwórz nowy pusty wiersz kodu powyżej TwoCoins podpisu metody. Następnie wprowadź następujący kod:

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

    Pamiętaj, że TwoCoins metoda zwraca pustą tablicę, jeśli nie zostanie znaleziona żadna zmiana. Przed podjęciem próby wydrukowania tablicy należy sprawdzić rozmiar tablicy result .

  2. Wprowadź nowy pusty wiersz kodu. Następnie wprowadź następujący kod:

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

  3. W razie potrzeby otwórz panel zintegrowany terminal programu Visual Studio Code.

  4. W wierszu polecenia terminalu wprowadź polecenie dotnet run. Porównaj dane wyjściowe z następującymi danymi:

    Change found at positions 2 and 5

    Jeśli kod wyświetla nieoczekiwane wyniki, musisz przejrzeć kod, aby znaleźć błąd i wprowadzić aktualizacje. Uruchom ponownie kod, aby sprawdzić, czy problem został rozwiązany. Kontynuuj aktualizowanie i uruchamianie kodu, dopóki kod nie generuje oczekiwanych wyników.

Znajdź wiele par monet, które zmieniają

W tym kroku rozszerzysz metodę TwoCoins , aby znaleźć więcej par monet, których suma jest równa wartości docelowej. W tym ćwiczeniu znajdziesz maksymalnie pięć par. Oznacza to, że zwracany typ będzie tablicą 2D zamiast tablicy 1D i należy zmodyfikować sposób, w jaki kod zwraca wyniki. Zaczynamy!

  1. Zmień typ zwracany w sygnaturze metody z int[] na int[,] , aktualizując kod na następujące:

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

    Następnie utworzysz tablicę int[,] do przechowywania i zwracania wyników oraz zmiennej licznika w celu śledzenia liczby par dodanych do tablicy.

  2. Zaktualizuj metodę TwoCoins przy użyciu następującego kodu:

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

    Zwróć uwagę, że zainicjowano elementy tablicy wyników na -1. Pomoże to później, gdy chcesz wydrukować znalezione pary.

    Następnie użyjesz tablicy do przechowywania każdej znalezionej result pary zamiast zwracania pierwszego dopasowania.

  3. Zaktualizuj metodę TwoCoins przy użyciu następującego kodu:

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

        }
    }

    Zwróć uwagę, że jest zwiększana za każdym razem, count gdy para jest dodawana do tablicy. Może to spowodować błąd indeksu poza granicami, jeśli znaleziono więcej niż pięć par. Aby zapobiec temu błędowi, możesz dodać kod w celu sprawdzenia wartości count i zwrócenia wyniku result tablicy.

  4. Zaktualizuj logikę w metodzie TwoCoins przy użyciu następującego kodu:

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

    Na koniec należy zaktualizować ostateczną instrukcję return, aby zwrócić prawidłowy wynik, jeśli w ogóle nie znaleziono dopasowań lub jeśli znaleziono mniej niż pięć dopasowań.

  5. Przejdź do instrukcji return w metodzie TwoCoins . Zmodyfikuj instrukcję tak return , aby odpowiadała następującemu kodowi:

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

    Możesz również skrócić ten kod powrotny przy użyciu operatoraternary w następujący sposób:

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

    Ważne

    Elastyczność słowa kluczowego return umożliwia zwrócenie wartości wyrażenia, o ile wynik jest zgodny z określonym typem zwracanym przez metodę.

  6. W tym momencie metoda powinna być zgodna TwoCoins z następującym kodem:

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

Przechwytywanie nowej tablicy zwracanej

Teraz, gdy metoda zwraca tablicę 2D, możesz zaktualizować kod, aby pobrać i wydrukować wyniki. Ponieważ elementy tablicy wyników zostały zainicjowane do -1elementu , można dodać sprawdzenie, aby wydrukować wszystkie pary do momentu znalezienia -1 wartości.

  1. Przejdź do początku programu, na którym zdefiniowano zmienną target . Zmodyfikuj kod w następujący sposób:

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

    Następnie zaktualizujesz wywołanie , aby Console.WriteLine poprawnie wydrukować result wartości.

  2. Przejdź do Console.WriteLine połączenia. Zaktualizuj kod, aby był zgodny z następującymi elementami:

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

    W tym miejscu należy zachować sprawdzanie pustej tablicy w takiej postaci i wyświetlić wartości tablicy 2D w pętli for-loop. Po znalezieniu -1 wartości należy przerwać pętlę, ponieważ nie ma żadnych następnych par.

Sprawdź swoją pracę

W tym zadaniu uruchomisz aplikację ze zintegrowanego terminalu i sprawdzisz, czy kod działa poprawnie. Zaczynajmy.

  1. Porównaj kod z następującymi elementami, aby upewnić się, że jest on poprawny:

    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. Zapisz swoją pracę przy użyciu Ctrl + S lub za pomocą menu Plik programu Visual Studio Code.

  3. W razie potrzeby otwórz panel zintegrowany terminal programu Visual Studio Code.

    W panelu EKSPLORATOR, aby otworzyć terminal w lokalizacji folderu TestProject, kliknij prawym przyciskiem myszy pozycję TestProject, a następnie wybierz polecenie Otwórz w zintegrowanym terminalu.

  4. W wierszu polecenia terminalu wprowadź polecenie dotnet run

  5. Sprawdź, czy kod generuje następujące dane wyjściowe:

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

    Jeśli kod wyświetla różne wyniki, musisz przejrzeć kod, aby znaleźć błąd i wprowadzić aktualizacje. Uruchom ponownie kod, aby sprawdzić, czy problem został rozwiązany. Kontynuuj aktualizowanie i uruchamianie kodu, dopóki kod nie generuje oczekiwanych wyników.

  6. Następnie zaktualizuj wartość target wartości na wartość :80

    int target = 80;

  7. Zapisz swoją pracę, a następnie wprowadź polecenie dotnet run w wierszu polecenia terminalu

  8. Aby sprawdzić, czy kod działa zgodnie z oczekiwaniami, porównaj dane wyjściowe aplikacji z następującymi danymi wyjściowymi:

    No two coins make change

    Jeśli kod wyświetla różne wyniki, musisz przejrzeć kod, aby znaleźć błąd i wprowadzić aktualizacje. Uruchom ponownie kod, aby sprawdzić, czy problem został rozwiązany. Kontynuuj aktualizowanie i uruchamianie kodu, dopóki kod nie generuje oczekiwanych wyników.