Ejercicio: Devolver matrices de métodos

10 minutos

Al desarrollar aplicaciones, a menudo tendrá que compilar y modificar conjuntos de datos. Los métodos son útiles para realizar operaciones sobre los datos y son herramientas especialmente eficaces para crear los propios conjuntos de datos. El desarrollo de métodos para crear matrices que representen el conjunto de datos ayuda a mantener el código reutilizable, organizado y simplificado. En este ejercicio, practicará la devolución de matrices con métodos.

Encontrar monedas para dar el cambio

Supongamos que tiene varias monedas de diferentes valores. Se le ha pedido que encuentre dos monedas cuya suma sea igual a un valor objetivo. En este ejercicio, las monedas disponibles se representan en una matriz de enteros. Deberá devolver los índices de las dos monedas en una nueva matriz. Comencemos.

En el Editor de Visual Studio Code, elimine cualquier código existente de los ejercicios anteriores.
En el Editor de Visual Studio Code, escriba el código siguiente:
```
int[] TwoCoins(int[] coins, int target) 
{
    return  new int[0];
}
```
En caso de que no se encuentren dos monedas, el método devuelve una matriz vacía. Dedique un momento a considerar la sintaxis del resultado devuelto. Aunque puede crear una variable para almacenar una nueva matriz int[] y devolver la variable, la instrucción return permite crear y devolver valores al mismo tiempo.
Hay muchos enfoques para resolver este problema. Dedique un momento a considerar cómo puede buscar dos números en una matriz cuya suma sea igual a un valor determinado.

En este ejercicio, se usará el siguiente enfoque:
1. Elegir un número de la matriz.
2. Comprobar otros números de uno en uno para ver si suman el valor objetivo.
3. Devolver el resultado tan pronto como se encuentre una coincidencia.
Para comprobar cada número de la matriz, actualice el método TwoCoins con el código siguiente:
```
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];
}
```
Aquí, curr representa un índice fijo de monedas y next representa los índices de moneda subsiguientes. Intentará agregar cada moneda next con la moneda fija curr para ver si son iguales al valor objetivo.
A continuación, agregue lógica para comprobar la suma de las dos monedas para el valor objetivo. Para ello, actualice los bucles for anteriores con el código siguiente:
```
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};
        }

    }
}
```
En este código, comprobará si la suma de los valores de curr y next en la matriz es igual al valor objetivo. Si la suma es igual, se crea una matriz para almacenar esos índices y devolverlos. Si no es igual, puede omitir estos valores y seguir la comprobación.

Prueba de la solución

En este paso, probará el código para asegurarse de que se ejecuta correctamente. En primer lugar, inicializará algunas variables para almacenar los datos de entrada y, luego, llamará al método e imprimirá los resultados.

Cree una nueva línea de código en blanco encima de la firma del método TwoCoins. A continuación, escriba el código siguiente:
```
int target = 60;
int[] coins = new int[] {5, 5, 50, 25, 25, 10, 5};
int[] result = TwoCoins(coins, target);
```
Recuerde que el método TwoCoins devuelve una matriz vacía si no se encuentra ningún cambio. Antes de intentar imprimir la matriz result, deberá comprobar su tamaño.

Escriba una nueva línea de código en blanco. A continuación, escriba el código siguiente:

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

Si es necesario, abra el panel del terminal integrado de Visual Studio Code.
En el símbolo del sistema del terminal, escriba dotnet run. Compare la salida con lo siguiente:
```
Change found at positions 2 and 5
```
Si el código muestra un resultado inesperado, debe revisarlo para buscar el error y corregirlo. Vuelva a ejecutar el código para ver si ha corregido el problema. Continúe actualizando y ejecutando el código hasta que genere los resultados esperados.

Encontrar varios pares de monedas para dar el cambio

En este paso, ampliará el método TwoCoins para encontrar más pares de monedas cuya suma sea igual al valor objetivo. Para este ejercicio, encontrará un máximo de cinco pares. Esto significa que el tipo de valor devuelto será una matriz 2D en lugar de una matriz 1D, y tendrá que modificar la forma en que el código devuelve los resultados. Comencemos.

