Exercício - Retornar matrizes de métodos

  • 10 minutos

Ao desenvolver aplicativos, muitas vezes você precisará criar e modificar conjuntos de dados. Os métodos são úteis para executar operações em dados e são ferramentas especialmente poderosas para criar os próprios conjuntos de dados. O desenvolvimento de métodos para criar matrizes que representam seu conjunto de dados ajuda a manter seu código reutilizável, organizado e simplificado. Neste exercício, você praticará o retorno de matrizes de métodos.

Encontre moedas para fazer o troco

Suponha que você tenha várias moedas de valores diferentes. Você é encarregado de encontrar duas moedas cuja soma é igual a um valor-alvo. Neste exercício, as moedas disponíveis são representadas em uma matriz inteira. Você precisará retornar os índices das duas moedas em uma nova matriz. Vamos começar!

  1. No Editor de Códigos do Visual Studio, exclua qualquer código existente dos exercícios anteriores.

  2. Insira o seguinte código no Editor de Códigos do Visual Studio:

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

    No caso em que não são encontradas duas moedas, seu método retorna uma matriz vazia. Reserve um momento para considerar a sintaxe do resultado retornado. Embora você possa criar uma variável para armazenar uma nova int[] matriz e retornar a variável, a return instrução permite que você crie e retorne valores simultaneamente.

  3. Existem muitas abordagens para resolver este problema. Reserve um momento para considerar como você pode procurar dois números em uma matriz cuja soma é igual a um determinado valor.

    Neste exercício, será utilizada a seguinte abordagem:

    1. Escolha um número da matriz
    2. Verifique outros números, um de cada vez, para ver se eles se somam ao valor-alvo
    3. Devolver o resultado assim que for encontrada uma correspondência

  4. Para verificar cada número na matriz, atualize o TwoCoins método com o seguinte código:

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

    Aqui, curr representa um índice de moeda fixa e next representa os índices de moeda subsequentes. Você tentará adicionar cada next moeda com a moeda fixa curr para ver se elas correspondem ao valor-alvo.

  5. Em seguida, adicione lógica para verificar a soma das duas moedas para o valor alvo. Para fazer isso, atualize os loops anteriores for com o seguinte código:

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

    }
}

    Neste código, você está verificando se a soma dos valores em curr e next na matriz é igual ao valor de destino. Se a soma for igual, você criará uma matriz para armazenar esses índices e devolvê-la. Se eles não forem iguais, você pode ignorá-los e continuar verificando.

Teste a sua solução

Nesta etapa, você testará seu código para garantir que ele esteja sendo executado corretamente. Primeiro, você inicializará algumas variáveis para armazenar os dados de entrada, depois chamará o método e imprimirá os resultados.

  1. Crie uma nova linha de código em branco acima da assinatura do TwoCoins método. Em seguida, insira o seguinte código:

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

    Lembre-se de que o TwoCoins método retorna uma matriz vazia se nenhuma alteração for encontrada. Você precisará verificar o tamanho da matriz antes de tentar imprimi-la result .

  2. Insira uma nova linha de código em branco. Em seguida, insira o seguinte código:

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

  3. Se necessário, abra o painel Terminal integrado do Visual Studio Code.

  4. No prompt de comando do Terminal, digite dotnet run. Compare a sua saída com o seguinte:

    Change found at positions 2 and 5

    Se o código apresentar resultados inesperados, terá de rever o código para encontrar o erro e fazer atualizações. Execute o código novamente para ver se você corrigiu o problema. Continue atualizando e executando seu código até que seu código produza os resultados esperados.

Encontre vários pares de moedas que fazem a mudança

