Exercícios resolvidos sobre testes condicionais e laços em C

No artigo passado de nossa apostila de C, propomos uma série de questões e desafios, como parte do treinamento final sobre testes condicionais e laços em C.

Não há uma única, nem uma melhor maneira de resolver as questões.
Você terá que raciocinar e usar o que achar necessário.

Use:
Teste condicional IF ELSE
Laço WHILE
Laço FOR
Teste condicional SWITCH, com ou sem CONTINUE e BREAK
Laço DO WHILE

• Como ser programador C
• Leia este conteúdo no seu computador: Apostila C Progressivo

Exercícios sobre testes condicionais e loopings em C

Questão 0:
Vamos usar quatro variáveis na solução desse exercício: o 'n' vai armazenar quantos números o usuário vai inserir, o 'count' será usado como contador do laço, o 'num' é a variável que vai armazenar o número que o usuário digitar a cada iteração e por fim temos a variável 'menor' que, como o nome diz, vai armazenar o valor do menor número inserido.

A lógica da questão é simples: a cada laço, pedimos um número ao usuário.
Se esse número for o primeiro a ser inserido, ele será o menor até então.

Depois disso, continuamos a pedir os números ao usuário, e comparamos se esse número inserido é menor que o valor do número armazenado em 'menor', se for menor, a variável 'menor' vai receber esse novo valor.

Fazendo isso em todas as iterações, terminamos o laço com o menor valor inserido dentro da variável 'menor'.

Código C:

#include<stdio.h>

int main()
{
    int n,
        count,
        num,
        menor;

    printf("Quantos numeros deseja comparar: ");
    scanf("%d", &n);

    for(count = 1 ; count <= n ; count++)
    {
        printf("Insira o numero %d: ", count);
        scanf("%d", &num);

        if(count == 1)
            menor=num;

        if(num < menor)
            menor=num;
    }

    printf("Menor numero: %d", menor);
}

Questão 1:
Como de praxe, a variável 'n' recebe quantos números serão exibidos (de 1 até n) e a variável 'count' será a responsável pelo controle de nosso laço.

Iniciamos as variáveis 'pares' e 'impares', que irão receber o produto, com valor 1 (consegue pensar o motivo disso?)

A seguir entramos no laço, e dentro deste fazemos um teste condicional do tipo IF ELSE.
Testamos se o número é par. Se for, ele deixará resto da divisão por 2 igual a 0, então multiplicamos esse número por 'pares'.
Caso o número seja ímpar, vamos multiplicar esse 'count' pela variável 'impares'.

Assim, ao final do laço, teremos o produto de todos os pares e de todos os números ímpares de 1 até n, nas variáveis 'pares' e 'impares', respectivamente.

Relembrando que os seguintes símbolos:
pares *= count;
impares *= count;

Representam o mesmo que:
pares = pares * count;
impares = impares * count;

Assim, o código de nossa questão será:

Código C:

#include<stdio.h>

int main()
{
    int n,
        count,
        pares=1,
        impares=1;

    printf("Produto dos pares e impares ate o numero: ");
    scanf("%d", &n);


    for(count = 1 ; count <= n ; count++)
    {
        if(count % 2 == 0)
            pares *= count;
        else
            impares *= count;
    }

    printf("\nProduto dos pares: %d\n", pares);
    printf("\nProduto dos impares: %d\n", impares);
}

Questão 2:
Essa questão é uma continuação da anterior. Se fez a questão 1, fará essa com facilidade.
Porém essa tem uma utilidade muito grande: calcular fatoriais é muito importante em Matemática.
Assim, criando esse programa você terá criado uma ferramenta muito útil.

Pois bem, a variável 'n' e a 'count' você já sabe o que faz.
Agora, para armazenar o produto de 1 até n, vamos usar só a variável 'res', que nos fornecerá a resposta final.

O laço não tem segredo, basta fazer rodar de 1 até n, e a cada iteração multiplicamos esse número da iteração por 'res', que ao final temos o número desejado, o fatorial de n: n!

Código C:

#include<stdio.h>

int main()
{
    int n,
        count,
        res=1;

    printf("Insira um inteiro positivo: ");
    scanf("%d", &n);


    for(count = 1 ; count <= n ; count++)
        res *= count;

    printf("\nFatorial de %d eh: %d\n", n, res);
}

Questão 3:
O funcionamento é o seguinte:
Você inicia sua conta com um valor 'inicial'.
Depois de 1 mês, rendeu 0,5%, ou seja, você teve um lucro de 0.005 * inicial
Agora seu total é: inicial + 0,005*inicial = 1,005 inicial

Essa fórmula será usada sempre: o dinheiro que você tem no início do mês, é 1,005 daquele que você tinha há um mês atrás.
Então, 'valor_final' = '1,005*valor_final'

