Slides no formato

Aula 4
Estruturas de Repetição
Programação em Java 2006-2007
Estruturas de Repetição
As estruturas repetitivas ou ciclos permitem repetir
um conjunto de uma ou mais instruções
O Java apresenta três variantes de ciclos:
O ciclo while (pre-validação)
O ciclo do … while (post-validação)
O ciclo for (contador automático)
Programação em Java 2006-2007
2
1
O Ciclo while e do … while
Permite repetir um conjunto de uma ou mais
instruções enquanto uma condiç
condição mantiver o
valor lógico verdadeiro
while (condição) {
instruções;
}
do {
instruções;
} while (condição)
condição := expressão lógica
pre-validação: o teste da
condição é feito antes da
execução das instruções
post-validação: o teste da
condição só é feito depois
da execução das instruções
Programação em Java 2006-2007
3
Problema 1
Escrever um programa que leia uma sequencia de
números inteiros positivos introduzidos pelo
teclado, até que apareça o número zero
(indicador de paragem), e que determina e
escreva no monitor o número e a média
dos números lidos
Programação em Java 2006-2007
4
2
Problema 1: Especificação
Entrada: uma sequencia de números inteiros positivos
introduzidos pelo utilizador.
Cada número é guardado na variável num
(valor numérico inteiro positivo)
Saída:
contador – o número de números lidos (valor inteiro)
media - a média dos números lidos (valor real)
Algoritmo:
Inicializar a variável contador e a variável soma com zero
Repetir enquanto houver números
1º. ler o número (guardar na variável num)
num
2º. Incrementar contador
3º. Adicionar num a soma
Fim repetir
Se contador
contador é diferente de zero calcular a média pela fórmula:
media = soma / contador
Imprimir contador
contador e media
Programação em Java 2006-2007
5
Problema 1. Pseudo-Código
soma
soma com
com 0;
0;
contador
contador com
com 0;
0;
Ler
Ler o
o primeiro
primeiro número
número ((num
num )) ;;
Enquanto
Enquanto num
num !=
!= 0
0
Adiciona-lo
á
Adiciona-lo á soma
soma ;;
Incrementar
Incrementar contador
contador em
em um
um ;;
Ler
Ler o
o seguinte
seguinte número
número ((num
num )) ;;
Fim
Fim Enquanto
Enquanto ;;
Se
Se ((contador
contador !=
!= 0)
0)
Calcular
Calcular média
média (( media
media == soma
soma // contador
contador););
Escrever
Escrever no
no ecrã
ecrã o
o total
total de
de números
números lidos
lidos ((contador
contador););
Escrever
no
ecrã
a
média
dos
números
lidos
Escrever no ecrã a média dos números lidos ((media
media););
caso
contr
caso contrá
contrá
rio
contráário
Escrever
Escrever a
a mensagem
mensagem ““Não foram introduzidos dados””;;
Inicializar
Inicializar
Inicializar
Inicializar
Antes de testar a
condição é preciso
ler o primeiro
número
Programação em Java 2006-2007
6
3
Problema 1. Programa
(versão 1)
import
import p1.*;
p1.*;
class
Pr_4_1_CalcularMedia
class Pr_4_1_CalcularMedia extends
extends P1App
P1App {{
public
public static
static void
void main(String
main(String args[])
args[]) {{
//// declaraç
declara
inicializa
vari
declaraç
ão ee inicializaç
inicializaç
ão de
de variá
variá
veis
declaraçção
inicializaçção
variááveis
int
int num,
num, soma
soma =
= 0,
0, contador
contador =
=0
0 ;;
double
double media;
media;
//// entrada
entrada ee processamento
processamento dos
dos dados
dados
Precisamos
ainda validar
que o
número é
não negativo
num
num =
= readInt("Introduza
readInt("Introduza o
o primeiro
primeiro número
número inteiro
inteiro positivo:
positivo: ");
");
while
while (num
(num !=
!= 0)
0) {{
soma
soma =
= soma
soma +
+ num;
num;
//
// adiciona
adiciona
contador
contador =
= contador
contador +
+ 1;
1;
num
num aa soma
soma
contador
contador em
em 1
1
//
// incrementa
incrementa o
o
num
num =
= readInt("Introduza
readInt("Introduza o
o seguinte
seguinte número
número inteiro
inteiro positivo:
positivo: ");
");
}}
Programação em Java 2006-2007
7
Problema 1. Programa (cont..)
(versão 1)
//// saí
sa
saí
da de
de dados
dados
saíída
ifif (contador
(contador !=
!= 0)
0) {{
media
media =
= (( ((double
double)) soma
soma )/
)/ contador;
contador;
Se os dois operandos
são de tipo int o
resultado é também
do tipo int.
Precisamos converter
explicitamente um
dos operandos para
tipo double
println("Foram
println("Foram lidos
lidos "" +
+ contador
contador +
+
"" números
números inteiros
inteiros positivos.");
positivos.");
print("A
print("A média
média dos
dos números
números lidos
lidos é
é "" );
);
printfd(6,
printfd(6, 2,
2, media);
media);
}}
else
else {{
println("Não
println("Não foram
foram introduzidos
introduzidos dados");
dados");
}}
}} //
// fim
fim main()
main()
}} //
// fim
fim class
class Pr_4_1_CalcularMedia
Pr_4_1_CalcularMedia
Programação em Java 2006-2007
8
4
Problema 1. Programa
(versão melhorada) I
Usar do … while para validação de dados
//// entrada
entrada ee processamento
processamento dos
dos dados
dados
do
do
Precisamos validar
que o número é não
negativo.
Usamos do.. while:
enquanto o número
é negativo vamos
continuar a ler um
número do teclado
num
num =
= readInt("Introduza
readInt("Introduza o
o primeiro
primeiro número
número inteiro
inteiro positivo:
positivo: ");
");
while
while (num
(num <
< 0);
0);
while
while (num
(num !=
!= 0)
0) {{
soma
soma +=
+= num;
num;
contador++;
contador++;
//
// adiciona
adiciona num
num a
a soma
soma
//
// incrementa
incrementa o
o contador
contador em
em 1
1
do
do
num
num =
= readInt("Introduza
readInt("Introduza o
o seguinte
seguinte número
número int.
int. positivo:
positivo: ");
");
while
while (num
(num <
< 0);
0);
}} //
// fecha
fecha while
while
Programação em Java 2006-2007
9
Problema 1. Programa
(versão melhorada) II
Usar o operador += para simplificar a
escrita de expressões matemáticas
//// entrada
entrada ee processamento
processamento dos
dos dados
dados
do
do
num
num =
= readInt("Introduza
readInt("Introduza o
o primeiro
primeiro número
número inteiro
inteiro positivo:
positivo: ");
");
while
while (num
(num <
< 0);
0);
while
while (num
(num !=
!= 0)
0) {{
Equivalente a:
soma = soma + num
soma
soma +=
+= num;
num;
contador++;
contador++;
//
// adiciona
adiciona num
num a
a soma
soma
//
// incrementa
incrementa o
o contador
contador em
em 1
1
do
do
num
num =
= readInt("Introduza
readInt("Introduza o
o seguinte
seguinte número
número int.
int. positivo:
positivo: ");
");
while
while (num
(num <
< 0);
0);
}} //
// fecha
fecha while
while (num
(num !=
!= 0)
0)
Programação em Java 2006-2007
10
5
Problema 1. Programa
(versão melhorada) III
Usar o operador unário ++ para incrementar o contador
//// entrada
entrada ee processamento
processamento dos
dos dados
dados
do
do
num
num =
= readInt("Introduza
readInt("Introduza o
o primeiro
primeiro número
número inteiro
inteiro positivo:
positivo: ");
");
while
while (num
(num <
< 0);
0);
Equivalente a:
contador = contador + 1
while
while (num
(num !=
!= 0)
0) {{
soma
soma +=
+= num;
num;
contador++;
contador++;
//
// adiciona
adiciona num
num a
a soma
soma
//
// incrementa
incrementa o
o contador
contador em
em 1
1
do
do
num
num =
= readInt("Introduza
readInt("Introduza o
o seguinte
seguinte número
número int.
int. positivo:
positivo: ");
");
while
while (num
(num <
< 0);
0);
}} //
// fecha
fecha while
while (num
(num !=
!= 0)
0)
Programação em Java 2006-2007
11
Operadores Unários
As operações unárias envolvem apenas um operando
Operadores de incremento e decremento: aumentam ou
diminuem, respectivamente, uma unidade ao valor do operando
++x;
--x;
pré-incremento:
x++;
x--;
pós-incremento:
1º se modifica
2º é feita a atribuição
1º é feita a atribuição
2º se modifica
x= 7;
x= 7;
num =
num =
++x;
Primeiro x é incrementado para 8 e
depois num toma o valor de x.
Retorna x= 8, num = 8
x++;
Primeiro num toma o valor de x e
depois x é incrementado.
Retorna x = 8, num = 7
Programação em Java 2006-2007
12
6
A palavra chave break
Permite ao programa terminar a execução das instruções
e passa imediatamente o controlo fora do ciclo
Exemplo:
//// outra
outra forma
forma de
de validar
validar os
os dados
dados
while
while (true)
(true) {{ //
// como
como se
se fosse
fosse aa correr
correr indefinidamente
indefinidamente
num
num =
= readInt("Introduza
readInt("Introduza um
um número
número inteiro
inteiro positivo:
positivo: ");
");
ifif (num
(num >=
>= 0)
0)
break
break;;
println(“O
println(“O número
número tem
tem que
que ser
ser inteiro
inteiro positivo
positivo ou
ou zero
zero para
para terminar”);
terminar”);
}}
//// se
nnú
se oo nú
mero éé inteiro
inteiro positivo
positivo ou
ou zero,
zero, então
então
núúmero
//// oo programa
programa continua
continua aqui
aqui depois
depois do
do break
break
Programação em Java 2006-2007
13
Problema 1. Programa
(versão III usando break)
//// entrada
entrada ee processamento
processamento dos
dos dados
dados
while
while (true)
(true) {{
num
nnú
num =
= readInt("
readInt("Introduza
Introduza oo primeiro
primeiro nú
mero inteiro
inteiro positivo
positivo ou
ou zero:
zero: ");
");
núúmero
ifif (num
>=
0)
(num >= 0)
break;
break
break;
break;;
println
nnú
println((""O
O nú
que ser
ser inteiro
inteiro positivo
positivo ou
ou zero
zero para
para terminar
terminar");
");
núúmero
mero tem
tem que
}}
while
while (num
(num !=
!= 0)
0) {{
soma
soma +=
+= num;
num;
//
// Adiciona
Adiciona num
num a
a soma
soma
contador++;
contador++;
while
while (true)
(true) {{
//
// Incrementa
Incrementa o
o contador
contador em
em 1
1
//
// como
como se
se fosse
fosse a
a correr
correr indefinidamente
indefinidamente
Introduza
nnú
Introduza oo seguinte
seguinte nú
mero inteiro
inteiro positivo:
positivo: ");
");
núúmero
ifif (num
>=
0)
(num >= 0)
break
break;;
println("
nnú
println("O
O nú
tem que
que ser
ser inteiro
inteiro positivo
positivo ou
ou zero
zero para
para terminar
terminar");
");
núúmero
mero tem
num
num =
= readInt("
readInt("
}}
}}
Programação em Java 2006-2007
14
7
while versus do…while
Normalmente do…while é mais utilizado que while.
Mas, em princípio, qualquer problema que possa ser resolvido
usando do…while pode também ser resolvido usando while.
fazerAlgo;;
while
condi
while
condiç
ção
ão )
while ( condiç
condiç
{ fazerAlgo };
do
do
do
{ fazerAlgo }
while
condi
while
condiç
ção
ão )
while ( condiç
condiç
( condiç
condi
condiç
ção
ão )
condiç
{ fazerAlgo };
if
if
if
while
while
while
( condiç
condi
condiç
ção
ão )
condiç
do
do
do
{ fazerAlgo };
while
condi
while
condiç
ção
ão )
while ( condiç
condiç
Programação em Java 2006-2007
15
Problema 1. Programa
(versão IV com do…while em vez de while)
//// entrada
entrada ee processamento
processamento dos
dos dados
dados
do
do {{
do
do {{
num
nnú
num =
= readInt("
readInt("Introduza
Introduza um
um nú
mero inteiro
inteiro positivo
positivo ou
ou zero
zero para
para terminar:
terminar: ");
");
núúmero
ifif (num
(num >=
>= 0)
0)
break;
break
break;
break;;
println("
nnú
println("O
O nú
mero tem
tem que
que ser
ser inteiro
inteiro positivo
positivo ou
ou zero
zero ");
");
núúmero
}} while
while (true);
(true);
//// continua
continua depois
depois do
do break
break
ifif (num
(num ==
== 0)
0)
break
break;;
else
else
{{ soma
//// Adiciona
soma +=
+= num;
num;
Adiciona num
num aa soma
soma
contador++;
//// Incrementa
contador++;
Incrementa oo contador
contador em
em 11
}} //
// fecha
fecha else
else
}} while
while (true);
(true);
Programação em Java 2006-2007
16
8
Problema 2
Escrever um programa que primeiro leia quantos
números reais serão introduzidos pelo utilizador e
depois de introduzidos os números, determine e
escreva no monitor a soma dos números lidos
Programação em Java 2006-2007
17
Problema 2: Especificação
Entrada: n - o total de números que serão introduzidos
uma sequencia de n números reais introduzidos pelo
utilizador. Cada número é guardado na variável num
(valor numérico real)
Saída:
soma - a soma dos números lidos (valor numérico real)
Algoritmo:
Inicializar o contador i e a variável soma com zero
Ler o total de números para a variável n
Fazer
1º. Incrementar o contador i em 1
2º. Ler o número i para a variável num
3º. Somar num a soma
Enquanto (i < n)
Imprimir soma
Programação em Java 2006-2007
18
9
Problema 2. Programa
(versão 1: usando o ciclo do…while)
import
import p1.*;
p1.*;
class
class Pr_4_2_CalcularSoma
Pr_4_2_CalcularSoma extends
extends P1App
P1App {{
public
static
void
main(String
args[])
public static void main(String args[]) {{
double
double num,
num, soma
soma =
= 0;
0;
int
int n,
n, i=0;
i=0;
do
do
Quantos
nnú
Quantos nú
meros vai
vai introduzir?
introduzir? ");
");
núúmeros
n
n=
= readInt("
readInt("
Quando i = n o ciclo
termina.
Podemos reescreve-lo usando o
ciclo for
while
while (n
(n <=0);
<=0);
do
do {{
i++;
i++;
Introduza
Introduza oo "" ++ ii ++ "" nnúúmero:
mero: ");
");
num
num =
= readDouble("
readDouble("
soma
soma +=
+= num;
num;
//
// Adiciona
Adiciona num
num a
a soma
soma
while
while (i(i << n)
n)
println("
nnú
println("A
A soma
soma dos
dos nú
meros lidos
lidos éé "" ++ soma
soma );
);
núúmeros
}}
}} }}
Programação em Java 2006-2007
19
O Ciclo for
for
for (inicialização; condição; actualização) {
instruções;
}
inicialização: inicializa a variável de controlo
condição: é calculada antes de cada execução das instruções.
aa variável
variável de
de controlo,
controlo, controla
controla oo número
número de
de vezes
vezes que
que as
as
instruções
instruções vão
vão se
se repetidas
repetidas
se
se oo seu
seu resultado
resultado for
for verdadeiro,
verdadeiro, as
as instruções
instruções são
são executadas
executadas
se
se for
for falso,
falso, oo ciclo
ciclo termina
termina
actualização: é executada depois da execução das instruções
uma
uma acção
acção que
que incrementa
incrementa ou
ou decrementa
decrementa aa variável
variável de
de controlo
controlo
Programação em Java 2006-2007
20
10
Problema 2. Programa
(versão 2: usando o ciclo for)
import
import p1.*;
p1.*;
class
class Pr_4_2_CalcularSoma
Pr_4_2_CalcularSoma extends
extends P1App
P1App {{
public
static
void
main(String
args[])
public static void main(String args[]) {{
double
double num,
num, soma
soma =
= 0;
0;
int
int n;
n;
do
do
Quantos
nnú
Quantos nú
meros vai
vai introduzir?
introduzir? ");
");
núúmeros
n
n=
= readInt("
readInt("
i é a variável de controlo.
i é inicializada com o valor 1
Repetir:
Verificar a condição: i ≤ n ?
Se i≤
≤n, o processo prossegue:
1º. Executar as instruções
2º. Executar i++
caso contrário (i>n):
⇒ o ciclo termina
while
while (n
(n <=0);
<=0);
for
for (int
(int i=1;
i=1; i<=n;
i<=n; i++)
i++) {{
num
num =
= readDouble("
readDouble("Introduza
Introduza oo "" ++ ii ++ "" nnúúmero:
mero: ");
");
soma
soma +=
+= num;
num;
//
// Adiciona
Adiciona num
num a
a soma
soma
}}
A
nnú
A soma
soma dos
dos nú
meros lidos
lidos éé "" ++ soma
soma );
);
núúmeros
println("
println("
}}
}}
Programação em Java 2006-2007
21
Descrição da sequencia de passos
efectuados por o ciclo for para n =3
Inicialização: i = 1 ( a variável de controlo i toma o valor de 1)
Iteração 1: (i =1)
1.
2.
3.
Iteração 2: (i =2)
1.
2.
3.
Verificar a condição: i ≤3? ⇒ SIM ⇒ o ciclo prossegue
Executar as instruções: Ler o segundo número e adiciona-lo a soma
Executar a acção i++ ⇒ i = 3
Iteração 3: (i =3)
1.
2.
3.
Verificar a condição: i ≤3? ⇒ SIM ⇒ o ciclo prossegue
Executar as instruções: Ler o primeiro número e adiciona-lo a soma
Executar a acção i++ ⇒ i = 2
Verificar a condição: i ≤3? ⇒ SIM ⇒ o ciclo prossegue
Executar as instruções: Ler o terceiro nú
número e adiciona-lo a soma
Executar a acção i++ ⇒ i = 4
Iteração 4: (i =4)
1.
Verificar a condição: i ≤4? ⇒ Não ⇒ o ciclo termina
Programação em Java 2006-2007
22
11
Problema 3
Escrever um programa que, recebendo um
qualquer número inteiro positivo,
devolva a soma dos seus dígitos.
Por exemplo, se o inteiro introduzido for 1234 o
programa deverá devolver 10 = 1+2+3+4
Programação em Java 2006-2007
23
Problema 3: Especificação
Entrada: num - número inteiro positivo com um número
indeterminado de dígitos
(valor numérico inteiro positivo: num > 0 )
Saída:
soma - a soma dos dígitos do número
(valor numérico inteiro)
Algoritmo:
Ler o número para a variável num
Inicializar soma com 0
Repetir enquanto houver dígitos para somar
1º. Separar um dos dígitos de num e guardar em dígito.
gito
2º. Somar dígito a soma.
soma
Imprimir soma
Programação em Java 2006-2007
24
12
Problema 3. Pseudo-Código
soma
soma com
com 0;
0;
num
num )) ;;
Enquanto
Enquanto num
num >> 00
digito
digito == num
num %
% 10;
10;
num
=
num
/
10;
num = num / 10;
soma
soma == soma
soma ++ digito
digito;;
Fim
Fim Enquanto
Enquanto ;;
Inicializar
Inicializar
Ler
Ler o
o número
número ((
soma
soma););
Escrever
Escrever no
no ecrã
ecrã a
a soma
soma dos
dos dígitos
dígitos ((
1234 / 10 = 123.4 ⇒
123 – parte inteira → num
4 – o resto da divisão → digito
Iteração
num inicial
digito soma num final
1
1234
4
4
123
2
123
3
7
12
3
12
2
9
1
4
1
1
10
0
Programação em Java 2006-2007
25
Problema 3. Programa
(versão 1: usando o ciclo while)
import
import p1.*;
p1.*;
class
Pr_4_3_1_CalcularSomaDigitos
class Pr_4_3_1_CalcularSomaDigitos extends
extends P1App
P1App {{
public
public static
static void
void main(String
main(String args[])
args[]) {{
int
int num,
num, digito,
digito, soma
soma =
= 0;
0;
leitura
do
do
Introduza
nnú
Introduza um
um nú
núúmero
mero inteiro
inteiro positivo
positivo");
");
num
num =
= readInt(“
readInt(“
while
while (num
(num <=0);
<=0);
while
while (num
(num >0){
>0){
processamento
digito
digito =
= num
num %
% 10;
10;
Equivalente a:
num = num /10
num
num /=
/= 10;
10;
soma
soma +=
+= digito;
digito;
}}
A
ddí
A soma
soma dos
dos dí
gitos éé "" ++ soma
soma );
);
díígitos
escrita
println("
println("
}}
}}
Programação em Java 2006-2007
26
13
Problema 3. Programa
(versão 2: usando o ciclo for)
while
while ((num
num >0){
>0){
digito
digito =
= num
num %
% 10;
10;
processamento
num
num /=
/= 10;
10;
soma
soma +=
+= digito;
digito;
}}
for
for
(( ;;
num
num >0;
>0; num
num /=
/= 10){
10){
num
num %
% 10;
10;
digito
digito =
=
soma
soma +=
+= digito;
digito;
}}
Podemos ainda
escrever as
instruções nesta
forma mais
compacta
for
for
(( ;;
num
num >0;
>0; num
num /=
/= 10){
10){
num
num %
% 10;
10;
soma
soma +=
+=
num é a variável de controlo.
num é inicializada antes do ciclo (o
valor introduzido pelo utilizador)
Repetir:
Verificar a condição: num > 0?
Se num > 0, o processo prossegue:
1º. Executar as instruções
2º. Executar acção: num /= 10
caso contrário (num =0):
⇒ o ciclo termina
}}
Programação em Java 2006-2007
27
Problema 3. Programa
(versão 2: usando o ciclo for)
import
import p1.*;
p1.*;
class
Pr_4_3_2_CalcularSomaDigitos
class Pr_4_3_2_CalcularSomaDigitos extends
extends P1App
P1App {{
public
public static
static void
void main(String
main(String args[])
args[]) {{
int
int num,
num, soma
soma =
= 0;
0;
leitura
do
do
Introduza
nnú
Introduza um
um nú
núúmero
mero inteiro
inteiro positivo
positivo");
");
num
num =
= readInt(“
readInt(“
while
while (num
(num <=0);
<=0);
processamento
for
for
(( ;num
;num >0;
>0; num/=10
num/=10 ){
){
soma
soma +=
+= num
num %
% 10;
10;
}}
escrita
A
ddí
A soma
soma dos
dos dí
gitos éé "" ++ soma
soma );
);
díígitos
println("
println("
}}
}}
Programação em Java 2006-2007
28
14
Problema 4
Escrever um programa que escreva no ecrã uma pirâmide de
números com um número de linhas entre 1 e 9,
fornecido pelo utilizador.
Por exemplo, se o número de linhas for 4, deve obter-se:
1
121
12321
1234321
Programação em Java 2006-2007
29
Problema 4: Especificação
Entrada: numLinhas - número de linhas da pirâmide
(valor numérico inteiro positivo)
Saída:
pirâmide com o número de linhas igual a numLinhas
Algoritmo:
Ler o número de linhas para a variável numLinhas
Para uma variável nLinha = 1 até
até numLinhas fazer:
1º. Escrever os espaços
2º. Escrever números por ordem crescente
3º. Escrever números por ordem decrescente
4º. Mudar de linha
Fim para
Programação em Java 2006-2007
30
15
Problema 4: Algoritmo
for
for
(nLinha
(nLinha =1;
=1; nLinha
nLinha <=
<= numLinhas;
numLinhas;
nLinha++)
nLinha++) {{
//// 1º
11º
espa
Escrever os
os espaç
espaç
espaçços
os
1ºº.. Escrever
for
for (i(i =1;
=1; ii <=
<= numLinhas
numLinhas –
– nLinha;
nLinha; ii ++)
++)
Se numLinhas = 4
Para nLinha =1,
3 espaços
1
Para nLinha =2,
2 espaços
121
print(“
print(“
");
");
//// 2º
22º
nnú
2ºº.. Escrever
Escrever nú
núúmeros
meros (ordem
(ordem crescente)
crescente)
for
for (i(i =1
=1 ;; ii <=
<= nLinha;
nLinha; ii ++)
++)
print(i
print(i );
);
Para nLinha =3,
1 espaço
12321
Para nLinha =4,
0 espaço
1234321
//// 3º
33º
nnú
Escrever nú
núúmeros
meros (ordem
(ordem decrescente)
decrescente)
3ºº.. Escrever
for
for (i(i =nLinha-1
=nLinha-1 ;; ii >=1;
>=1; ii --)
--)
print(i
print(i );
);
//// 4º
44º
Mudar de
de linha
linha
4ºº.. Mudar
println();
println();
# espaços = numLinhas - nLinha
}}
Programação em Java 2006-2007
31
Problema 5
Escrever um programa que dado um número indeterminado
de inteiros positivos introduzidos pelo teclado, até que
apareça o número zero (indicador de paragem),
verifica se os números lidos constituem
uma sequência continua de números impares.
Se a sequência for continua, o programa escreve no monitor
a mensagem: “A sequência de números é uma sequência
continua de números impares”, senão escreve a mensagem:
“A sequência de números não é uma sequência continua de
números impares”
Programação em Java 2006-2007
32
16