Prévia do material em texto

1 
LINGUAGEM E TÉCNICA DE PROGRAMAÇÃO I 
 
Profa. Gisele Busichia Baioco 
gisele@ft.unicamp.br 
 
 
Algoritmos Estruturados e 
Linguagem de Programação Estruturada 
 
Estrutura de Repetição em C 
1 Estrutura de Repetição para Número Definido de Repetições 
A estrutura de repetição para número definido de repetições é utilizada quando se 
sabe o número de vezes que um comando ou um conjunto de comandos deve ser repetido. 
O número de repetições é controlado por uma variável de contagem (ou contadora), na 
qual o valor da contagem é mantido. Deve-se especificar um valor inicial, um valor final e o 
passo para a contagem, fazendo com que a contagem seja crescente ou decrescente e ocorra 
de acordo com passo (de 1 em 1, de 2 em 2, de 3 em 3, etc). 
Sintaxe em C: 
for (inicialização; condição; incremento/decremento) 
 comando; 
onde: 
for: é a palavra reservada de C para a estrutura de repetição; 
inicialização: é um comando de atribuição que determina a variável de contagem com seu 
valor inicial; 
condição: é uma expressão relacional que testa a variável de contagem contra algum valor, 
para determinar quando a repetição terminará; 
incremento/decremento: define a maneira como a variável de contagem será alterada a cada 
repetição, ou seja, soma-se (incremento) ou subtrai-se (decremento) da variável de contagem 
o valor do passo; 
comando: qualquer instrução válida. 
 Caso seja necessária a execução de um bloco de comandos, a sintaxe é a seguinte: 
for (inicialização; condição; incremento/decremento) 
 { 
 comando1; 
 ... 
 comandoN; 
} 
 
 
 2 
Exemplos: 
Algoritmo 
 início 
 declare N1, N2, M, Mgeral, soma: numérico real; 
 cont: numérico inteiro; 
 soma ← 0; /* valor inicial para a sumarização das médias */ 
 para cont ← 1 até 50 passo 1 faça 
 início 
 escreva(“Digite as duas notas”); 
 leia(N1); 
leia(N2); 
 M ← (N1 + N2)/2; /* cálculo da média de um aluno */ 
 soma ← soma + M; /* sumariza as médias dos alunos */ 
 escreva(“Media do aluno ”, cont, “ = ”, M); 
 fim 
 Mgeral ← soma/50; /* cálculo da média geral dos 50 alunos */ 
 escreva(“Media geral da turma de alunos = ”, Mgeral); 
fim 
#include <stdio.h> 
main() 
 { 
 float N1, N2, M, Mgeral, soma; 
 int cont; 
 soma = 0; /* valor inicial para a sumarização das médias */ 
 for (cont=1; cont <= 50; cont++) 
 { 
 printf(“Digite as duas notas”); 
 scanf(“%f”, &N1); 
 scanf(“%f”, &N2); 
 M = (N1 + N2)/2; /* cálculo da média de um aluno */ 
 soma = soma + M; /* sumariza as médias dos alunos */ 
 printf(“Media do aluno %d = %f”, cont, M); 
 } 
 Mgeral = soma/50; /* cálculo da média geral dos 50 alunos */ 
 printf(“Media geral da turma de alunos = %f”, Mgeral); 
} 
 
Algoritmo 
 início 
 declare N, cont: numérico inteiro; 
 escreva(“Digite um número inteiro positivo: ”); 
 leia(N); 
 escreva(“Seqüência de números pares até ”, N); 
 para cont ← 2 até N passo 2 faça 
 escreva(cont); 
 fim 
#include <stdio.h> 
main() 
 { 
 int N, cont; 
 printf(“Digite um número inteiro positivo: ”); 
 scanf(“%d”, &N); 
 printf(“Seqüência de números pares até %d”, N); 
 for (cont = 2; cont <= N; cont = cont + 2) 
 printf(“%d “,cont); 
 } 
 
 3 
Variações do comando for 
 A linguagem C permite muitas variações que aumentam a flexibilidade e a 