Cambie el tipo de valor devuelto de la firma del método de int[] a int[,]; para ello, actualice el código con lo siguiente:
```
int[,] TwoCoins(int[] coins, int target)
```
A continuación, creará una matriz int[,] para almacenar y devolver los resultados, y una variable de contador para realizar un seguimiento del número de pares agregados a la matriz.
Actualice el método TwoCoins con el código siguiente:
```
int[,] TwoCoins(int[] coins, int target) 
{
    int[,] result = {{-1,-1},{-1,-1},{-1,-1},{-1,-1},{-1,-1}};
    int count = 0;
```
Observe que inicializó los elementos de la matriz de resultados en -1. Esto le ayudará más adelante cuando quiera imprimir los pares que se encontraron.

A continuación, usará la matriz result para almacenar cada par encontrado en lugar de devolver la primera coincidencia.

Actualice el método TwoCoins con el código siguiente:

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

        }
    }

Observe que count se incrementa cada vez que se agrega un par a la matriz. Esto puede provocar un error de índice fuera de los límites si se encuentran más de cinco pares. Para evitar este error, puede agregar código para comprobar el valor de count y devolver el resultado que rellena la matriz result.

Actualice la lógica del método TwoCoins con el código siguiente:

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

Por último, deberá actualizar la instrucción "return" final para devolver el resultado correcto si no se encuentra ninguna coincidencia o si se han encontrado menos de cinco coincidencias.

Vaya a la instrucción return en el método TwoCoins. Modifique la instrucción return para que coincida con el código siguiente:
```
if (count == 0) 
{
    return new int[0,0];
}
return result;
```
También puede acortar este código de devolución mediante el operador ternario de la siguiente manera:
```
return (count == 0) ? new int[0,0] : result;
```
Importante

La flexibilidad de la palabra clave return permite devolver el valor de una expresión, siempre y cuando el resultado coincida con el tipo de valor devuelto especificado del método.

En este momento, el método TwoCoins debe coincidir con el código siguiente:

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

Capturar la nueva matriz de devolución

Ahora que el método devuelve una matriz 2D, puede actualizar el código para recuperar e imprimir los resultados. Puesto que los elementos de la matriz de resultados se inicializaron en -1, puede agregar una comprobación para imprimir todos los pares hasta que se encuentre un valor -1.

Vaya al principio del programa donde se define la variable target. Modifique el código de la siguiente manera:
```
int target = 30;
int[] coins = new int[] {5, 5, 50, 25, 25, 10, 5};
int[,] result = TwoCoins(coins, target);
```
A continuación, actualizará la llamada a Console.WriteLine para imprimir correctamente los valores result.

Vaya a la llamada Console.WriteLine. Actualice su código para que coincida con el siguiente:

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

Aquí, se mantiene la comprobación de una matriz vacía tal cual y se imprimen los valores de la matriz 2D en un bucle "for". Cuando se encuentra un valor -1, se interrumpe el bucle, ya que no hay siguientes pares.

Comprobar el trabajo

En esta tarea, ejecutará la aplicación desde el terminal integrado y comprobará que el código funciona correctamente. Empecemos.

Compare el código con lo siguiente para asegurarse de que es correcto:

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

Guarde el trabajo con Ctrl + S o use el menú archivo de Visual Studio Code.
Si es necesario, abra el panel del terminal integrado de Visual Studio Code.

En el panel EXPLORADOR, para abrir un terminal en la ubicación de la carpeta TestProject, haga clic con el botón derecho en TestProject y, luego, seleccione Abrir en el terminal integrado.
En el símbolo del sistema del terminal, escriba dotnet run.
Compruebe que el código genera la salida siguiente:
```
Change found at positions:
0,3
0,4
1,3
1,4
3,6
```
Si el código muestra resultados diferentes, deberá revisarlo para encontrar el error y realizar las actualizaciones correspondientes. Vuelva a ejecutar el código para ver si ha corregido el problema. Continúe actualizando y ejecutando el código hasta que genere los resultados esperados.
A continuación, actualice el valor de target a un valor de 80:
```
int target = 80;
```
Guarde el trabajo y, luego, escriba dotnet run en el símbolo del sistema del terminal.
Para comprobar que el código funciona según lo previsto, compare la salida de la aplicación con la salida siguiente:
```
No two coins make change
```
Si el código muestra resultados diferentes, deberá revisarlo para encontrar el error y realizar las actualizaciones correspondientes. Vuelva a ejecutar el código para ver si ha corregido el problema. Continúe actualizando y ejecutando el código hasta que genere los resultados esperados.

Comentarios

¿Le ha resultado útil esta página?