Comandos repetitivos em algoritmos

•Objetivos
• Criar algoritmos com comandos
repetitivos.
• Identificar as variações que existem entre
os comandos em cada uma das linguagens.

Para começar...
 Os comandos de repetição dão mais movimento ao programa,
permitindo que uma ação seja executada mais de uma vez sem que seja
necessário executar novamente o programa.
 É possível testar entradas de dados e pedir que o usuário repita a
entrada até que um valor válido seja digitado.
 No algoritmo da calculadora visto no capítulo anterior, por exemplo,
quando um símbolo diferente de uma das operações aritméticas é lido,
o algoritmo imprime uma mensagem e termina o programa.

Para começar...
 Pode-se alterar o algoritmo para repetir a entrada do símbolo da
operação aritmética até que a entrada seja um símbolo válido.
 Para a alteração proposta, é necessário fazer a leitura do símbolo da
operação aritmética num comando sozinho, para repetir a leitura
somente do símbolo enquanto o símbolo digitado for diferente de um
dos básicos: +,-,*,/.
 No lugar do comando condicional, será incluído um comando para
repetir a leitura.
 A condição deverá fazer parte do comando de repetição.

Para começar...
Fluxograma contendo a
alteração no algoritmo

Para começar...
A partir do fluxograma e passando para uma forma textual tem-se:
Leia (A, B,)
Leia (op)
Enquanto op  +,-,*,/
Leia(op)
 O primeiro comando de leitura da operação foi necessário, no exemplo,
para que a operação pudesse ser testada no comando repetitivo.
 O segundo comando de leitura será repetido enquanto a operação lida
for diferente de uma das operações básicas (+,-,*,/).

Para começar...
 Quando uma das básicas for digitada, o controle sairá do comando
repetitivo e passará a executar o comando de seleção.
 O que controla o número de repetições é uma condição (expressão
lógica).
 No exemplo da calculadora, a condição utilizada foi em relação à
operação digitada ser diferente das básicas.
 Os comandos iterativos básicos são: enquanto, para e repita/faça-
enquanto.

Conhecendo a teoria para programar
Comando iterativo – enquanto (while)
 O comando cuja palavra-chave é enquanto (while), tem o mesmo
comportamento nas várias linguagens, com apenas algumas diferenças na
escrita do comando.
 É um comando que repete um comando ou um conjunto de comandos
enquanto uma condição (expressão lógica) for verdadeira.
 Quando essa condição se tornar falsa, o controle passa para o próximo
comando que se segue imediatamente ao final do comando repetitivo
enquanto.

VisuAlg – Comando iterativo – enquanto (while)
sintaxe:
enquanto <expressão-lógica> faca
<sequência-de-comandos>
fimenquanto
análise do comando:
 o bloco do comando se inicia com a palavra-chave enquanto e termina com o
fimenquanto;
 o comando utiliza uma outra palavra-chave: faça, sem a cedilha, após a
expressão-lógica;
 a expressão-lógica não precisa estar entre parênteses.

PASCAL - Comando iterativo – enquanto (while)
sintaxe:
while expressão-lógica do
comando;
 o comando se inicia com a palavra-chave while e utiliza a palavra-chave do
após a expressão-lógica;
 a expressão-lógica não precisa estar entre parênteses;
 para a repetição de mais de um comando é necessário colocá-los dentro de um
bloco de comandos, utilizando-se as palavras-chave begin e end.

C, JAVA e PHP - Comando iterativo – enquanto (while)
sintaxe:
while (expressão_lógica)
comando;
 o comando se inicia com a palavra-chave while;
 a expressão-lógica deve estar entre parênteses;
 para a repetição de um conjunto de comandos é necessário colocá-los
dentro de um bloco de comandos, isto é, entre chaves: { }.

Comando iterativo – enquanto (while)
Exemplos:
Versão em C Versão em Java Versão em PHP
x=1;
while (x<4){
printf(“%d”,x);
x++;
}
x = 1;
while (x<4)
{
System.out.println( x);
x++;
}
<?php
$x=1;
while ($x<4){
echo $x;
$x++;
}
?>

