Aprendendo C# do zero ao Intermediário— 3. Lógica de Programação: Condições e Repetições

Introdução à Lógica de Programação

Antes de escrever códigos, é essencial entender o que está por trás de cada decisão ou repetição que fazemos em um programa. A programação é, basicamente, uma série de instruções lógicas que descrevem como resolver problemas.

Vamos começar com uma definição simples: lógica de programação é a habilidade de organizar pensamentos e passos de forma clara e eficiente para resolver problemas. Pense nisso como planejar o caminho para um destino desconhecido — você precisa de um mapa ou, neste caso, um algoritmo que te guie.

Para facilitar o aprendizado, vamos relacionar conceitos de programação com situações do dia a dia. Dessa forma, você entenderá para que serve cada ferramenta antes de aprender como usá-la.

Associação com o Cotidiano

Decisões (Condições)

Imagine que você está decidindo o que comer no jantar: hambúrguer ou lasanha. Para tomar a decisão, você pode pensar assim:

• Se você está com vontade de algo rápido, escolhe o hambúrguer.
• Caso contrário, escolhe a lasanha.

Isso é uma condição: você analisa uma situação (“Estou com vontade de algo rápido?”) e toma uma decisão com base na resposta.

Observe que toda condição tem algo que acontece quando a condição é atendida (caso verdadeiro) e também quando não é atendida (caso falso). Por exemplo, imagine que você quer algo rápido para comer. Nesse caso (verdadeiro), escolhe o hambúrguer. Caso contrário (falso), opta por preparar a lasanha. As condições geralmente seguem esse princípio: “se isso acontecer, faça aquilo; se não, faça outra coisa.” É importante lembrar que você sempre precisa instruir a máquina sobre o que ela deve fazer em cada cenário.

Repetições (Loops)

Agora, imagine que você está contando quantos alunos existem em uma sala de aula. Você pode fazer isso assim:

• Olha para cada aluno, conta “1” e repete até chegar ao último aluno.

Essa ideia de repetir uma ação até atingir um objetivo é o que chamamos de loop ou laço de repetição.

Outro exemplo: o nascer do sol acontece todos os dias. Esse evento é cíclico, ou seja, se repete constantemente.

Mais exemplos do cotidiano podem incluir:

• Um atleta dando voltas em uma pista até atingir a quantidade definida de voltas.
• Uma criança que pergunta repetidamente “Já chegamos?” até receber uma resposta afirmativa.
• Verificar todas as gavetas de uma cômoda até encontrar um objeto perdido.

Entender esses conceitos no contexto do cotidiano ajuda a imaginar como eles funcionam nos programas. Por exemplo, o ato de escovar os dentes todos os dias ou verificar se há mensagens no celular são atividades cíclicas que se repetem regularmente. Da mesma forma, fazer um bolo pode envolver etapas repetitivas, como misturar ingredientes ou contar colheres de açúcar, até alcançar o resultado desejado.

Exemplos de Raciocínio Lógico

Antes de mergulharmos em condições e repetições, vamos abordar alguns exemplos simples de raciocínio lógico:

1. Resolver um problema: Imagine que você perdeu as chaves de casa. O que você faz? Primeiro, pensa em todos os lugares onde elas poderiam estar. Em seguida, verifica um por um até encontrar as chaves. Esse é um processo lógico: listar possibilidades e testá-las.
2. Classificar objetos: Você tem uma pilha de roupas e precisa separar as coloridas das brancas. Para cada peça, você avalia: “Essa peça é branca ou colorida?” e a coloca na pilha correspondente. Esse é outro exemplo de decisão lógica aplicada.
3. Planejar um caminho: Para ir do trabalho para casa, você avalia: “Qual o caminho mais rápido?” ou “Qual caminho tem menos trânsito?”. Você toma uma decisão baseada nas condições do momento.

Com esses exemplos em mente, vamos avançar para como traduzir essas ideias em código.

Tomando Decisões no Código: Condições com IF/ELSE e SWITCH

Na programação, utilizamos o comando if (se) para tomar decisões. Ele funciona como uma pergunta: “Se isso for verdade, então faça aquilo”. Já o comando else (senão) entra em ação quando a condição não é verdadeira, oferecendo uma alternativa ao programa: "Se isso não for verdade, então faça outra coisa".

Exemplo de Condição Simples

Vamos traduzir a decisão sobre o jantar em código:

string desejo = "rapido";

if (desejo == "rapido")
{
    Console.WriteLine("Escolha hambúrguer.");
}
else
{
    Console.WriteLine("Escolha lasanha.");
}

Criamos a variável desejo para guardar a nossa vontade. Essa variável armazena o valor “rapido” como exemplo inicial. Em seguida, utilizamos a estrutura if para perguntar: "Se o desejo for igual a 'rapido', o que devemos fazer?". O compilador verifica se a condição desejo == "rapido" é verdadeira ou falsa. Se for verdadeira, ele executa a linha Console.WriteLine("Escolha o hambúrguer");, exibindo a mensagem correspondente. Caso contrário, ele segue para a opção definida no else, que imprime "Escolha lasanha". Esse fluxo de decisão permite que o programa escolha ações diferentes dependendo do valor de entrada, facilitando o controle lógico do comportamento desejado.

Exemplo com Mais de Uma Condição

Imagine que você também considere a saúde da comida:

string desejo = "saudavel";

if (desejo == "rapido")
{
    Console.WriteLine("Escolha hambúrguer.");
}
else if (desejo == "saudavel")
{
    Console.WriteLine("Escolha salada.");
}
else
{
    Console.WriteLine("Escolha lasanha.");
}

Neste exemplo, a lógica do programa avalia o valor armazenado na variável desejo e toma decisões baseadas em condições múltiplas. Se o valor for "rapido", o programa exibe a mensagem "Escolha hambúrguer.". Caso contrário, ele verifica se o valor é "saudavel" e, se for verdadeiro, exibe "Escolha salada.". Por fim, se nenhuma das condições anteriores for satisfeita, o programa exibe a mensagem "Escolha lasanha." definida no bloco else. Essa estrutura permite considerar diferentes cenários e adaptar a resposta do programa com base nas entradas fornecidas. Assim, podemos ter uma lógica que reflete decisões mais complexas, garantindo que cada alternativa seja avaliada e tratada adequadamente.

O Comando SWITCH

O switch permite que você verifique uma única variável ou expressão e compare seu valor com diferentes casos. Pense nele como uma forma de escolher entre diversas opções, semelhante a um cardápio: você seleciona a opção que mais lhe agrada.

Exemplo Prático com SWITCH

Imagine que você tenha um programa que indique uma atividade baseada no dia da semana. Assim, você pode usar o switch para decidir o que fazer:

string diaDaSemana = "Sexta";

switch (diaDaSemana)
{
    case "Segunda":
        Console.WriteLine("Comece a semana com energia!");
        break;
    case "Terça":
        Console.WriteLine("Dia de estudar algo novo.");
        break;
    case "Quarta":
        Console.WriteLine("Metade da semana, continue firme!");
        break;
    case "Quinta":
        Console.WriteLine("Prepare-se para o final de semana.");
        break;
    case "Sexta":
        Console.WriteLine("Sexta-feira, hora de relaxar!");
        break;
    case "Sábado":
    case "Domingo":
        Console.WriteLine("Fim de semana! Aproveite o descanso.");
        break;
    default:
        Console.WriteLine("Dia inválido.");
        break;
}

Explicação do Código SWITCH:

• **switch (diaDaSemana)**: Avalia a variável diaDaSemana.
• **case "Segunda": até `case "Domingo":**: Cadacaserepresenta um cenário específico. Se o valor dediaDaSemanacorresponder ao valor docase`, o código dentro dele será executado.
• **break;**: Instrução que encerra a execução do switch para evitar que outros casos sejam verificados.
• **default:**: Caso nenhum dos case seja verdadeiro, o bloco default é executado.

