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 de dados e são ferramentas especialmente poderosas para criar os próprios conjuntos de dados. Desenvolver métodos para criar matrizes que representam seu conjunto de dados ajuda a manter o código reutilizável, organizado e simplificado. Neste exercício, você praticará o retorno de matrizes a partir de métodos.

Localizar moedas para fazer alterações

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

No Editor do Visual Studio Code, exclua todo o código existente dos exercícios anteriores.
Insira o código de exemplo a seguir no Editor do Visual Studio Code:
```
int[] TwoCoins(int[] coins, int target) 
{
    return  new int[0];
}
```
Caso não sejam 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 matriz int[] e retornar a variável, a instrução return permite que você crie e retorne valores simultaneamente.
Há muitas abordagens para resolver esse problema. Reserve um momento para considerar como você pode pesquisar dois números em uma matriz cuja soma seja igual a um determinado valor.

Neste exercício, a seguinte abordagem será usada:
1. Escolher um número da matriz
2. Verificar outros números um de cada vez para ver se eles se somam ao valor de destino
3. Retornar o resultado assim que uma correspondência for encontrada
Para verificar cada número na matriz, atualize o método TwoCoins 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 fixo e next representa os índices de moeda subsequentes. Você tentará somar cada moeda next com a moeda curr fixa para ver se elas são iguais ao valor alvo.
Em seguida, adicione lógica para verificar a soma das duas moedas para o valor de destino. Para fazer isso, atualize os loops for anteriores 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 retorná-los. Se eles não forem iguais, você poderá ignorá-los e continuar verificando.

Testar sua solução

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

Crie uma linha de código em branco acima da chamada do método TwoCoins. 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 método TwoCoins retornará uma matriz vazia se nenhuma alteração for encontrada. Você precisará verificar o tamanho da matriz antes de tentar imprimir a matriz result.

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

Se necessário, abra o painel Terminal Integrado do Visual Studio Code.
No prompt de comando do terminal, insira dotnet run. Compare sua saída com o seguinte:
```
Change found at positions 2 and 5
```
Se o código exibir resultados inesperados, você precisará examinar 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 o código até que ele produza os resultados esperados.

Localizar vários pares de moedas que dão troco

Nesta etapa, você estenderá o métodoTwoCoins para encontrar mais pares de moedas cuja soma seja igual ao valor alvo. Para este exercício, você encontrará no máximo 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!

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 matriz int[,] para armazenar e retornar seus resultados e uma variável contadora para acompanhar o número de pares adicionados à matriz.
Atualize o método TwoCoins pelo 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 para -1. Isso ajudará você posteriormente, quando quiser imprimir os pares que foram encontrados.

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

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

Atualize a lógica no método TwoCoins 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 instruçã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.

Navegue até a instrução return no método TwoCoins. Modifique a instrução return 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 da seguinte forma:
```
return (count == 0) ? new int[0,0] : result;
```
Importante

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

Neste ponto, o método TwoCoins 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 para -1, você pode adicionar uma verificação para imprimir todos os pares até que um valor -1 seja encontrado.

Navegue até o início do programa em que a variável target está definida. Modifique o 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 para imprimir corretamente os valores result.

Navegue até a chamada Console.WriteLine. Atualize o código para que ele corresponda ao seguinte exemplo de código:

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 no estado em que se encontra e imprime os valores da matriz 2D em um for-loop. Quando um valor -1 é encontrado, você sai do loop, pois não há pares seguintes.

Verificar seu trabalho

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

Compare o código com o seguinte para garantir que ele 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;
}

Salve seu trabalho usando Ctrl + S ou usando o menu Arquivo do Visual Studio Code.
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.
No prompt de comando do Terminal, insira dotnet run
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 exibir resultados diferentes, você precisará examinar 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 o código até que ele produza os resultados esperados.
Em seguida, atualize o valor de target para um valor de 80:
```
int target = 80;
```
Salve seu trabalho e, em seguida, digite dotnet run no prompt de comando do Terminal
Para verificar se o código está funcionando conforme o esperado, compare a saída do aplicativo com a seguinte saída:
```
No two coins make change
```
Se o código exibir resultados diferentes, você precisará examinar 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 o código até que ele produza os resultados esperados.

Comentários

Esta página foi útil?