Após esse lucro gerado pela poupança, você vai adicionar, todo mês, um 'investimento'.
Assim, após o lucro e investimento, seu dinheiro é: valor_final = 1,005*valor_final + investimento

Logo, nosso código C fica:

Código C:

#include<stdio.h>

int main()
{
    float inicial = 0.0,
          investimento = 0.0,
          valor_final;

    int meses=0,
        count;

    printf("Investimento inicial: ");
    scanf("%f", &inicial);
    valor_final = inicial;

    printf("Investimento mensal: ");
    scanf("%f", &investimento);

    printf("Tempo, em meses, que deixara rendendo: ");
    scanf("%d", &meses);


    for(count = 1 ; count <= meses ; count++)
    {
        valor_final = 1.005*valor_final;
        valor_final += investimento;
        printf("Apos %d mes(es) voce tera: %.2f\n", count, valor_final);
    }

    printf("\nVoce comecou com %.2f e investiu %.2f durante %d meses\n", inicial, investimento, meses);
    printf("Seu lucro foi de %.2f\n", valor_final - inicial - (meses*investimento));
}

Questão 4:
Note que o usuário vai fornecer o número de linha e que o número da linha, é o primeiro dígito da linha.
Por exemplo, a linha 3 começa com o número 3.

Note também que estamos calculando os múltiplos.
Por exemplo, a linha 'n' tem elementos que são o 'n' multiplicado de 1 até n: n*1, n*2, n*3, ...,n*n

Vamos usar dois laços for, encadeados.
O primeiro, é o que vai ficar responsável pela linha. Essas linha vão de 1 até n.

Dentro de cada linha dessa, vamos imprimir 'n' elementos. Ou seja, vamos imprimir as colunas.
Cada elemento da coluna é o valor do número da linha multiplicado pelo número da coluna (as colunas variam de 1 até n).

Então, nosso código fica assim:

Código C:

#include<stdio.h>

int main()
{
    int num,
        linha,
        coluna;

    printf("Entre com o numero: ");
    scanf("%d", &num);

    for(linha = 1 ; linha <= num ; linha++)
    {
        for(coluna = 1 ; coluna <= linha ; coluna++)
            printf("%3d ", linha*coluna);

        printf("\n");
    }
}

Questão 5:
Uma maneira simples de fazer essa questão é com o laço while, pois as operações que deverão ser feitas, devem acontecer ENQUANTO o número for diferente de 1.

Dentro desse laço, usamos o resto da divisão do número por 2, pra saber se o número é par ou ímpar e então a operação é

Código C:

#include <stdio.h>

int main()
{
        int num;

        printf("Digite um numero inteiro: ");
        scanf("%d", &num);

        while(num != 1)
        {
            if( num%2 == 0)
                num = num/2;
            else
                num = 3*num +1;

            printf("%d ", num);
        }
}

Desafio dos números de FIbonacci:
Vamos chamar o n-ésimo termo da série de 'numero', o (n-1)-ésimo termo de 'ultimo' e o (n-2)-ésimo de 'penultimo'.
Assim, temos a fórmula geral: numero = ultimo + penultimo;

Para calcularmos o próximo termo da série ('numero'), temos que mudar os valores de 'ultimo' e 'penultimo'.
Para tal, o valor de 'penultimo' agora será o valor de 'ultimo', e o valor de 'ultimo' será agora o valor de 'numero'. Após fazer isso, podemos calcular o novo valor de 'numero', que é 'ultimo + penultimo'.

Por exemplo, chegamos em um ponto que:
numero = 21
ultimo = 13
penultimo = 8

Para calcular o próximo termo, fazemos 'penultimo=ultimo', ou seja, agora:
penultimo = 13
Analogamente, fazemos 'ultimo=numero', e temos:
ultimo=21

De posse desses novos valores, temos o novo valor de 'numero', que é: 21 + 13 = 34, que é o próximo termo da série.

Código C:

#include<stdio.h>

int main()
{
    int numero,
        ultimo=1,
        penultimo=0,
        count,
        termo;

    printf("Entre com o termo desejado: ");
    scanf("%d", &termo);

    for( count = 3 ; count <= termo ; count++)
    {
        numero = ultimo + penultimo;
        penultimo=ultimo;
        ultimo=numero;
    }

    printf("Elemento de termo %d: %d\n", termo, numero);
}

Desafio do diamante de asteriscos:
Há duas coisas na figura: espaços em branco e asteriscos.
Vamos resolver esse desafio analisando o padrão do número de asteriscos (variável asteriscos) e do número de espaços em branco (variável espacos).

Antes de desenhar o diamante, temos que checar se o número que o usuário forneceu é ímpar, através de um teste condicional:
if(numero%2 != 0)

Se não for, o programa cai no else e nossa aplicação C é finalizada.
Vamos desenhar o dito cujo.

Parte de cima do diamante
Qual o número inicial de espaços?
Note que é sempre: (numero-1)/2
...e essa é a lógica do problema, a parte mais difícil, que é notar esse padrão.

