Exercice - Retourner des tableaux à partir de méthodes

  • 10 minutes

Lorsque vous développez des applications, vous devez souvent générer et modifier des jeux de données. Les méthodes sont utiles pour effectuer des opérations sur les données, et sont des outils particulièrement puissants pour créer les jeux de données eux-mêmes. Le développement de méthodes pour créer des tableaux représentant votre jeu de données permet de garder votre code réutilisable, organisé et simplifié. Dans cet exercice, vous allez vous entraîner à retourner des tableaux à partir de méthodes.

Trouver des pièces pour faire de la monnaie

Supposons que vous avez plusieurs pièces de différentes valeurs. Vous êtes chargé de trouver deux pièces dont la somme est égale à une valeur cible. Dans cet exercice, les pièces disponibles sont représentées dans un tableau d’entiers. Vous devez retourner les index des deux pièces dans un nouveau tableau. C’est parti !

  1. Dans l’Éditeur Visual Studio Code, supprimez tout code existant des exercices précédents.

  2. Entrez le code suivant dans l’Éditeur Visual Studio Code :

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

    Dans le cas où les deux pièces ne sont pas trouvées, votre méthode retourne un tableau vide. Prenez un moment pour examiner la syntaxe du résultat retourné. Même si vous pouvez créer une variable pour stocker un nouveau tableau int[] et retourner la variable, l’instruction return vous permet de créer et de retourner des valeurs simultanément.

  3. Il existe de nombreuses approches pour résoudre ce problème. Prenez un moment pour réfléchir à la façon dont vous pourriez rechercher deux nombres dans un tableau dont la somme est égale à une valeur donnée.

    Dans cet exercice, l’approche suivante est utilisée :

    1. Choisir un nombre dans le tableau
    2. Vérifier les autres nombres un par un pour voir s’ils correspondent à la valeur cible en les ajoutant
    3. Retourner le résultat dès qu’une correspondance est trouvée

  4. Pour examiner chaque nombre dans le tableau, mettez à jour la méthode TwoCoins avec le code suivant :

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

    Ici, curr représente l’index d’une pièce fixe et next représente les index de pièces suivantes. Vous allez essayer d’ajouter chaque pièce next à la pièce curr fixe pour voir si elles sont égales à la valeur cible.

  5. Ensuite, ajoutez une logique pour vérifier si la somme des deux pièces correspond à la valeur cible. Pour ce faire, mettez à jour les boucles for précédentes avec le code suivant :

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

    }
}

    Dans ce code, vous vérifiez si la somme des valeurs au niveau de curr et de next dans le tableau est égale à la valeur cible. Si la somme est égale, vous créez un tableau pour stocker ces index et le retourner. Dans le cas contraire, vous pouvez les ignorer et continuer la vérification.

Tester votre solution

Dans cette étape, vous allez tester votre code pour vous assurer qu’il s’exécute correctement. Tout d’abord, vous allez initialiser des variables pour stocker les données d’entrée, puis vous allez appeler la méthode et afficher les résultats.

  1. Créez une ligne de code vide au-dessus de la signature de la méthode TwoCoins. Entrez ensuite le code suivant :

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

    Rappelez-vous que la méthode TwoCoins retourne un tableau vide si aucune pièce n’est trouvée. Vous devez vérifier la taille du tableau avant d’essayer d’afficher le tableau result.

  2. Entrez une nouvelle ligne de code vide. Entrez ensuite le code suivant :

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

  3. Si nécessaire, ouvrez le volet Terminal intégré de Visual Studio Code.

  4. À l’invite de commandes du Terminal, entrez dotnet run. Comparez votre sortie avec ce qui suit :

    Change found at positions 2 and 5

    Si votre code affiche des résultats inattendus, vous devez le passer en revue afin de trouver votre erreur et d’effectuer des mises à jour. Réexécutez le code pour voir si vous avez résolu le problème. Continuez à mettre à jour et à exécuter votre code jusqu’à ce qu’il produise les résultats attendus.

Rechercher plusieurs paires de pièces qui font de la monnaie