Essa estrutura deixa o código mais organizado quando você precisa comparar um mesmo valor com várias possibilidades.

Repetindo Ações no Código: Repetições

Os loops permitem que você repita a mesma ação várias vezes, como contar os alunos de uma sala. Em C#, os loops mais comuns são:

1. while (enquanto)
2. for (para)
3. foreach (para cada)

Exemplo com while

Vamos contar até 10:

int contador = 1;

while (contador <= 10)
{
    Console.WriteLine(contador);
    contador++;
}

Saída esperada na tela:

1
2
3
4
5
6
7
8
9
10

O laço while é uma estrutura de repetição que continua executando enquanto uma condição for verdadeira. A principal diferença entre o for e o while é que no while você tem mais flexibilidade, mas a condição é verificada antes de cada iteração. Vamos analisar o funcionamento do código, passo a passo:

1. Inicialização (int contador = 1):

• Antes do laço começar, o contador é inicializado com o valor 1. O laço while não possui um campo explícito de inicialização, então o contador é inicializado fora do laço. Este é o valor com o qual começamos a contar.

2. Condição de Continuação (contador <= 10):

• A condição contador <= 10 é verificada antes de cada iteração.
• Enquanto o valor de contador for menor ou igual a 10, a condição será verdadeira, e o laço continuará a ser executado. Quando contador for maior que 10, a condição será falsa, e o laço se encerrará.

3. Corpo do Laço:

• Dentro do laço, temos duas operações principais:
• Imprimir o valor do contador (Console.WriteLine(contador)): O valor atual do contador será exibido na tela.
• Incrementar o contador (contador++): O contador é incrementado em 1 após cada iteração.

O que acontece a cada iteração do laço?

1. Primeira iteração:

• contador é igual a 1. A condição 1 <= 10 é verdadeira, então o laço entra em execução.
• O valor 1 é impresso na tela.
• O contador é incrementado para 2.

2. Segunda iteração:

• Agora, contador é 2. A condição 2 <= 10 é verdadeira, então o laço continua.
• O valor 2 é impresso na tela.
• O contador é incrementado para 3.

3. O processo continua até a décima iteração, onde:

• contador é 10. A condição 10 <= 10 ainda é verdadeira, então o laço imprime 10.
• O contador é incrementado para 11.

4. Quando o contador chega a 11:

• A condição 11 <= 10 se torna falsa, então o laço é interrompido.
• O programa segue para o código seguinte após o laço.

Resumo:

• O laço while começa verificando se a condição contador <= 10 é verdadeira.
• A cada iteração, o valor do contador é impresso, e o contador é incrementado.
• Quando o contador se torna maior que 10, a condição é falsa, e o laço termina.

Diferente do for, que é mais compacto, o while precisa de uma inicialização, uma condição e um incremento/decremento separados. Embora ambos sejam usados para loops, o while é mais comum quando o número de iterações não é conhecido de antemão e você depende de uma condição para controlar a repetição.

Exemplo com for

O mesmo código pode ser escrito de forma mais compacta com for:

for (int contador = 1; contador <= 10; contador++)
{
    Console.WriteLine(contador);
}

O laço for é uma estrutura de repetição bastante utilizada, e é uma maneira compacta de se escrever loops. Ele é composto por três partes principais, separadas por ponto e vírgula, e é assim que funciona:

1. Inicialização (int contador = 1):

• A primeira parte é a inicialização. Aqui, o contador é criado e atribuído o valor 1. Essa parte é executada uma única vez, no início da execução do laço. O contador vai começar com o valor 1.

2. Condição de Continuação (contador <= 10):