aplicabilidade do comando for em certas situações de programação: 
1) Uso de duas ou mais variáveis de contagem: por exemplo, o programa seguinte imprime 
os números de 0 a 98 em incrementos de 2. Observa-se que as variáveis x e y controlam o 
número de repetições: 
#include <stdio.h> 
main() 
{ 
 int x, y; 
 for (x = 0, y = 0; x + y < 100; x++, y++) 
 printf("%d ", x + y) 
 } 
 
2) A condição de parada não tem necessariamente que envolver a variável de contagem: 
na verdade, a condição pode ser qualquer expressão válida em C. Por exemplo, o programa 
seguinte ajuda a ensinar adição a uma criança: 
#include <stdio.h> 
#include <conio.h> 
main() 
{ 
 int i, j, resposta; 
 char feito = ‘ ’; 
 for (i = 1; i < 100 && feito != ‘N’; i++) 
 { 
 for (j = 1; j < 10; j++) 
 { 
 printf("Quanto é %d + %d ?", i, j); 
 scanf("%d", &resposta); 
 if (resposta != i + j) 
 printf("errado\n"); 
 else 
printf("certo\n"); 
 } 
 printf("Deseja continuar? (S/N)"); 
 feito = getche(); 
 } 
} 
 
3) Não é necessária a definição de todas as partes do comando: por exemplo, a instrução 
seguinte é válida: 
for (x = 0; x != 100;) 
 
4) Laço infinito (loop infinito): pode-se fazer com que o número de repetições seja infinito 
deixando as partes do comando vazias. Por exemplo: 
 for (;;) 
 printf("Este laço rodará para sempre"); 
 
5) Comando for sem nenhum corpo: o corpo (comando ou bloco de comandos) pode ser 
vazio. Com isso pode-se aumentar a eficiência de certos algoritmos como, por exemplo, criar 
laços para o retardo de tempo: 
for (t = 0; t < algum_valor; t++); 
 4 
2 Estrutura de Repetição para Número Indefinido de Repetições Pré-Teste 
A estrutura de repetição para número indefinido de repetições pré-teste deve ser 
utilizada quando não se sabe o número de vezes que um comando ou um bloco de comandos 
deve ser repetido, embora também possa ser utilizada quando se sabe esse número. 
O número de repetições é controlado por uma condição representada por uma 
expressão lógica. O teste da condição de controle é realizado antes da execução do comando 
ou bloco de comandos, por isso essa estrutura de repetição é denominada pré-teste (teste no 
início). Desse modo, se a condição de controle for falsa logo na primeira comparação, o 
comando ou bloco de comandos da estrutura de repetição não será executado nenhuma vez. 
Sintaxe em C: 
while (condição) 
 comando; 
onde: 
while: é a palavra reservadas de C para a estrutura de repetição; 
condição: é uma expressão lógica que, enquanto for verdadeira, fará com que o comando seja 
executado. Quando se tornar falsa, fará com que a execução de comando pare, ou seja, 
interrompe a repetição; 
comando: qualquer instrução válida. 
 Caso seja necessária a execução de um bloco de comandos, a sintaxe é a seguinte: 
while (condição) 
{ 
comando1; 
... 
comandoN; 
} 
 
Exemplos: 
Algoritmo 
 início 
 declare N, r: numérico inteiro; 
 escreva(“Entre com um numero inteiro”); 
 leia(N); 
 enquanto (N ≠ 0) faça 
 início 
 r ← resto(N, 2); 
 se (r = 0) 
 então 
 escreva(“O numero é par”); 
 senão 
 escreva(“O numero é ímpar”); 
 escreva(“Entre com outro numero inteiro”); 
 leia(N); 
 fim 
fim 
 5 
#include <stdio.h> 
main() 
 { 
 int N, r; 
 printf(“Entre com um numero inteiro”); 
 scanf(“%d”, &N); 
 while (N != 0) 
 { 
 r = N % 2; 
 if (r == 0) 
 printf(“O numero é par”); 
 else 
 printf(“O numero é ímpar”); 
 printf(“Entre com outro numero inteiro”); 
 scanf(“%d”, &N); 
 } 
} 
 