Dans cette étape, vous allez étendre la méthode TwoCoins pour rechercher d’autres paires de pièces dont la somme est égale à la valeur cible. Pour cet exercice, vous allez rechercher un maximum de cinq paires. Cela signifie que le type de retour sera un tableau 2D au lieu d’un tableau 1D, et que vous devrez modifier la façon dont votre code retourne les résultats. C’est parti !

  1. Changez le type de retour dans la signature de méthode en remplaçant int[] par int[,] en mettant à jour votre code avec ce qui suit :

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

    Ensuite, vous allez créer un tableau int[,] pour stocker et retourner vos résultats, ainsi qu’une variable de compteur pour suivre le nombre de paires ajoutées au tableau.

  2. Mettez à jour la méthode TwoCoins avec le code suivant :

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

    Notez que vous avez initialisé les éléments du tableau de résultats sur -1. Cela vous aidera plus tard lorsque vous voudrez afficher les paires trouvées.

    Ensuite, vous allez utiliser le tableau result pour stocker chaque paire trouvée au lieu de retourner la première correspondance.

  3. Mettez à jour la méthode TwoCoins avec le code suivant :

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

        }
    }

    Notez que count est incrémenté chaque fois qu’une paire est ajoutée au tableau. Cela peut entraîner une erreur d’index hors limites s’il y a plus de cinq paires trouvées. Pour éviter cette erreur, vous pouvez ajouter du code pour vérifier la valeur de count et retourner le résultat que le tableau result contient.

  4. Mettez à jour la logique dans la méthode TwoCoins avec le code suivant :

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

    Enfin, vous devez mettre à jour l’instruction return finale pour retourner le résultat correct si aucune correspondance n’est trouvée ou si moins de cinq correspondances ont été trouvées.

  5. Accédez à l’instruction return dans la méthode TwoCoins. Modifiez l’instruction return pour qu’elle corresponde au code suivant :

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

    Vous pouvez également raccourcir ce code de retour à l’aide de l’opérateur ternaire comme suit :

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

    Important

    La flexibilité du mot clé return vous permet de retourner la valeur d’une expression, tant que le résultat correspond au type de retour spécifié de la méthode.

  6. À ce stade, la méthode TwoCoins doit correspondre au code suivant :

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

Capturer le nouveau tableau de retour

Maintenant que votre méthode retourne un tableau 2D, vous pouvez mettre à jour votre code pour récupérer et afficher les résultats. Étant donné que les éléments du tableau de résultats ont été initialisés sur -1, vous pouvez ajouter une vérification pour afficher toutes les paires jusqu’à ce qu’une valeur -1 soit trouvée.

  1. Accédez au début de votre programme où la variable target est définie. Modifiez votre code comme suit :

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

    Ensuite, vous allez mettre à jour l’appel à Console.WriteLine pour afficher correctement le valeurs result.

  2. Accédez à l’appel à Console.WriteLine. Mettez à jour votre code pour qu’il corresponde à ce qui suit :

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

    Ici, vous conservez la recherche d’un tableau vide en l’état et affichez les valeurs du tableau 2D dans une boucle for. Lorsqu’une valeur -1 est trouvée, vous sortez de la boucle puisqu’il n’y a pas de paires suivantes.

Vérifier votre travail

Dans cette tâche, vous allez exécuter votre application à partir du Terminal intégré et vérifier que votre code fonctionne correctement. Commençons.

  1. Comparez votre code au suivant pour vous assurer qu’il est correct :

    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. Enregistrez votre travail à l’aide de Ctrl + S ou du menu Fichier de Visual Studio Code.

  3. Si nécessaire, ouvrez le volet Terminal intégré de Visual Studio Code.

    Dans le volet EXPLORATEUR, pour ouvrir un Terminal à l’emplacement de votre dossier TestProject, cliquez avec le bouton droit sur TestProject, puis sélectionnez Ouvrir dans le Terminal intégré.

  4. À l’invite de commandes du Terminal, entrez dotnet run.

  5. Vérifiez que votre code produit la sortie suivante :

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

    Si votre code affiche des résultats différents, vous devez le passer en revue afin de trouver votre erreur et d’effectuer des mises à jour. Réexécutez le code pour voir si vous avez résolu le problème. Continuez à mettre à jour et à exécuter votre code jusqu’à ce qu’il produise les résultats attendus.

  6. Ensuite, mettez à jour la valeur de target avec la valeur 80 :

    int target = 80;

  7. Enregistrez votre travail, puis entrez dotnet run à l’invite de commandes du Terminal.

  8. Pour vérifier que votre code fonctionne comme prévu, comparez la sortie de votre application avec la sortie suivante :

    No two coins make change

    Si votre code affiche des résultats différents, vous devez le passer en revue afin de trouver votre erreur et d’effectuer des mises à jour. Réexécutez le code pour voir si vous avez résolu le problème. Continuez à mettre à jour et à exécuter votre code jusqu’à ce qu’il produise les résultats attendus.