• A segunda parte é a condição de continuação. Ela é verificada antes de cada iteração (antes de cada repetição do laço).
• Neste caso, a condição é contador <= 10. Enquanto o valor de contador for menor ou igual a 10, o laço continuará a ser executado. Quando essa condição for falsa, o laço irá parar de rodar.

3. Incremento/Decremento (contador++):

• A terceira parte é o incremento (ou decremento), que ocorre ao final de cada iteração.
• O contador++ significa que, após a execução de uma iteração, o valor do contador será incrementado em 1 (ou seja, contador vai de 1 para 2, depois de 2 para 3, e assim por diante). Isso é necessário para evitar que o laço fique executando indefinidamente.

O que acontece a cada iteração do laço?

1. Na primeira iteração, contador começa em 1. A condição 1 <= 10 é verdadeira, então o corpo do laço é executado e imprime o valor 1. Após isso, o contador++ é executado, o contador passa a ser 2.
2. Na segunda iteração, contador agora é 2. A condição 2 <= 10 é ainda verdadeira, então o laço continua, imprime o valor 2, e contador se torna 3.
3. O processo se repete até que, na décima iteração, o contador seja 10. A condição 10 <= 10 ainda é verdadeira, então imprime 10, e o contador passa para 11.
4. Quando o contador chega a 11, a condição 11 <= 10 é falsa, o laço é interrompido e o programa segue para o código seguinte.

Resumo:

• O laço for inicializa o contador em 1, verifica se o contador é menor ou igual a 10 antes de cada iteração e, ao final de cada ciclo, incrementa o contador.
• O código imprimirá os números de 1 a 10, um por um, e depois o laço será interrompido.

Esse tipo de laço é muito útil quando você sabe com antecedência o número de vezes que a repetição precisa ocorrer.

Exemplo com foreach

Imagine que você tem uma lista de alunos, como se fosse uma fila de pessoas esperando para serem chamadas. Cada pessoa da fila tem um nome, e você quer chamar o nome de cada uma delas, uma por uma. O foreach é como uma maneira de percorrer essa fila e chamar os nomes de cada aluno, sem precisar se preocupar com a posição de cada um na fila.

Aqui está o código:

string[] alunos = { "Ana", "João", "Carlos" };

foreach (string aluno in alunos)
{
    Console.WriteLine(aluno);
}

Vamos quebrar isso em partes simples:

1. A lista de alunos:

string[] alunos = { "Ana", "João", "Carlos" };

Aqui, estamos criando uma lista com os nomes de três alunos: “Ana”, “João” e “Carlos”. Essa lista pode ser comparada a uma fila onde os alunos estão esperando para serem chamados.

2. O foreach:

foreach (string aluno in alunos)
{
    Console.WriteLine(aluno);
}

O foreach é uma ferramenta que ajuda a percorrer a lista de alunos, um por um. A palavra foreach indica que vamos passar por cada aluno da lista e, para cada aluno, vamos fazer algo — neste caso, vamos imprimir o nome dele na tela.

• **string aluno**: Aqui estamos dizendo que, para cada aluno na lista, vamos chamá-lo de aluno. Não precisamos nos preocupar com a posição dele na lista (não precisamos saber se é o primeiro, o segundo ou o terceiro), só queremos que o nome dele seja impresso.
• **in alunos**: Isso é como dizer "em cada aluno na lista".
• **Console.WriteLine(aluno);**: Esta linha simplesmente imprime o nome do aluno na tela.

Como o código funciona na prática?

1. Na primeira vez, o código pega o primeiro aluno da lista, que é “Ana”, e imprime o nome dela na tela.
2. Na segunda vez, ele pega o segundo aluno, “João”, e imprime o nome dele na tela.
3. Na terceira vez, ele pega o terceiro aluno, “Carlos”, e imprime o nome dele.

Depois disso, o código já percorreu toda a lista, então ele termina.

Por que o foreach é útil?