E o número de asteriscos inicial?
Fácil, é 1 e vai crescendo de 2 em 2 até que o número de asteriscos impressos seja igual a numero.

Pois bem, vamos desenhar linha por linha, imprimindo primeiro o número correto de espaços e depois o de asteriscos.
Esse controle de linhas é feito pela linha de código:
for(linha=1 ; espacos > 0 ; linha++)

Ou seja, vamos imprimir da linha 1 até a linha central (note que a linha central é a que tem espacos=0).

Agora, dentro desse looping vamos imprimir, em cada linha, primeiro o número de espaços e depois os asteriscos.
Sabemos que o número inicial de espaços é (numero-1)/2 e o número inicial de asteriscos é 1.

Para imprimir o número correto de espaços e asteriscos vamos usar a variável count:
for(count=1 ; count <= espacos ; count++)
for(count=1 ; count <= asteriscos ; count++)

Após o looping maior, o das linhas, temos que decrementar o número de espaços em 1, e incrementar o número de asteriscos em 2, além da quebra de linha.


Parte de cima do diamante
A lógica é a mesma da de cima, porém o número de espaços aumenta em 2, e o número de asteriscos é decrementado em 2.
Outra diferença é que vamos imprimir uma linha a menos, pois a linha central já foi impressa. Assim, essas linhas são impressas desde a primeira abaixo da linha central, até enquanto houver asteriscos (até ter 1, que é o último):
for(linha=1 ; asteriscos > 0 ; linha++) 

Código C:

#include<stdio.h>

int main()
{
        int numero,
            espacos,
            asteriscos,
            count,
            linha;

        printf("Insira um numero impar: ");
        scanf("%d", &numero);

        if(numero%2 != 0)
        {
            //Imprimindo a parte de cima do diamante
            asteriscos = 1;
            espacos = (numero-1)/2;
            for(linha = 1 ; espacos > 0 ; linha++)
            {
                //Espaços
                for(count = 1 ; count <= espacos ; count++)
                    printf(" ");

                //Asteriscos
                for(count = 1 ; count <= asteriscos ; count++)
                    printf("*");

                espacos--;
                asteriscos += 2;
                printf("\n");
            }

            //Imprimindo a parte de baixo do diamante
            for(linha=1 ; asteriscos > 0 ; linha++)
            {

                //Espaços
                for(count = 1 ; count <= espacos ; count++)
                    printf(" ");

                //Asteriscos
                for(count = 1 ; count <= asteriscos ; count++)
                    printf("*");

                espacos++;
                asteriscos -= 2;
                printf("\n");
            }

        }
        else
            printf("Não é ímpar!");

}

Super hiper mega desafio de Fibonacci
Essa questão é um pouco mais complicada, vai precisar de conhecimentos em Programação e um pouco de Matemática, mas não deixa de ser simples e engenhosa.

Na seção passada usamos três variáveis: 'numero', 'ultimo' e 'penultimo', para descrever o n-ésimo, (n-1)-ésimo e o (n-2)-ésimo termo, respectivamente.
Vamos excluir a variável 'numero', e trabalhar somente com o 'ultimo' e 'penultimo'.

Vamos supor que em um determinado ponto temos:
ultimo=5
penultimo=3

É fácil ver que o próximo termo é sempre (ultimo + penultimo), que nesse caso é 8.
Nosso objetivo então é fazer com que as variáveis tenham o valor ultimo=8 e penultimo=5, concorda?

Para que consigamos gerar mais números de Fibonacci, fazemos com que 'ultimo' receba seu antigo valor somado com o valor de 'penultimo', pois assim a variável 'ultimo' terá a soma dos dois números anteriores, como diz a regra de Fibonacci. Em C, fica assim:
ultimo = ultimo + penultimo

Agora ultimo = 8, e penultimo = 3.
Nosso objetivo agora é fazer com que penultimo receba o valor 5. Mas como, se nenhuma das variáveis possui valor 5? De onde obter esse valor?
De uma relação matemática da série de Fibonacci! Note que sempre: ultimo = numero - penultimo
Veja como obter 5:  5 = 8 -3 , ou seja, é o novo valor de 'ultimo' subtraído do atual valor de 'penultimo'.

Em C fica assim: penultimo = ultimo - penultimo

Note no desenho como variam os valores das variáveis no decorrer da execução:

Veja como fica o resultado:

Código C:

#include<stdio.h>

int main()
{
    int ultimo=1,
        penultimo=0,
        termo,
        count;

    printf("Entre com o termo desejado: ");
    scanf("%d", &termo);

    printf("%d\n%d\n", penultimo, ultimo);

    for( count = 3 ; count <= termo ; count++)
    {
        ultimo = ultimo + penultimo;
        penultimo = ultimo - penultimo;
    }

    printf("Elemento de termo %d: %d\n", termo, ultimo);
}