VisuAlg - Comando iterativo – para (for)
 Este comando é útil quando se deseja repetir um número fixo de vezes
determinado conjunto de comandos.
 Possui a mesma lógica de funcionamento nas linguagens abordadas.
 Deverá ter uma variável de controle, um valor inicial, um valor
final e o valor do incremento – passo - que essa variável receberá
para sair do valor inicial até atingir o valor final.

sintaxe:
para <variável> de <valor-inicial> ate <valor-limite> [passo <incremento>]
faca
fimpara
 para, de, ate, passo, faca e fimpara são palavras-chave do comando;
 variável : é a variável de controle do comando e deve ser do tipo inteiro;
 valor-inicial: é o valor de início da variável de controle. Pode ser uma constante
ou uma expressão aritmética, desde que o valor seja do tipo inteiro. A
atribuição desse valor à variável de controle é feita apenas uma vez antes de
iniciar a primeira repetição do comando.

análise do comando (continuação):
 valor-limite: é o valor de parada do comando. Isto é, a sequência de comandos
será executada até que a variável de controle atinja esse valor;
 incremento: é o valor do passo que a variável de controle deve “caminhar” para
que atinja o valor limite. É opcional e, quando presente, é necessário apresentar
o valor do incremento que será acrescentado à variável de controle após cada
repetição da sequência de comandos. Quando não está presente não deverá
especificado o valor do incremento e compilador entenderá que o valor do
incremento é o padrão, ou seja, igual a 1 (um).

Exemplo:
para x de 1 ate 3 passo 1 faca
escreval(“X = ”, x)
Como o passo usado, no exemplo, é igual a 1 ele pode ser omitido. Nesse
caso a linha do comando ficaria:
para x de 1 ate 3 faca
Observação: de pode ser substituído por dois-pontos e igual (:=)
para x := 1 ate 3 faca

PASCAL - Comando iterativo – para (for)
sintaxe:
for variável-de-controle:= valor-inicial to valor-final do
comando;
 for, to e do: são palavras-chave do comando;
 a primeira parte é a atribuição do valor-inicial à variável de controle e é
executada apenas uma vez, antes da execução da primeira repetição do
comando;
 valor-final é o valor limite que a variável de controle deve atingir.

 não há a apresentação do passo pois está implícito que o
incremento é igual ao valor 1;
 a palavra-chave downto é usada no lugar da palavra-chave
to quando o incremento for igual ao valor -1. Nesse caso o
valor-inicial deve ser maior do que o valor-final;

Exemplo:
for X:=3 downto 1 do
writeln(‘X = ’, X);
O resultado esperado:
X = 3
X = 2
X = 1

C, JAVA e PHP - Comando iterativo – para (for)
sintaxe:
for(iniciar ; expressão-lógica ; expressão-de-atualização)
comando;
 o comando possui apenas uma palavra-chave: for;
 o comando é formado por três partes, colocadas entre parênteses e
obrigatoriamente separadas por ponto-e-vírgula. Mesmo que uma das partes
não seja necessária é obrigatória a apresentação dos dois pontos-e-vírgulas.
Exemplo: for( ; i<N; ).
 iniciar: primeira parte e será executada apenas uma vez, quando começar o
comando for.

C, JAVA e PHP - Comando iterativo – para (for)
 expressão-lógica: será executada para testar se a expressão-
lógica é verdadeira ou falsa; se for verdadeira executará o
comando a ser repetido e, se for falsa executará o próximo
comando fora do for;
 expressão-de-atualização: será executada a partir da
segunda vez, da repetição do comando for.

Comando iterativo – para (for)
O comando for possui vantagem em relação ao comando-while a medida que
em uma mesma linha de comando está a atribuição inicial da variável de controle
e o comando de atualização da variável de controle. Ambos possuem a expressão-
lógica como elemento de parada da repetição.
Veja abaixo a comparação em C, por exemplo:
x = 0
while (x < 4) { for(x = 0; x < 4; x++)
printf(“X = %d n”,x); printf (“X = %d n”,x);
x++;
}

Comando iterativo – repita/faça-enquanto (repeat/do-while)
 Este comando é semelhante ao enquanto, com a diferença que a