Algoritmo 
 início 
 declare N1, N2, M, Mgeral, soma: numérico real; 
 cont: numérico inteiro; 
 soma ← 0; /* valor inicial para a sumarização das médias */ 
 cont ← 1; /* inicialização da variável de contagem */ 
 enquanto (cont ≤ 50) faça 
 início 
 escreva(“Digite as duas notas”); 
 leia(N1); 
leia(N2); 
 M ← (N1 + N2)/2; /* cálculo da média de um aluno */ 
 soma ← soma + M; /* sumariza as médias dos alunos */ 
 escreva(“Media do aluno ”, cont, “ = ”, M); 
 cont ← cont + 1; /* incremento da variável de contagem */ 
 fim 
 Mgeral ← soma/50; /* cálculo da média geral dos 50 alunos */ 
 escreva(“Media geral da turma de alunos = ”, Mgeral); 
fim 
#include <stdio.h> 
main() 
 { 
 float N1, N2, M, Mgeral, soma; 
 int cont; 
 soma = 0; /* valor inicial para a sumarização das médias */ 
 cont = 1; /* inicialização da variável de contagem */ 
 while (cont<= 50) 
 { 
 printf(“Digite as duas notas”); 
 scanf(“%f”, &N1); 
scanf(“%f”, &N2); 
 M = (N1 + N2)/2; /* cálculo da média de um aluno */ 
 soma = soma + M; /* sumariza as médias dos alunos */ 
 printf(“Media do aluno %d = %f”, cont, M); 
 cont = cont + 1; /* incremento da variável de contagem */ 
 } 
 Mgeral = soma/50; /* cálculo da média geral dos 50 alunos */ 
 printf(“Media geral da turma de alunos = %f”, Mgeral); 
} 
 
 6 
3 Estrutura de Repetição para Número Indefinido de Repetições Pós-Teste 
A estrutura de repetição para número indefinido de repetições pós-teste deve ser 
utilizada quando não se sabe o número de vezes que um comando ou um bloco de comandos 
deve ser repetido, embora também possa ser utilizada quando se sabe esse número. 
O número de repetições é controlado por uma condição representada por uma 
expressão lógica. O teste da condição de controle é realizado após a execução do comando ou 
bloco de comandos, por isso essa estrutura de repetição é denominada pós-teste (teste no 
final). Desse modo, a execução do comando ou bloco de comandos ocorre pelo menos uma 
vez antes que a condição de controle seja testada, o que difere a estrutura de repetição para 
número indefinido de repetições pós-teste da pré-teste. 
Sintaxe em C: 
do { 
 comando ou bloco de comandos; 
} while (condição) 
onde: 
do e while: são as palavras reservadas de C para a estrutura de repetição; 
condição: é uma expressão lógica que, enquanto for verdadeira, fará com que o comando ou o 
bloco de comandos seja executado. Quando se tornar falsa, fará com que a execução pare; 
comando ou bloco de comandos: qualquer instrução ou conjunto de instruções válidas. 
 Embora as chaves { } não sejam necessárias quando do-while tiver apenas um 
comando, elas são geralmente usadas para aumentar a legibilidade. 
 Deve-se observar que a lógica de execução de do-while é inversa da do repita-até em 
algoritmos. Esquematicamente tem-se: 
 
 
condição 
comando(s) 
Falsa 
Verdadeira 
condição 
comando(s) 
Verdadeira 
Falsa 
do-while repita-até 
 
 7 
Exemplos: 
Algoritmo 
 início 
 declare N, r: numérico inteiro; 
 repita 
 escreva(“Entre com um numero inteiro”); 
 leia(N); 
 se (N ≠ 0) 
 então início 
 r ← resto(N, 2); 
 se (r = 0) 
 então 
 escreva(“O numero é par”); 
 senão 
 escreva(“O numero é ímpar”); 
 fim 
 até (N = 0); 