Nesta etapa, você estenderá o TwoCoins método para encontrar mais pares de moedas cuja soma é igual ao valor alvo. Para este exercício, você encontrará um máximo de cinco pares. Isso significa que o tipo de retorno será uma matriz 2D em vez de uma matriz 1D, e você precisará modificar a maneira como seu código retorna os resultados. Vamos começar!

  1. Altere o tipo de retorno na assinatura do método de int[] para int[,] atualizando seu código para o seguinte:

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

    Em seguida, você criará uma int[,] matriz para armazenar e retornar seus resultados e uma variável de contador para acompanhar o número de pares adicionados à matriz.

  2. Atualize o TwoCoins método com o seguinte código:

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

    Observe que você inicializou os elementos da matriz de resultados em -1. Isso irá ajudá-lo mais tarde quando você quiser imprimir os pares que foram encontrados.

    Em seguida, você usará a result matriz para armazenar cada par encontrado em vez de retornar a primeira correspondência.

  3. Atualize o TwoCoins método com o seguinte código:

    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 é incrementado toda vez que count um par é adicionado à matriz. Isso pode causar um erro de índice fora dos limites se houver mais de cinco pares encontrados. Para evitar esse erro, você pode adicionar código para verificar o valor e count retornar o resultado da result matriz está preenchido.

  4. Atualize a TwoCoins lógica no método com o seguinte código:

    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 fim, você precisará atualizar a declaração de retorno final para retornar o resultado correto se nenhuma correspondência for encontrada ou se menos de cinco correspondências tiverem sido encontradas.

  5. Navegue até a return instrução no TwoCoins método. Modifique a return instrução para corresponder ao seguinte código:

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

    Você também pode encurtar esse código de retorno usando o operador ternário assim:

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

    Importante

    A flexibilidade da return palavra-chave permite que você retorne o valor de uma expressão, desde que o resultado corresponda ao tipo de retorno especificado do método.

  6. Neste ponto, o TwoCoins método deve corresponder ao seguinte código:

    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 a nova matriz de retorno

Agora que seu método está retornando uma matriz 2D, você pode atualizar seu código para recuperar e imprimir os resultados. Como os elementos da matriz de resultados foram inicializados no -1, você pode adicionar uma verificação para imprimir todos os pares até que um -1 valor seja encontrado.

  1. Navegue até o início do seu programa onde a target variável está definida. Modifique seu código da seguinte maneira:

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

    Em seguida, você atualizará a chamada para Console.WriteLine imprimir corretamente os result valores.

  2. Navegue até a Console.WriteLine chamada. Atualize o código para corresponder ao seguinte:

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

    Aqui, você mantém a verificação de uma matriz vazia como está e imprime os valores da matriz 2D em um loop for. Quando um -1 valor é encontrado, você sai do loop, pois não há próximos pares.

Verifique o seu trabalho

Nesta tarefa, você executará seu aplicativo a partir do Terminal Integrado e verificará se seu código está funcionando corretamente. Vamos começar.

  1. Compare seu código com o seguinte para garantir que esteja correto:

    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. Salve seu trabalho usando Ctrl + S ou usando o menu Arquivo de código do Visual Studio.

  3. Se necessário, abra o painel Terminal integrado do Visual Studio Code.

    No painel EXPLORER, para abrir um Terminal no local da pasta TestProject, clique com o botão direito do mouse em TestProject e selecione Abrir no Terminal Integrado.

  4. No prompt de comando do Terminal, digite dotnet run

  5. Verifique se o código produz a seguinte saída:

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

    Se o código apresentar resultados diferentes, terá de rever o código para encontrar o erro e fazer atualizações. Execute o código novamente para ver se você corrigiu o problema. Continue atualizando e executando seu código até que seu código produza os resultados esperados.

  6. Em seguida, atualize o valor de para um valor de target80:

    int target = 80;

  7. Salve seu trabalho e digite dotnet run no prompt de comando do Terminal

  8. Para verificar se o código está funcionando conforme o esperado, compare a saída do seu aplicativo com a seguinte saída:

    No two coins make change

    Se o código apresentar resultados diferentes, terá de rever o código para encontrar o erro e fazer atualizações. Execute o código novamente para ver se você corrigiu o problema. Continue atualizando e executando seu código até que seu código produza os resultados esperados.