condição para a repetição dos comandos é testada ao final, somente
depois de executá-los pelo menos uma vez.
 Nas linguagens VisuAlg e Pascal, o comando que testa a condição ao
final após executar o bloco de comandos a ser repetido é: repita-até
(repeat-until).
 Já para as linguagens C, Java e PHP, o comando repetitivo com essa
característica de testar a condição ao final do bloco é: faça-enquanto
(do-while).

VisuAlg - Comando iterativo – repita-até (repeat-until)
sintaxe:
repita
ate <expressão-lógica>
 o bloco do comando começa com a palavra-chave repita e termina com
a palavra-chave até (sem acento);
 expressão-lógica: enquanto ela for falsa a sequência de comandos é
repetida. Quando ela se tornar verdadeira o controle passa para o
próximo comando que se segue.

PASCAL - Comando iterativo – repita-até (repeat-until)
sintaxe:
repeat
comando ou conjunto de comandos;
until <expressão-lógica>;
 o comando começa com a palavra-chave repeat e termina com a palavra-chave
until;
 expressão-lógica: enquanto ela for falsa, o comando é repetido. Quando ela se
torna verdadeira, o controle passa para o próximo comando;
 no caso do comando repeat-until, não há necessidade do uso das palavras-
chave begin e end para um conjunto de comandos. A palavra-chave until
delimita o final do comando.

C,JAVA e PHP - Comando iterativo – faça-enquanto (do-while)
sintaxe:
do
comando;
while (expressão_lógica);
 o comando se inicia com a palavra-chave do e termina com a palavra-
chave while;
 o comando possui uma expressão-lógica que, enquanto for verdadeira,
o comando deve ser repetido;
 após a expressão-lógica, que deve estar entre parênteses, deve terminar
com um ponto-e-vírgula.

Comando iterativo – repita/faça-enquanto (repeat/do-while)-
Exemplos
Versão em VisuAlg Versão em PASCAL
i<- 1
repita
escreval("I = ", i)
i<- i+1
ate i>3
i:= 1;
repeat
writeln('I = ', i);
i:= i+1;
until i>3;

Comando iterativo – repita/faça-enquanto (repeat/do-while)-
Exemplos:
Versão em C Versão em JAVA Versão em PHP
i= 1;
do {
printf(“I = %d n”, i);
i++;
} while (i<=3);
i= 1;
do {
System.out.println(“I = ”+ i);
i++;
} while (i<=3);
$i= 1;
do {
echo “I = $i ”;
$i++;
} while ($i<=3);

Vamos Programar
Elaborar um algoritmo que imprima na tela os dez primeiros múltiplos de
um número inteiro qualquer fornecido pelo usuário (lido). No final,
imprima também a soma destes dez números. Fazer duas versões deste
programa: uma utilizando o for e outra utilizando o while.
Exemplo da saída:
Valor lido: 3
Lista de Múltiplos: 3 6 9 12 15 18 21 24 27 30
Soma = 165

Vamos Programar - VisuAlg
algoritmo "Múltiplos de número lido"
// Seção de Declarações
var
numero, soma, multiplo, i: inteiro
inicio
// Seção de Comandos
escreva("Digite um número: ")
leia(numero)
escreval ("Valor Lido: ", numero)
escreva ("Lista de Múltiplos: ")
soma<-0
para i de 1 ate 10 passo 1 faca
multiplo <- i*numero
escreva(multiplo, " ")
soma<- soma+multiplo
fimpara
escreval()
escreval("Soma = ", soma)
fimalgoritmo
algoritmo "Múltiplos de número lido"
// Seção de Declarações
var
numero, soma, multiplo, i: inteiro
inicio
// Seção de Comandos
escreva("Digite um número: ")
leia(numero)
escreval ("Valor Lido: ", numero)
escreva ("Lista de Multiplos: ")
i<-1
soma<-0
enquanto (i<=10) faca
multiplo <- i*numero
escreva(multiplo, " ")
soma<- soma+multiplo
i<- i+1
fimenquanto
escreval()
escreval("Soma = ", soma)
fimalgoritmo