O foreach facilita bastante o trabalho de percorrer listas, porque você não precisa se preocupar com a posição dos alunos na lista (se eles estão no começo, no meio ou no final). Ele simplesmente vai passando por cada um e fazendo o que você pedir. Neste caso, estamos pedindo para imprimir o nome de cada aluno.

Isso torna o código mais simples e fácil de entender, especialmente quando você só quer processar todos os itens de uma lista, sem precisar de um controle manual sobre onde cada item está.

Exercícios Práticos

Agora é hora de praticar!

Exercício 1: Qual é o Maior Número?

Peça ao usuário dois números e exiba qual é o maior.

Console.WriteLine("Digite o primeiro número:");
int numero1 = Convert.ToInt32(Console.ReadLine());

Console.WriteLine("Digite o segundo número:");
int numero2 = Convert.ToInt32(Console.ReadLine());
if (numero1 > numero2)
{
    Console.WriteLine($"O maior número é: {numero1}");
}
else if (numero2 > numero1)
{
    Console.WriteLine($"O maior número é: {numero2}");
}
else
{
    Console.WriteLine("Os números são iguais.");
}

Exercício 2: Contagem Regressiva

Exiba uma contagem regressiva de 10 até 1.

for (int i = 10; i >= 1; i--)
{
    Console.WriteLine(i);
}
Console.WriteLine("Feliz Ano Novo!");

Exercício 3: Lista de Compras

Peça ao usuário itens para uma lista de compras e exiba todos no final.

List<string> listaDeCompras = new List<string>();
string item;

Console.WriteLine("Digite os itens da sua lista de compras (digite 'sair' para finalizar):");
while (true)
{
    item = Console.ReadLine();
    if (item.ToLower() == "sair")
        break;
    listaDeCompras.Add(item);
}

Console.WriteLine("Sua lista de compras:");
foreach (string produto in listaDeCompras)
{
    Console.WriteLine(produto);
}

Exercício 4: Menu de Atividades (usando SWITCH)

Crie um programa que peça ao usuário para digitar um dia da semana e, usando switch, exiba uma atividade específica para esse dia.

Console.WriteLine("Digite um dia da semana (ex: Segunda, Terça, etc.):");
string dia = Console.ReadLine();

switch (dia)
{
    case "Segunda":
        Console.WriteLine("Comece a semana com energia!");
        break;
    case "Terça":
        Console.WriteLine("Dia de estudar algo novo.");
        break;
    case "Quarta":
        Console.WriteLine("Metade da semana, continue firme!");
        break;
    case "Quinta":
        Console.WriteLine("Prepare-se para o final de semana.");
        break;
    case "Sexta":
        Console.WriteLine("Sexta-feira, hora de relaxar!");
        break;
    case "Sábado":
    case "Domingo":
        Console.WriteLine("Fim de semana! Aproveite o descanso.");
        break;
    default:
        Console.WriteLine("Dia inválido.");
        break;
}

Conclusão

Ao longo deste artigo, exploramos como conceitos fundamentais da lógica de programação, como condições e repetições, podem ser entendidos e aplicados de forma prática. Ao relacionar essas ideias com situações do dia a dia, ficou claro que a programação, apesar de técnica, é profundamente conectada à maneira como resolvemos problemas no cotidiano.

Compreender as condições ajuda você a tomar decisões nos seus programas, enquanto os loops oferecem uma forma poderosa de automatizar tarefas repetitivas. Dominar essas ferramentas é essencial para qualquer desenvolvedor iniciante, pois elas formam a base de soluções mais complexas.

Agora que você possui uma visão clara dos fundamentos, o próximo passo é praticar. Experimente criar pequenos programas que usem if, else e diferentes tipos de loops para resolver problemas simples. Ao fazer isso, você consolidará seus conhecimentos e estará preparado para enfrentar desafios mais avançados na programação.

Lembre-se: a prática é o elemento-chave para transformar a teoria em habilidade. Portanto, mãos à obra e bons estudos!