C#: Desvendando os problemas clássicos de lógica e suas soluções

Fala, dev! Bora embarcar em mais uma aventura pelo universo da programação? Apertem os cintos e preparem-se para decolar rumo aos problemas clássicos de lógica em C# e como desvendá-los!

Hoje, vamos explorar juntos alguns problemas clássicos de lógica e aprender como resolvê-los de maneira prática e descomplicada. Então, vamos nessa? Bora codar!

Compreendendo a lógica de programação em C#

• Estruturas de controle: Utilizadas para direcionar o fluxo do seu código, como if/else, switch/case, for, while e do-while.

• Estruturas de dados: São formas de organizar e armazenar dados, como arrays, listas, dicionários, pilhas e filas.

• Orientação a objetos: C# é uma linguagem orientada a objetos, o que significa que você deve entender conceitos como classes, objetos, herança e polimorfismo.

Missão Extra: explore o universo de C#!

• Como começar a aprender C#

• Estruturas condicionais em C#: Guia prático

• Estruturas de repetição na prática com C#

• Introdução às classes e objetos em C#

• Array vs. Lists em C#: Qual escolher?

• Dominando switch case e operador ternário em C#

Esses artigos são como boosters para o seu foguete 🚀, garantindo que você chegue ainda mais longe na sua jornada como desenvolvedor C#. Vamos juntos, dev, porque o céu não é o limite, é apenas o começo!

Problemas clássicos de cálculos matemáticos

Calculadora básica

Console.WriteLine("Digite o primeiro número:");
double num1 = Convert.ToDouble(Console.ReadLine());

Console.WriteLine("Digite o operador (+, -, *, /):");
char operador = Console.ReadLine()[0];

Console.WriteLine("Digite o segundo número:");
double num2 = Convert.ToDouble(Console.ReadLine());

double resultado = 0;

switch (operador)
{
    case '+':
        resultado = num1 + num2;
        break;
    case '-':
        resultado = num1 - num2;
        break;
    case '*':
        resultado = num1 * num2;
        break;
    case '/':
        resultado = num1 / num2;
        break;
    default:
        Console.WriteLine("Operador inválido!");
        break;
}

Console.WriteLine($"Resultado: {resultado}");

Neste código, pedimos ao usuário dois números e um operador. Usamos um switch para determinar qual operação realizar com base no operador inserido. Simples e direto, né? Curioso para ver como o código se comporta? Clique aqui.

Fatorial de um número

int CalcularFatorial(int n)
{
    if (n == 0)
        return 1;
    else
        return n * CalcularFatorial(n - 1);
}

Aqui, a função CalcularFatorial chama a si mesma até atingir o caso base (n <= 1). Isso demonstra o poder da recursão de forma elegante. Que tal ver o fatorial de um número que você escolher? Teste o código aqui e surpreenda-se com os resultados!

Sequência de Fibonacci

int Fibonacci(int n)
{
    if (n <= 1)
        return n;
    else
        return Fibonacci(n - 1) + Fibonacci(n - 2);
}

Este código gera a sequência de Fibonacci até o número de termos desejado, usando um loop for para iterar e calcular cada termo. Quer ver a sequência de Fibonacci ganhar vida? Teste o código aqui e acompanhe a mágica acontecendo!

Fibonacci otimizado

void FibonacciOtimizado(int termos)
{
    int a = 0, b = 1, c;

    Console.Write($"{a} {b} ");

    for (int i = 2; i < termos; i++)
    {
        c = a + b;
        Console.Write($"{c} ");
        a = b;
        b = c;
    }
}

// Uso:
FibonacciOtimizado(termos);

Neste código, em vez de usar recursão, utilizamos um loop for para calcular cada termo da sequência de Fibonacci de forma eficiente. Atualizamos os valores conforme avançamos, economizando recursos e tempo. Ficou curioso para ver a sequência de Fibonacci voando em alta velocidade? Clique aqui e teste o código otimizado!

Máximo divisor comum (MDC) e mínimo múltiplo comum (MMC)

int CalcularMDC(int a, int b)
{
    while (b != 0)
    {
        int resto = a % b;
        a = b;
        b = resto;
    }
    return a;
}

// Uso:
Console.WriteLine("Digite o primeiro número:");
int num1 = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Digite o segundo número:");
int num2 = Convert.ToInt32(Console.ReadLine());
int mdc = CalcularMDC(num1, num2);
Console.WriteLine($"MDC de {num1} e {num2} é {mdc}");

Neste código, usamos um loop para aplicar repetidamente a lógica do algoritmo de Euclides, reduzindo os valores até encontrarmos o maior divisor comum. Simples, elegante e eficiente! Ahhh, lembra das aulas de matemática na escola? É a hora de ver esse conhecimento em ação! Vamos de código e descubra o MDC de dois números!

Manipulação de strings em C#

Verificar palíndromo

bool EUmPalindromo(string texto)
{
    string textoInvertido = new string(texto.Reverse().ToArray());
    return texto.Equals(textoInvertido, StringComparison.OrdinalIgnoreCase);
}

Aqui, removemos os espaços e transformamos o texto em minúsculas para facilitar a comparação. Em seguida, invertimos a string e comparamos com o original. Vamos descobrir se aquela palavra que você pensou é um palíndromo? Teste agora mesmo e divirta-se!

Contagem de palavras

Console.WriteLine("Digite uma frase:");
string frase = Console.ReadLine();
string[] palavras = frase.Split(' ');
int quantidade = palavras.Length;
Console.WriteLine($"A frase contém {quantidade} palavras.");