fim 
#include <stdio.h> 
main() 
 { 
 int N, r; 
 do { 
 printf(“Entre com um numero inteiro”); 
 scanf(“%d”, &N); 
 if (N != 0) 
 { 
 r = N % 2; 
 if (r == 0) 
 printf(“O numero é par”); 
 else 
printf(“O numero é ímpar”); 
 } 
 } while (N != 0); 
 } 
 
Algoritmo 
 início 
 declare N1, N2, M, Mgeral, soma: numérico real; 
 cont: numérico inteiro; 
 soma ← 0; /* valor inicial para a sumarização das médias */ 
 cont ← 1; /* inicialização da variável de contagem */ 
 repita 
 escreva(“Digite as duas notas”); 
 leia(N1); 
leia(N2); 
 M ← (N1 + N2)/2; /* cálculo da média de um aluno */ 
 soma ← soma + M; /* sumariza as médias dos alunos */ 
 escreva(“Media do aluno ”, cont, “ = ”, M); 
 cont ← cont + 1; /* incremento da variável de contagem */ 
 até (cont > 50); 
 Mgeral ← soma/50; /* cálculo da média geral dos 50 alunos */ 
 escreva(“Media geral da turma de alunos = ”, Mgeral); 
fim 
 8 
#include <stdio.h> 
main() 
 { 
 float N1, N2, M, Mgeral, soma; 
 int cont; 
 soma = 0; /* valor inicial para a sumarização das médias */ 
 cont = 1; /* inicialização da variável de contagem */ 
 do { 
 printf(“Digite as duas notas”); 
 scanf(“%f”, &N1); 
scanf(“%f”, &N2); 
 M = (N1 + N2)/2; /* cálculo da média de um aluno */ 
 soma = soma + M; /* sumariza as médias dos alunos */ 
 printf(“Media do aluno %d = %f”, cont, M); 
 cont = cont + 1; /* incremento da variável de contagem */ 
 } while (cont <= 50); 
 Mgeral = soma/50; /* cálculo da média geral dos 50 alunos */ 
 printf(“Media geral da turma de alunos = %f”, Mgeral); 
} 
4 Exemplos de Programas C 
1) Faça um algoritmo e programa C que calcule o fatorial de um número inteiro qualquer. 
Sabe-se que: 
0! = 1 
n! = 1*2*3*...*n-1*n, n > 0 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare num, fatorial, cont: numérico inteiro; 
 /* Entrada de dados */ 
 escreva(“Digite um número inteiro para o calculo do fatorial: ”); 
 leia(num); 
/* Processo – cálculo do fatorial */ 
fatorial ← 1; /* resolve o problema de fatorial de 0 e 1 */ 
para cont ← 2 até num passo 1 faça 
 fatorial ← fatorial * cont; 
escreva(“Fatorial = ”, fatorial); 
fim 
#include <stdio.h> 
main() 
{ 
 /* Declaração de variáveis */ 
 int num, fatorial, cont; 
 /* Entrada de dados */ 
 printf(“Digite um número inteiro para o calculo do fatorial: ”); 
 scanf(“%d”, &num); 
/* Processo – cálculo do fatorial */ 
fatorial = 1; /* resolve o problema de fatorial de 0 e 1 */ 
for (cont = 2; cont <= num; cont++) 
 fatorial = fatorial * cont; 
printf(“Fatorial = %d”, fatorial); 
} 
 9 
2) Anacleto tem 1.50 m de altura e cresce 2 centímetros por ano enquanto Felisberto tem 
1.10 m de altura e cresce 3 centímetros por ano. Construa um algoritmo e programa C 
que calcule e imprima quantos anos serão necessários para que Felisberto seja mais 
alto que Anacleto. 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare alt_A, alt_F: numérico real; 
 anos: numérico inteiro; 
 /* Processo*/ 
 alt_A ← 1.50; /* inicializa a altura de Anacleto */ 
 alt_F ← 1.10; /* inicializa a altura de Felisberto */ 
 anos ← 0; /* inicializa o numero de anos */ 
 enquanto (alt_A ≥ alt_F) 
 início 
 alt_A ← alt_A + 0.02; 
 alt_F ← alt_F + 0.03; 
 anos ← anos + 1; 
 fim 
 escreva(“Anos= ”, anos); 