Vamos Programar - PASCAL
program Múltiplos;
uses Crt;
var
numero, soma, multiplo, i: integer;
begin
write('Digite um número: ');
readln(numero);
writeln ('Valor Lido: ', numero);
write ('Lista de Múltiplos: ');
soma:=0;
for i := 1 to 10 do begin
multiplo := i*numero;
write(multiplo, ' ');
soma:= soma+multiplo;
end;
writeln();
writeln('Soma = ', soma);
end.
program Múltiplos;
uses Crt;
var
numero, soma, multiplo, i: integer;
begin
write('Digite um número: ');
readln(numero);
writeln ('Valor Lido: ', numero);
write ('Lista de Múltiplos: ');
i:=1;
soma:=0;
while (i<=10) do begin
multiplo := i*numero;
write(multiplo, ' ');
i:= i+1;
soma:= soma+multiplo;
end;
writeln();
writeln('Soma = ', soma);
end.

Vamos Programar - C
void main()
{
int numero, soma, multiplo, i;
printf(“Digite um numero: ”);
scanf (“%d”,numero);
printf(“Valor Lido: %dn”, numero);
printf(“Lista de Multiplos: ”);
soma=0;
for (i= 1 ; i<=10 ; i++)
{
multiplo = i*numero;
printf(“ %d”, multiplo);
soma += multiplo;
}
printf(“nSoma = %d”, soma);
}
void main()
{
printf(“Digite um numero: ”);
scanf (“%d”,numero);
printf(“Valor Lido: %dn”, numero);
printf(“Lista de Multiplos: ”);
soma=0;
i = 1;
while(i<=10)
{
printf(“ %d”,multiplo);
soma += multiplo;
i++;
}
printf(“nSoma = %d”, soma);
}

Vamos Programar - JAVA
import java.util.*
public class Multiplo {
public static void main(String args[])
{
Scanner entrada=new Scanner(System.in);
System.out.print(“Digite um numero: ”);
numero = entrada_dado.nextInt();
System.out.print(“nValor Lido: “+numero);
System.out.print(“nLista de Multiplos: ”);
soma=0;
for (i= 1 ; i<=10 ; i++)
{
System.out.print(“ “ + multiplo);
soma += multiplo;
}
System.out.print(“nSoma = ”+ soma);
}
import java.util.*
public class Multiplo {
public static void main(String args[])
{
Scanner entrada=new Scanner(System.in);
System.out.print(“Digite um numero: ”);
numero = entrada_dado.nextInt();
System.out.print(“nValor Lido: “+numero);
System.out.print(“nLista de Multiplos: ”);
soma=0;
i = 1;
while(i<=10)
{
System.out.print(“ “ + multiplo);
soma += multiplo;
i++;
}
System.out.print(“nSoma = ”+ soma);
}

Vamos Programar - PHP
<?php
$numero = $_POST[num_lido];
echo“Valor: $numero”;
echo “Lista de Múltiplos: ”;
$soma=0;
for ($i= 1 ; $i<=10 ; $i++)
{
$multiplo = $i*$numero;
echo $multiplo;
$soma += $multiplo;
}
echo “Soma = $soma”;
?>
<?php
$numero = $_POST[num_lido];
echo“Valor: $numero”;
echo “Lista de Múltiplos: ”;
$soma=0;
$i = 1;
while($i<=10)
{
$multiplo = $i*$numero;
echo $multiplo;
$soma += $multiplo;
$i++;
}
echo “Soma = $soma”;
?>

Nos próximos capítulos você irá completar seus conhecimentos com
tipos de dados mais complexos que combinam entre si os tipos já
aprendidos, compondo as estruturas de dados. Com essas estruturas de
dados, você poderá então construir programas que trabalham com
conjuntos maiores de informações e perceberá a importância e
necessidade dos comandos repetitivos.
Boa leitura!

Comandos repetitivos em algoritmos

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Comandos repetitivos em algoritmos

Semelhante a Comandos repetitivos em algoritmos (20)

Mais de Os Fantasmas !

Mais de Os Fantasmas ! (20)

Último

Último (20)

Comandos repetitivos em algoritmos