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




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 = 21ultimo = 13penultimo = 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:
[Image] 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); }