Este código divide a frase nos espaços em branco e conta quantos elementos existem no array resultante. Quer ver quantas palavras tem aquela frase famosa? Experimente o código e descubra!

Ordenação de Palavras

Console.WriteLine("Digite palavras separadas por espaço:");
string entrada = Console.ReadLine();
string[] listaPalavras = entrada.Split(' ');
Array.Sort(listaPalavras);

Console.WriteLine("Palavras em ordem alfabética:");
foreach (string palavra in listaPalavras)
{
    Console.WriteLine(palavra);
}

Aqui, usamos Array.Sort para ordenar as palavras em ordem alfabética. Pronto para organizar suas palavras? Teste o código aqui e veja a mágica acontecer!

Estruturas de dados e algoritmos clássicos

Busca linear e binária

Busca linear

int BuscaLinear(int[] array, int valorProcurado)
{
    for (int i = 0; i < array.Length; i++)
    {
        if (array[i] == valorProcurado)
            return i; // Encontrado!
    }
    return -1; // Não encontrado...
}

// Uso:
int[] numeros = { 42, 13, 7, 24, 89 };
int indice = BuscaLinear(numeros, 24);
Console.WriteLine(indice != -1 ? $"Número encontrado no índice {indice}!" : "Número não encontrado. Talvez esteja em outra galáxia.");

Neste código, percorremos o array elemento por elemento até encontrar o valor desejado. Agora é sua vez, dev! Teste esse código aqui.

Busca binária

Mas atenção! Essa busca só funciona em arrays ordenados. Tentar usar em um array bagunçado é como tentar organizar um armário jogando tudo para o alto.

int BuscaBinaria(int[] array, int valorProcurado)
{
    int minimo = 0;
    int maximo = array.Length - 1;

    while (minimo <= maximo)
    {
        int meio = (minimo + maximo) / 2;

        if (array[meio] == valorProcurado)
            return meio; // Encontrado!
        else if (array[meio] < valorProcurado)
            minimo = meio + 1;
        else
            maximo = meio - 1;
    }
    return -1; // Não encontrado...
}

// Uso:
int[] numerosOrdenados = { 3, 6, 8, 12, 15, 18, 21 };
int indice = BuscaBinaria(numerosOrdenados, 15);
Console.WriteLine(indice != -1 ? $"Número encontrado no índice {indice}!" : "Número

Nesse exemplo, dividimos o array ao meio repetidamente até encontrar o valor procurado. Teste você mesmo! Coloque esse código para rodar clicando aqui e veja a eficiência da busca binária em ação!

Algoritmos de ordenação

Bubble sort

void BubbleSort(int[] array)
{
    int tamanho = array.Length;
    for (int i = 0; i < tamanho - 1; i++)
    {
        for (int j = 0; j < tamanho - i - 1; j++)
        {
            if (array[j] > array[j + 1])
            {
                // Troca os elementos
                int temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

// Uso:
int[] numeros = { 29, 10, 14, 37, 13 };
BubbleSort(numeros);
Console.WriteLine("Array ordenado com Bubble Sort:");
foreach (int num in numeros)
{
    Console.Write($"{num} ");
}
// Saída: 10 13 14 29 37

Neste código, o algoritmo compara elementos adjacentes e os troca se estiverem fora de ordem, repetindo o processo até que o array esteja ordenado. Agora é com você! Teste este código clicando aqui.

Quick Sort

void QuickSort(int[] array, int inicio, int fim)
{
    if (inicio < fim)
    {
        int indicePivo = Particionar(array, inicio, fim);
        QuickSort(array, inicio, indicePivo - 1);
        QuickSort(array, indicePivo + 1, fim);
    }
}

int Particionar(int[] array, int inicio, int fim)
{
    int pivo = array[fim];
    int indiceMenor = inicio - 1;

    for (int j = inicio; j < fim; j++)
    {
        if (array[j] <= pivo)
        {
            indiceMenor++;
            // Troca array[indiceMenor] e array[j]
            int temp = array[indiceMenor];
            array[indiceMenor] = array[j];
            array[j] = temp;
        }
    }

    // Troca array[indiceMenor + 1] e array[fim]
    int temp1 = array[indiceMenor + 1];
    array[indiceMenor + 1] = array[fim];
    array[fim] = temp1;

    return indiceMenor + 1;
}

// Uso:
int[] numeros = { 33, 15, 10, 7, 40, 22 };
QuickSort(numeros, 0, numeros.Length - 1);
Console.WriteLine("\nArray ordenado com Quick Sort:");
foreach (int num in numeros)
{
    Console.Write($"{num} ");
}
// Saída: 7 10 15 22 33 40

Neste código, o Quick Sort divide e conquista, escolhendo um pivô e organizando os elementos menores à esquerda e os maiores à direita, recursivamente. Chegou sua vez! Experimente o código clicando aqui e veja a velocidade do quick sort!

Dicas para resolver problemas de lógica em C#

• Decomponha o problema: quebre em partes menores e resolva passo a passo.

• Desenhe fluxogramas: visualizar ajuda a entender a lógica.

• Teste seu código: use testes unitários para validar.

• Explore diferentes abordagens: há várias maneiras de resolver um problema.

• Consulte a documentação: sempre uma ótima fonte de conhecimento.

• Participe de comunidades: troque ideias e aprenda com outros devs.

Quer levar seu aprendizado para outro nível? Participe da comunidade Rocketseat! Lá você vai trocar ideias, tirar dúvidas, compartilhar suas conquistas e aprender com outros devs que, assim como você, estão nessa jornada rumo ao infinito e além! 💜

Conclusão