fim 
#include <stdio.h> 
main() 
{ 
 /* Declaração de variáveis */ 
 float alt_A, alt_F; 
int anos; 
 /* Processo*/ 
 alt_A = 1.50; /* inicializa a altura de Anacleto */ 
 alt_F = 1.10; /* inicializa a altura de Felisberto */ 
 anos = 0; /* inicializa o numero de anos */ 
 while (alt_A >= alt_F) 
 { 
 alt_A = alt_A + 0.02; 
 alt_F = alt_F + 0.03; 
 anos = anos + 1; 
 } 
 printf(“Anos = %d”, anos); 
} 
 
 10 
3) A nota final de um estudante é calculada a partir de três notas: laboratório, avaliação 
semestral e exame final, com os pesos 2, 3 e 5, respectivamente. Faça um algoritmo 
que leia três notas de um estudante e calcule e mostre a média ponderada, repetindo o 
processo até que o usuário deseje parar. 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare laboratorio, semestral, exame, media: numérico real; 
 resp: caractere; 
 repita 
 /* Entrada de dados */ 
 escreva(“Digite a nota de laboratório: ”); 
 leia(laboratorio); 
 escreva(“Digite a nota da avaliação semestral: ”); 
 leia(semestral); 
 escreva(“Digite a nota do exame final: ”); 
leia(exame); 
/* Processo – cálculo da média ponderada */ 
media ← (laboratório * 2 + semestral * 3 + exame * 5) / 10; 
/* Saída de dados */ 
escreva(“Média ponderada = ”, media); 
escreva(“Deseja continuar(S/N)?”); 
leia(resp); 
 até (resp = ‘N’); 
fim 
#include <stdio.h> 
#include <conio.h> 
main() 
{ 
 /* Declaração de variáveis */ 
 float laboratorio, semestral, exame, media; 
 char resp; 
 do { 
 /* Entrada de dados */ 
 printf(“Digite a nota de laboratório: ”); 
 scanf(“%f”, &laboratorio); 
 printf(“Digite a nota da avaliação semestral: ”); 
 scanf(“%f”, &semestral); 
 printf(“Digite a nota do exame final: ”); 
scanf(“%f”, &exame); 
/* Processo – cálculo da média ponderada */ 
media = (laboratorio * 2 + semestral * 3 + exame * 5) / 10; 
/* Saída de dados */ 
printf(“Média ponderada = %f”, media); 
printf(“Deseja continuar(S/N)?”); 
resp = getche(); 
 } while (resp == ‘S’); 
}
 11 
Exercícios de Fixação 
 
1) Faça um algoritmo e programa C para determinar os divisores de um número 
qualquer. 
2) Construa um algoritmo e programa C que, dadoum conjunto de valores inteiros e 
positivos, determine qual o menor e o maior valor do conjunto. O final do conjunto de 
valores é determinado pelo valor –1, que não deve ser considerado. 
3) Calcule o imposto de renda de N contribuintes, considerando que os dados de cada 
contribuinte número do CPF, número de dependentes e renda mensal, são valores 
fornecidos pelo usuário. Para cada contribuinte serão deduzidos 5% da renda mensal 
correspondente a cada dependente. Os valores da alíquota para cálculo do imposto são: 
 
Renda Líquida Alíquota 
Até 2 salários mínimos Isento 
De 2 a 3 salários mínimos. 5% 
De 3 a 5 salários mínimos. 10% 
De 5 a 7 salários mínimos. 15% 
Acima de 7 salários mínimos 20% 
 Obs: O valor atual do salário mínimo deve ser fornecido pelo usuário. 
4) Elabore um algoritmo e programa C que leia números reais até que o valor da soma 
destes números seja ≥ 100. O algoritmo deverá fornecer ao final, quantos valores lidos 
foram necessários para satisfazer tal condição. 
5) Elabore um algoritmo e programa C que calcule e escreva a soma de todos os números 
ímpares que são múltiplos de 3 e que se encontram no conjunto dos números de 1 até 
500.