Baixe MC102 – Algoritmos e Programação e outras Exercícios em PDF para Algoritmos e Programação, somente na Docsity!
MC102 – Algoritmos e Programação
Turma IJ
Professor: Rafael Saracchini
Respostas da Lista de Exercícios II – Assunto: Estruturas de Controle
Observações sobre o exercício: A resolução dos exercícios será dividida em duas etapas: Projeto do programa e Implementação. Embora a resposta do exercício seja apenas o código- fonte do programa estas etapas servirão para ilustrar como um programa deve ser elaborado passo- a- passo. a) Dados três números inteiros digitados pelo usuário diga qual é o maior e o menor entre eles Projeto do programa: Este programa pode ser dividido nas seguintes etapas
- Ler os três números
- Comparar números lidos e descobrir o maior
- Idem para descobrir o menor
- Imprimir o maior e o menor número Implementação: a)Ler os três números Para ler os 3 números , basta declará- los e utilizar a função scanf para efetuar a leitura do teclado #include <stdio.h> int main(void){ //declaração e leitura dos números int a,b,c; scanf(“%d %d %d” ,&a,&b,&c); return 0 ; } b)Comparar números lidos e descobrir o maior O valor do maior poderia ser obtido ordenando- se os três números , porém isto é uma tarefa difícil. Uma maneira mais simples é inicialmente escolher um numero como maior (digamos, a variável a ), armazená- lo em uma variável e depois comparar com os outros dois sucessivamente. Se em alguma dessas comparações o suposto maior número for menor que o comparado, atualizamos o valor da variável maior.
Para implementar esta etapa precisamos então declarar o variável maior, efetuar as comparações necessárias. Caso alguma comparação seja verdadeira o valor da variável maior deverá ser atualizado com o novo maior valor. #include <stdio.h> int main(void){ //declaração e leitura dos números int a,b,c; //declaração da variável maior int maior; scanf(“%d %d %d” ,&a,&b,&c); //escolhemos um possível maior valor maior = a; //comparamos maior com b if( maior < b){ //suposto maior é menor que b então b é o possível maior maior = b; } //o mesmo raciocínio é válido para c if(maior < c){ maior = c; } return 0 ; } c)Descobrir o menor número O mesmo raciocínio utilizado para descobrir o maior número pode ser utilizado para descobrir o menor número, só que testamos se o suposto menor número é maior que os números restantes... caso a comparação seja verdadeira atualizamos a variável menor. #include <stdio.h> int main(void){ int a,b,c; //declaração da variável maior e menor int maior,menor; scanf(“%d %d %d” ,&a,&b,&c); maior = a; if( maior < b){ maior = b; } if(maior < c){ maior = c; } //supomos que o menor número é a menor = a; //comparamos com b para verificar se a afirmação anterior é válida if(menor > b){ //b é menor que o suposto menor, logo b é o menor menor = b; } if(menor > c){ // c é menor que o suposto menor, logo c é o menor
- Ler n e m
- Calcular o valor de cada elemento da tabuada de 1 até m e imprimí- lo
- restringir a entrada de dados de maneira que a tabuada só seja calculada se n e m estiverem entre 2 e 9 (incluindo 2 e 9). Implementação: a) Ler n e m Para implementar esta etapa basta declarar as variáveis e utilizar o scanf para obter os dados do usuário. #include <stdio.h> int main(void){ //declaração e leitura de n e m int n,m; scanf(“%d %d” ,&n,&m); return 0 ; } b) Calcular o valor de cada elemento da tabuada de 1 até m e imprimí- lo Não podemos fazer no código o cálculo de cada expressão direto no código pois não temos um m determinado! Dada esta situação devemos então utilizar uma estrutura de controle de repetição como while, do- while ou for. A primeira coisa ser feita é analisar qual das 3 estruturas de controle serão utilizadas. while é recomendado quando queremos repetir uma operação 0 ou mais vezes e não podemos precisar exatamente quando a repetição termina. Ex: Calculo de logaritmo, conversão de bases do- while segue o mesmo princípio do while, mas queremos que as operações a serem repetidas sejam executadas ao menos uma vez. Ex: leitura de seqüência de numeros até usuário digitar –1, solicitação de senha. for é mais utilizado quando sabemos exatamente quantas vezes as operações serão repetidas. Ex: fatorial, tabuada Como podemos precisar que repetiremos m vezes o cálculo dos valores da tabuada, utilizaremos o for. Uma vez escolhida a estrutura de controle , teremos que ver como adaptá- la ao nosso programa... a cada repetição vemos que o valor do multiplicando vai sendo incrementado e que a repetição para ao chegar ao valor de m. Como o valor do multiplicando varia a cada iteração, então devemos declará- lo com uma variável e alterar seu valor a cada rodada. Sabemos também que o multiplicando sempre inicia com valor 1. Com isto podemos implementar o nosso for. #include <stdio.h>
int main(void){ int n,m; // declaracao do multiplicando e do valor da operação em cada etapa int mt,valor; scanf(“%d %d” ,&n,&m); /* Na estrutura do for temos já a inicialização, teste e atualização da variável de controle, no caso a variável “mt” / for(mt = 1; mt <= m; mt = mt+1){ //aqui o valor da operação a ser calculada valor = nmt; // e é claro nós imprimimos o mesmo printf(“%d x %d = %d\n”,n,mt,valor); } return 0 ; } c) Restringir a entrada de dados de maneira que a tabuada só seja calculada se n e m estiverem entre 2 e 9 (incluindo 2 e 9). O programa como está não restringe a entrada de dados do usuário. Para tal, teremos que fazer uso de uma estrutura de controle condicional e com ela tomarmos uma decisão de acordo com o valor digitado. As seguintes decisões precisam ser tomadas pelo programa:
• Se n e m estiverem entre 2 e 9 , ou seja 2 ≤n ≤ 9 e 2 ≤ m ≤9, o programa deve
calcular a tabuada
- Caso contrário, o programa deverá exibir uma mensagem de aviso Temos então que adaptar essas decisões a uma ou mais estruturas de controle, no caso, apenas um if bastará. Para a construção do IF precisamos determinar a expressão que resulte o valor Verdadeiro caso n e m atendam as condições especificadas acima e Falso caso contrário. A expressão que avalia isso é: ( (n>=2)&&(n <=9) ) && ( (m >=2) && (m<= 9)) Esta é umaexpressão composta, o primeiro grupamento ((n>=2)&&(n <=9) ) possui valor Verdadeiro se n respeitar a definição pedida assim como o segundo possui valor Verdadeiro se m respeita a definição dada. Caso n ou m tenham valor fora do conjunto [2,3,4..9] o && lógico entre os dois grupamentos garante que a expressão terá valor Falso e terá valor verdadeiro apenas se as duas variáveis estiverem dentro da faixa especificada. Uma vez pronta a expressão podemos ajustar nosso programa para atender a ultima etapa. #include <stdio.h> int main(void){ int n,m; int mt,valor; scanf(“%d %d” ,&n,&m); //testamos se n e m estão na faixa especificada if( ((n>=2) && (n<=9)) && ((m >=2) && (m <=9)) ){ //n e m estão na faixa especificada!
b)Analisar para cada número percorrido se o mesmo pode ser impresso na tela Uma tomada de decisão deve ser feita através de uma estrutura de controle condicional, no caso a mais adequada é o IF. Para poder utilizar o IF devemos ver quantos serão necessário e qual expressão avalia Verdadeiro ou Falso diante da análise pedida. Temos duas situações:
- Se o número dor divisível por n e não por m o número é impresso
- Senão nenhuma atitude é tomada Sabendo disso é fácil ver que apenas um IF é necessário, sem necessitar da construção de um ELSE pois se a condição de teste falhar nenhum comando é executado. Resta determinar a expressão. Sabemos que quando um número a é divisível por b então a%b é sempre 0, qualquer valor distinto indica que a não é divisível por b. Dado isto construímos nossa expressão para determinar de um dado número x é divisível por n mas não por m. (x%n == 0) && (x%m != 0) Note que esse número a ser avaliado no nosso programa é o próprio contador (variável cont), logo substuímos x por cont. Nosso programa fica então assim: #include <stdio.h> int main(void){ int n,m; int cont; scanf(“%d %d” ,&n,&m); for(cont = 1; cont <= 200; cont = cont+1){ if( (cont%n == 0) && (cont%m != 0) ){ //o número é divisível por n mas não por m printf(“%d\n”,cont); } } return 0 ; } d)Calcule o logaritmo mais próximo de 10 de um dado número n. Esta questão está um tanto mal formulada em relação ao que eu pretendia pedir. O enunciado correto deveria ser: “Calcule x igual ao logaritmo mais próximo de 10 de um dado número n onde x > n.” Esclarecido isso vamos resolver a questão. Projeto de programa:
A grosso modo um logaritmo de um número pode ser calculado contando- se quantas divisões inteiras podemos fazer até que o resultado da divisão seja 0. Logo nosso programa se resume a:
- Obter o número n
- Dividir n por 10 até que o resultado da divisão inteira seja 0
- Contar quantas divisões foram feitas Note que o que este programa faz no fundo é contar quantos dígitos possui um número positivo. Implementação: Vamos construir o básico do programa: #include <stdio.h> int main(void){ int n,x; scanf(“%d” ,&n); printf(“O logaritmo maior mais proximo e %d\n”,x); return 0 ; } a)Dividir n por 10 até que o resultado da divisão inteira seja 0 Primeiro passo – definir que estrutura de controle utilizar... desta vez não sabemos até quando iremos dividir n então de cara FOR não é o mais recomendado (embora seja perfeitamente possível utilizá- lo). Temos que decidir então se WHILE ou DO- WHILE é mais adequado... Note que pelo menos uma divisão teremos que fazer , mesmo que o número seja 0. Dado isso DO- WHILE facilitará mais a construção de nosso programa já que ele executa uma operação a ser repetida pelo menos uma vez. Logicamente a operação a ser repetida é de dividir n por 10. A condição de parada é que o resultado da divisão seja 0, logo a operação de divisão deve ser repetida enquanto o resultado da divisão seja diferente de 0 (note que “while” traduzido significa “enquanto”) #include <stdio.h> int main(void){ int n,x; //declaramos uma variavel que armazena o resultado da divisão int r; scanf(“%d” ,&n); //inicialmente r deve começar com o valor de n r = n; do{ /* dividimos o resultado da ultima divisão por 10 e armazenamos o resultado / r = r/10; /
Como neste programa temos uma grande quantidade de casos particulares em torno de um mesmo valor, SWITCH é o mais recomendado. Utilizando- o o programa adquire este aspecto: #include <stdio.h> int main(void){ int n; //declaramos uma variavel que armazena o dígito scanf(“%d” ,&n); switch(n){ case 0: printf(“_ _ _ _ _”); break; case 1: printf(“. _ _ _ _”); break; case 2: printf(“.. _ _ ”); break; case 3: printf(“... _ ”); break; case 4: printf(“.... ”); break; case 5: printf(“.... .”); break; case 6: printf(“... .”); break; case 7: printf(“ .. .”); break; case 8: printf(“ _ . .”); break; case 9: printf(“ _ _ _ .”); break; default: //caso em que n possui mais de um dígito! printf(“A entrada deve ser composta de 1 digito !\n”); break; }; return 0 ; } Repare que o scanf de um número não impede que digitemos mais de um dígito nem números negativos... neste caso devemos informar o usuário da situação. O programa também pode ser feito com IFs e ELSEs encadeados... é mais trabalhoso fazer o mesmo assim, mas a funcionalidade será a mesma.Confira na resposta abaixo: #include <stdio.h> int main(void){ int n; //declaramos uma variavel que armazena o dígito scanf(“%d” ,&n); if( n == 0 ){ printf(“ _ _ _ _”); }else if( n == 1 ){
printf(“. _ _ _ _”); }else if( n == 2 ){ printf(“.. _ _ _”); }else if( n == 3 ){ printf(“... _ ”); }else if( n == 4 ){ printf(“.... ”); }else if( n == 5 ){ printf(“.... .”); }else if( n == 6 ){ printf(“... .”); }else if( n == 7 ){ printf(“ .. .”); }else if( n == 8 ){ printf(“ _ . .”); }else if( n == 9 ){ printf(“ _ _ _ .”); }else{ //caso em que n possui mais de um dígito! printf(“A entrada deve ser composta de 1 digito !\n”); } return 0 ; } f)Dado um número inteiro, escrever o mesmo em código Morse. O código deve ser fornecido na mesma ordem que os caracteres digitados. Projeto do programa: Este realmente não é um programa trivial. Temos que extrair dígito a dígito do número, do mais significativo para o menos significativo, e para cada um deles imprimir o código Morse correspondente. Tarefas do programa
- Obter o número a ser impresso
- Extrair dígito a dígito do número, do mais significativo ao menos significativo
- Imprimir o código correspondente para cada dígito extraído Destas etapas, a mais difícil de longe é a segunda. Para facilitar o entendimento e fazer um código mais limpo e fácil de entender utilizaremos funções e procedimentos na construção do programa. Implementação: Vamos fazer a parte básica do programa: #include <stdio.h> int main(void){ int n; scanf(“%d” ,&n);
Relembrando a declaração de uma função: tipo NomeDaFunção (Listagem de Parâmetros de Entrada) { comandos return ValorDaFunção ; } Ex: a função abaixo calcula a média aritmética de 3 números reais passados como parâmetro de entrada (declarados como a,b e c), O valor retornado peloa função é do tipo float (real, ou ponto flutuante). float media3(float a, float b, float c){ return (a + b + c)/3.0 ; } Portanto, vamos criar uma função que dado um número inteiro retorna a quantidade de dígitos que ele possui reaproveitando o código do exercício anterior. int QtdDigitos(int n){ int x; //inicializamos o contador com 0 x = 0; do{ n = n/ 10 ; //a cada divisão incrementamos o contador x = x + 1 ; }while(n != 0 ); return x; } Quando colocamos QtdDigitos(i) dentro de uma expressão , o subprograma será executado com a variável n inicializada com o valor de i e após seu término será avaliado com o valor de x do tipo inteiro. Note que essas variáveis n e x declaradas dentro dele só existem dentro do bloco da função (trecho de código entre chaves) e são completamente independentes de quaisquer varíaveis declaradas dentro de outros blocos de função ou do main. Inclusive podemos declarar a variável n e x dentro do bloco do main sem quaisquer restrições , isto é o n declarado dentro de uma função não é o mesmo n declarado dentro do bloco do main. Voltando ao programa... Já sabemos qual é o expoente da potência de 10, mas precisamos é do valor de 10 elevado a este expoente. Vamos então construir uma função que dado um número positivo e retorna 10 e^. int potencia10(int e){ int r,cont;
r = 1 ; for(cont = 1 ; cont <= e; cont++){ // enquanto contador não for igual a e multiplicamos r por 10 r = r* 10 ; } return r; } Agora resta apenas decidir qual é a estrutura de repetição que vamos utilizar. Sabemos que se um número tem t dígitos então vamos repetir a operação t vezes. Podemos utilizar o FOR ou WHILE. Desta vez vamos utilizar o WHILE. O programa então ficará desta maneira #include <stdio.h> int QtdDigitos(int n){ int x; x = 0; do{ n = n/ 10 ; x = x + 1 ; }while(n != 0 ); return x; } int potencia10(int e){ int r,cont; r = 1 ; for(cont = 1 ; cont <= e; cont++){ r = r* 10 ; } return r; } int main(void){ int n,p,t,d; scanf(“%d” ,&n); //calculamos o total de dígitos do numero t = QtdDigitos(n); //enquanto houverem dígitos a serem extraídos repetimos operação while(t > 0){ //calculamos a potencia p p = potencia10(t - 1 ); //extraímos o digito mais significativo d = n/p; //recuperamos o restante dos dígitos n = n%p; //diminuímos um digito do total de dígitos t = t - 1 ; } return 0 ; }
Se chamarmos ImprimeMorse(k) em qualquer trecho do nosso programa, será impresso o código morse do dígito k. Uma vez com esse procedimento pronto basta chamar ImprimeMorse dentro da repetição principal do programa para cada dígito obtido. #include <stdio.h> void ImprimeMorse(int n){ switch(n){ case 0: printf(“_ _ _ _ _”); break; case 1: printf(“. _ _ _ _”); break; case 2: printf(“.. _ _ _”); break; case 3: printf(“... _ ”); break; case 4: printf(“.... ”); break; case 5: printf(“.... .”); break; case 6: printf(“... .”); break; case 7: printf(“ .. .”); break; case 8: printf(“ _ . .”); break; case 9: printf(“ _ _ _ .”); break; default: //caso em que n possui mais de um dígito! printf(“A entrada deve ser composta de 1 digito !\n”); break; }; } int QtdDigitos(int n){ int x; x = 0; do{ n = n/ 10 ; x = x + 1 ; }while(n != 0 ); return x; } int potencia10(int e){ int r,cont; r = 1 ; for(cont = 1 ; cont <= e; cont++){ r = r* 10 ; } return r;
int main(void){ int n,p,t,d; scanf(“%d” ,&n); t = QtdDigitos(n); while(t > 0){ p = potencia10(t - 1 ); d = n/p; n = n%p; t = t - 1 ; //imprimimos o dígito d extraído em Morse ImprimeMorse(d); /* imprimimos um espaço em branc o para evitar que os códigos fiquem grudados */ printf(“ “); } return 0 ; } Fazer este programa sem utilizar procedimentos e funções é no mínimo , bem mais trabalhoso. g)Dado um número n, escreva um “X” formado por asteriscos. Permita que apenas números ímpares sejam utilizados como entrada. Projeto do Programa: Em vez de pensarmos no “X” como uma figura só , podemos pensar que o programa traça duas diagonais simultaneamente. Desenhar uma diagonal é um problema bem mais simples. O programa pode ser dividido nas seguintes etapas:
- ler o número
- traçar diagonal principal
- traçar diagonal secundária
- restringir entrada de números pares Implementação: Estrutura básica do programa int main(void){ int n; scanf(“%d” ,&n); return 0 ; }
//se for qualquer outro é espaço em branco printf(“ “); } } //pulamos a linha após escrever os n caracteres printf(“\n”); } return 0 ; } b)Traçar a diagonal secundária O problema é praticamente o mesmo de traçar a diagonal principal, só a posição do asterisco cai em uma posição diferente. Se a linha for a primeira o asterisco deverá ser desenhado na n- esima posição, na segunda linha na n- esima posição menos 1 até que na n- esima linha o asterisco deverá ser desenhado na 1ª posição. Seguindo essa lógica , em uma linha de posição l o asterisco deverá ser desenhado na posição n- l +. Não iremos fazer outro grupo de FOR para imprimir a diagonal secundária pois em vez de obtermos o X teríamos duas diagonais uma embaixo da outra. Colocar dois agrupamentos de for vai nos dar isso:
Queremos isso:
Podemos alterar a expressão do IF da repetição que desenha a linha de maneira que se a posição a ser desenhada for do caracter da diagonal principal OU do caracter da diagonal secundaria então imprime- se um asterisco. Alterando- se apenas a expressão do IF fazemos nosso programa desenhar um ”X”. int main(void){ int n,l,cont; scanf(“%d” ,&n); for(l = 1 ; l <=n;l++){ //variamos l de 1 a n for(cont = 1; cont <=n; cont ++){ /*escrevemos n caracteres, Se a posição for igual a l então é diagonal principal se for igual a (n –l + 1) é d. secundaria / if((cont == l ) || (cont == (n –l +1 ))){ printf(“”);
else{ //se for qualquer outro é espaço em branco printf(“ “); } } //pulamos a linha após escrever os n caracteres printf(“\n”); } return 0 ; } c)Restringir a entrada de números pares Basta fazer um if com a expressão (n%2 == 0), pois já sabemos que o resto da divisão por 2 de números pares é sempre 0. int main(void){ int n,l,cont; scanf(“%d” ,&n); if(n %2 == 0){ printf(“Digite apenas numeros impares !”); }else{ for(l = 1 ; l <=n;l++){ //variamos l de 1 a n for(cont = 1; cont <=n; cont ++){ /*escrevemos n caracteres, Se a posição for igual a l então é diagonal principal se for igual a (n –l + 1) é d. secundaria / if((cont == l ) || (cont == (n –l +1 ))){ printf(“”); } else{ //se for qualquer outro é espaço em branco printf(“ “); } } //pulamos a linha após escrever os n caracteres printf(“\n”); } } return 0 ; } h)Escreva um programa um número imaginado pelo usuário entre 0 e n. Para cada valor sugerido pelo programa como sendo o valor imaginado pelo usuário, o usuário deve responder se o valor sugerido pelo programa é igual, menor ou maior que o valor imaginado. A execução do programa deve terminar assim que o programa “adivinhar” o valor imaginado pelo usuário. Projeto do Programa:
