Professional Documents
Culture Documents
Estruturas de Decisão
e de Repetição
Estruturas de Decisão
Conjunto de instruções que permitem o controle da
execução, de modo a que o programa possa fazer escolhas
1
Selecção Simples
Permite decidir entre executar ou não um conjunto de
instruções em função do resultado de uma condição
if (condição) {
instruções;
}
Selecção em alternativa
Escolhe entre dois conjuntos de instruções qual deve ser
executado em função do resultado de uma condição
if (condição) {
instruções se condição verdadeira;
}
else {
instruções se condição falsa;
}
2
Expressão Lógica
As expressões ló
lógicas constroem-
constroem-se mediante:
Operadores relacionais
Operadores lógicos
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 5
Operadores Relacionais
Operador Operação
Operam sobre operandos
== igual a
(constantes, variáveis, expressões)
!= diferente de
de diferentes tipos
(numé
(numéricos, caracteres) < menor que
e como resultado retornam um <= menor ou igual
valor de tipo lógico > maior que
>= maior ou igual
Exemplos
a b a == b a!=b a < b a<=b a > b a >= b
2 3 false true true true false false
‘a’ ‘d’ false true true true false false
33 33 true false false true false true
3
Precedência dos Operadores Relacionais
(a + b - 1) < (x * y) (a + b - 1) < (x * y)
R1
R1 == aa ++ bb R1
R1 == 31
31 ++ (-1)
(-1) == 30
30
R2
R2 == R1
R1 -- 11 R2
R2 == 30
30 -- 11 == 29
29
R3
R3 == xx ** yy R3
R3 == 33 ** 22 == 66
R4
R4 == R2
R2 << R3R3 →
→ resultado
resultado R4
R4 == 29
29 << 66 == falso
falso →
→ resultado
resultado
Exercício (I)
1. (a + b / c) >= (x – y % c)
para a=3, b=5, c=2, x=1 e y=4
2. a – b != x + y
para a=10, b=1, x=5 e y=4
3. (a + b % c ) <= (x * y) + (y % 2)
para a=2, b=7, c=3, x=2, y=1, z=6
4
Operadores Lógicos
Operam sobre operandos Operador Operação
(constantes, variáveis, expressões) && conjunção (AND)
de tipo lógico || disjunção (OR)
e retornam um valor de tipo lógico ! Negação (NOT)
a b a && b a || b !a !b
true true true true false false
true false false true false true
false true false true true false
false false false false true true
Exemplo do operador OR
ifif ((x
((x >> 5)
5) |||| (x
(x << 1))
1))
System.out.println(“x
System.out.println(“x ee maior
maior que
que 55 ou
ou menor
menor que
que 1”);
1”);
else
else
System.out.println(“x
System.out.println(“x está
está entre
entre 11 ee 5”);
5”);
5
Precedência dos Operadores Lógicos
Exemplo: Para x = 3 e y = 6
!(x < 5) && !(y >= 7) !(x < 5) && !(y >= 7)
R1
R1 == xx << 55 R1
R1 == 33 << 55 →
→ verdadeiro
verdadeiro
R2
R2 == yy >=
>= 77 R2
R2 = 6 >= 7 → falso
= 6 >= 7 → falso
R3
R3 == !R2
!R2 R3
R3 == !falso
!falso →→ verdadeiro
verdadeiro
R4
R4 == !R1
!R1 R4
R4 == !verdadeiro
!verdadeiro → → falso
falso
R5
R5 == R4
R4 &&&& R3
R3 →
→ Resultado
Resultado R5
R5 == verdadeiro
verdadeiro &&&& falso
falso == falso
falso
Exercício (II)
6
Exercício (III)
int
int xx == 0,
0, yy == 1,
1, zz == 2;
2;
ifif (((x
(((x !=0)
!=0) &&
&& (y(y ==
== 1))
1)) |||| (z
(z !=
!= 0))
0))
System.out.print("Ganhou");
System.out.print("Ganhou");
else
else
System.out.print("Perdeu");
System.out.print("Perdeu");
System.out.println("
System.out.println(" o prémio");
ifif (condição1)
(condição1) {{
instruções
instruções se se condição1
condição1 verdadeira;
verdadeira;
}} else
else {{
ifif (condição2)
(condição2) {{
instruções
instruções se se condição2
condição2 verdadeira;
verdadeira;
}} else
else { {
ifif (condição3)
(condição3) {{
instruções
instruções se
se condição3
condição3 verdadeira;
verdadeira;
……
else
else {{
instruções
instruções se
se condição
condição falsa;
falsa;
}}
7
Exemplo 1
Idade Bilhete
Inferior a 6 Isento de pagamento
Bilhete Entre 6 e 12
Entre 13 e 65
Bilhete de criança
Bilhete normal
Mais de 65 Bilhete de 3ª idade
idade é uma
variável inteira
ifif (idade
(idade <= <= 5){
5){ //// terá
terá menos
menos de de 66 anos?
anos?
System.out.println
System.out.println ("Isento ("Isento de de pago");
pago");
}} else
else {{ //// terá
terá entre
entre 66 ee 12
12 anos?
anos?
quando usamos ifif (idade
(idade <= 12){<= 12){
apenas uma
instrução por bloco System.out.println
System.out.println ("Bilhete ("Bilhete de de criança");
criança");
podemos tirar as }} else
else {{ //// terá
terá entre
entre 12
12 ee 65
65 anos?
anos?
chavetas, e assim o ifif (idade
(idade <=
<= 65){
65){
programa fica
menos confuso System.out.println
System.out.println ("Bilhete ("Bilhete normal");
normal");
}} else
else {{ //// teráterá mais
mais do
do que
que 6565 anos?
anos?
System.out.println("Bilhete
System.out.println("Bilhete 3ª 3ª idade");
idade");
}} //// fecha
fecha bloco
bloco se se idade
idade >> 65
65
}} //// fecha bloco se idade
fecha bloco se idade > 12 > 12
}} //// fecha
fecha bloco
bloco se
se idade idade >> 55
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 15
Exemplo 2
Dado um número do mês retorna qual a estação do ano
mes é uma
variável inteira
ifif (mes
(mes == == 1212 |||| mes
mes == == 11 |||| mes
mes == == 2)2)
System.out.println
System.out.println ("A ("A estação
estação do do ano
ano éé oo Inverno");
Inverno");
else
else ifif (mes
(mes == == 33 |||| mes
mes == == 44 |||| mes
mes ==== 5)
5)
System.out.println
System.out.println ("A ("A estação
estação do do ano
ano éé aa Primaveira");
Primaveira");
else if (mes == 6 || mes == 7
else if (mes == 6 || mes == 7 || mes == 8) || mes == 8)
System.out.println
System.out.println ("A ("A estação
estação do do ano
ano éé oo Verão");
Verão");
else
else ifif (mes
(mes == == 99 |||| mes
mes == == 10
10 |||| mes
mes ==
== 11)
11)
System.out.println
System.out.println ("A ("A estação
estação do do ano
ano éé oo Outono");
Outono");
Em vez de usar
if-
if-then podemos usar a
estrutura de selecção
múltipla switch-
switch-case
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 16
8
Selecção Múltipla: Switch-Case
Quando a escolha for feita em função do valor de uma
expressão inteira ou cará
carácter,
cter é mais eficaz utilizar
uma estrutura de switch-case
switch
switch (expressão)
(expressão) {{
case
case valor_1:
valor_1:
instruções;
instruções;
break provoca o fim break;
break;
da instrução,
….
….
evitando que as
instruções das case
case valor_n:
valor_n:
outras opções instruções;
instruções; default é opcional.
sejam executadas break;
break; Caso exista, será
default:
default: executada se nenhum
instruções;
instruções; dos valores for igual
break; ao resultado da
break;
expressão
}}
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 17
Implementação de Menus
(usando JOptionPane)
String
String str
str == JOptionPane.showInputDialog(null,
JOptionPane.showInputDialog(null, "Indique
"Indique aa opção:
opção: \n"
\n" ++
"" 11 –– opção
opção 11 \n"
\n" ++
…
…
"" nn –– opção
opção nn \n“
\n“ ););
int op = Integer.parseInt(str);
int op = Integer.parseInt(str);
switch
switch (op)
(op) {{
case
case 1: 1:
System.out.println(“Seleccionou
System.out.println(“Seleccionou aa opção
opção 1");
1");
switch-case pode ser break;
break;
usada para implementar …
…..
um menu com várias
opções a escolher pelo case
case n:n:
utilizador. As opções System.out.println(“Seleccionou
System.out.println(“Seleccionou aa opção
opção n");
n");
podem ser números ou
break;
break;
caracteres.
default:
default::
default
System.out.println(“A
System.out.println(“A opção
opção seleccionada
seleccionada está
está incorrecta");
incorrecta");
break;
break;
}}
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 18
9
Problema 1: Dias de um mês
Escrever um programa que lê do teclado uma data
composta pelo nº de mês e ano, calcula e imprime
no ecrã o nº de dias desse mês.
Implementar duas versões:
uma usando if-then e a outra usando swicth-case
Ano bissexto: de 4 em 4 anos, com excepção dos finais de século,
que são bissextos de 4 em 4 séculos. Por exemplo, os anos 1600,
1996, 2000, 2004 são bissextos, mas os anos 1700, 1800 ou 1900
não o são.
Problema 1. Especificação
Solução:
# Mes # dias
1, 3, 5, 7, 8, 31
10, 12 Ano bissexto: de 4 em 4 anos, com excepção dos finais
de século, que são bissextos de 4 em 4 séculos.
4, 6, 9, 11 30
2 SE (ano bissexto) SE ((ano é múltiplo de 4)
dias = 29 E (ano não é múltiplo de 100))
caso contrario OU (ano é múltiplo de 400)
dias = 28
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 20
10
Programa: Dias de um mês (v.1)
(usando if-else e I/O com caixas de dialogo)
import javax.swing.*;
class Cap1Top4Pr1v1DiasMes {
Podemos unir a entrada e conversão
public static void main (String [ ] args) {
em inteiro numa única instrução
int mes, ano, dias;
// entrada de dados
mes = Integer.parseInt (JOptionPane.showInputDialog (null, "Introduza o mes: "));
ano = Integer.parseInt (JOptionPane.showInputDialog (null, "Introduza o ano: "));
// processamento
if ( (mes == 4) || (mes == 9) || (mes == 11) )
dias = 30;
else if (mes == 2)
if ( ((ano % 4 == 0) && !(ano % 100 == 0)) || (ano % 400 == 0) )
dias = 29;
else Ano bissexto
dias = 28;
else
dias = 31;
// saida de resultados
JOptionPane.showMessageDialog (null, "mes: " + mes + "\n" + "ano: " + ano + "\n + "nº dias: " + dias);
} }
11
Programa: Dias de um mês (v.3)
(usando swith-case e I/O com caixas de diaologo
import javax.swing.*;
class Cap1Top4Pr1v3DiasMes {
public static void main (String [] args) {
int mes, ano, dias;
mes = Integer.parseInt (JOptionPane.showInputDialog (null, "Introduza o mes: "));
ano = Integer.parseInt (JOptionPane.showInputDialog (null, "Introduza o ano: "));
switch (mes) {
case 4:
case 6:
case 9:
case 11:
dias = 30;
break;
Processamento com switch-case
case 2:
if ( ((ano % 4 == 0) && !(ano % 100 == 0)) || (ano % 400 == 0) )
dias = 29;
else
dias = 28;
break;
default:
dias = 31;
}
JOptionPane.showMessageDialog (null, "mes: " + mes + "\n" + "ano: " + ano + "\n + "nº dias: " + dias);
} }
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 23
Problema 2
12
Programa: Menu de Operações (I)
(entrada usando caixa de dialogo)
import javax.swing.*;
class Cap1Top4Pr2v1MenuAritmetica{
public static void main(String [ ] args) {
int op, num1, num2;
Menu de Operações
char oper = ' ';
double res= 0;
String str = JOptionPane.showInputDialog (null, "Indique a operação: \n" +
" 1 - soma \n" +
entrada de dados
13
Programa: Menu de Operações (III)
(saída usando caixa de mensagem)
if (op != 4 || num2 !=0) {
JOptionPane.showMessageDialog (null, "1º operando: " + num1 + "\n" +
"2º operando: " + num2 + "\n" +
"operação: " + num1 + " " + oper + " " + num2 + " = " + res);
}
else
JOptionPane.showMessageDialog (null, " ERRO: divisão por zero ");
} // fecha if (op >= 1 && op <= 4)
else
JOptionPane.showMessageDialog (null, " ERRO: não existe essa operação");
} // close main
} // close class Este é o else caso a operação introduzida for
< 1 e > 4, ou seja estiver incorrecta
Estruturas de Repetição
14
Estruturas de Repetição
As estruturas repetitivas ou ciclos permitem repetir
um conjunto de uma ou mais instruções
while (condição) { do {
instruções; instruções;
} } while (condição)
pre-validação:
pre-validação: oo teste
teste da
da post-validação:
post-validação: oo teste
teste da
da
condição feito antes da
condição éé feito da condição
condição só é feito
feito depois
execução
execução das
das instruções
instruções da
da execução
execução das
das instruções
instruções
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 30
15
Problema 3
Problema 3: 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
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 32
16
Problema 3. Pseudo-Código
Inicializar
Inicializar soma
soma comcom 0;0;
Inicializar
Inicializar contador
contador com com 0;
0;
Ler
Ler oo primeiro
primeiro número
número (numnum )) ;;
(num
Antes de testar a Enquanto
Enquanto num num != != 00
condição é preciso
ler o primeiro
Adiciona-lo
Adiciona-lo áá soma
soma ;;
número para poder Incrementar
Incrementar contador
contador emem um um ;;
avaliar a expressão
lógica Ler
Ler oo seguinte
seguinte número
número (num
num )) ;;
(num
Fim
Fim Enquanto
Enquanto ;;
Se
Se (contador !=
(contador
contador != 0)
0)
Calcular
Calcular média
média (( media
media == soma
soma // contador);
contador
contador);
Escrever
Escrever no no ecrã
ecrã oo total
total de
de números
números lidos
lidos (contador
contador);
(contador);
Escrever
Escrever no no ecrã
ecrã aa média
média dos
dos números
números lidos
lidos (media
media);
(media);
caso
caso contrá
contr ário
contrário
Escrever
Escrever aa mensagem
mensagem ““Não
Não foram
foram introduzidos dados”;”;
introduzidos dados
import
import java.io.*;
java.io.*;
import
import java.text.*;
java.text.*; //// para
para usar
usar DecimalFormat
DecimalFormat
class
class Cap1Top4Pr3v1MediaSeqInt
Cap1Top4Pr3v1MediaSeqInt {{
public
public static
static void
void main(String
main(String [][] args)
args) throws
throws IOException{
IOException{
int
int num,
num, soma
soma == 0, 0, contador
contador == 00 ;;
double
double media;
media;
//// criação
criação do
do fluxo
fluxo de
de dados
dados para
para poder
poder ler
ler dados
dados do
do teclado
teclado
BufferedReader
BufferedReader input
input == new
new BufferedReader
BufferedReader (new
(new InputStreamReader
InputStreamReader (System.in));
(System.in));
Problema 3 DecimalFormat
DecimalFormat df
//// entrada
df == new
new DecimalFormat("0.00");
DecimalFormat("0.00"); //// formato
formato dos
dos números
números decimais
decimais
entrada ee processamento
processamento dos
dos dados
dados
Programa (1) System.out.print
System.out.print ("Introduza
("Introduza oo primeiro
primeiro número
número inteiro
inteiro positivo:
positivo: ");
");
num
num == Integer.parseInt
Integer.parseInt (input.readLine()
(input.readLine() ););
while
while (num
(num !=!= 0)
0) {{
Precisamos soma
soma == soma
soma ++ num;
num; //// adiciona
adiciona num
num aa soma
soma
ainda validar
contador
contador == contador
contador ++ 1;1; //// incrementa
incrementa oo contador
contador em
em 11
que o
System.out.print
System.out.print (( "Introduza
"Introduza oo seguinte
seguinte número
número inteiro
inteiro positivo:
positivo: ");
");
número é
não negativo num
num == Integer.parseInt
Integer.parseInt (input.readLine());
(input.readLine());
}}
//// processamento
processamento ee saída
saída de
de resultados
resultados
ifif (contador
(contador !=!= 0)
0) {{
media
media == ((double)
((double) soma)
soma) // contador;
contador;
System.out.println
System.out.println ("Foram
("Foram lidos
lidos "" ++ contador
contador ++ "" números
números inteiros
inteiros positivos.");
positivos.");
System.out.println
System.out.println ("A
("A média
média dos
dos números
números lidos
lidos éé "" ++ df.format
df.format (media)
(media) ););
}} else
else
System.out.println
System.out.println ("Não
("Não foram
foram introduzidos
introduzidos dados");
dados");
}} //// fim
fim main()
main()
}} //// fim
fim class
class Pr_4_1_CalcularMedia
Pr_4_1_CalcularMedia
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 34
17
Usando do…while para validar a entrada
//// outra
outra forma
forma de
de validar
validar os
os dados
dados
do
do { {
System.out.print
System.out.print (“ (“ Introduza
Introduza um um número
número inteiro
inteiro positivo:
positivo: ");
");
num
num == Integer.parseInt(input.readLine());
Integer.parseInt(input.readLine());
CUIDADO ao usar ifif (num
(num >= >= 0)
0)
while (true): break;
break;
o ciclo corre
System.out.println("O
System.out.println("O número número tem tem que
que ser
ser inteiro
inteiro positivo
positivo ouou zero
zero ");
");
indefinidamente e só
para quando }} while
while (true);
(true);
encontrar break //// sese oo número
número éé inteiro
inteiro positivo
positivo ou
ou zero,
zero, então
então
//// aa entrada
entrada está
está correcta,
correcta, por
por isso
isso oo ciclo
ciclo termina
termina ee oo programa
programa
//// continua
continua aa execução
execução aqui
aqui aa seguir
seguir dodo break
break
18
Problema 3. Programa Revisto
(versão 2 usando do…while e break)
CICLO EXTERNO //// entrada
entrada ee processamento
processamento dos
dos dados
dados
(para a entrada de do
do {{
números)
PARA se num == 0 //// leitura
leitura ee validação
validação dodo número
número entrada
entrada
do
do {{
System.out.print
System.out.print ("Introduza
("Introduza umum número
número inteiro
inteiro positivo:
positivo: ");
");
CICLO INTERNO num
num == Integer.parseInt
Integer.parseInt (input.readLine()
(input.readLine() ););
(para a validação
de uma entrada) ifif (num
(num >=>= 0)0)
PARA se a entrada break;
break;
é correcta, i.e.,
System.out.println
System.out.println ("O ("O número
número temtem que
que ser
ser inteiro
inteiro positivo
positivo ouou zero
zero ");
");
se num >= 0
}} while
while (true);
(true);
//// continua
continua depois
depois do
do break
break do
do ciclo
ciclo interno
interno
ifif (num
(num == == 0)
0)
break;
break; //// criterio
criterio de
de paragem
paragem da
da entrada
entrada
soma
soma += num; += num;
contador++;
contador++;
}} while
while (true);(true);
fazerAlgo;
fazerAlgo; do
do
while
while (( condição
condição )) {{ fazerAlgo
fazerAlgo }}
{{ fazerAlgo
fazerAlgo };
}; while
while (( condição
condição ))
while
while (( condição
condição )) ifif (( condição
condição ))
{{ fazerAlgo
fazerAlgo };
}; do
do
{{ fazerAlgo
fazerAlgo };};
while
while (( condição
condição ))
19
Erros na entrada de dados
O que acontece se introduzirmos, por exemplo, “ai” em
vez de um número inteiro, como é requerido?
do
do {{
System.out.print
System.out.print (“ (“ Introduza
Introduza um
um número
número inteiro
inteiro positivo:
positivo: ");
");
num
num == Integer.parseInt
Integer.parseInt (input.readLine()
(input.readLine() ););
ifif (num
(num >=>= 0)
0)
break;
break;
System.out.println("O
System.out.println("O númeronúmero tem
tem que
que ser
ser inteiro
inteiro positivo
positivo ou
ou zero
zero ");
");
}} while
while (true);
(true);
20
Usando try-catch para tratar erros
do
do {{
Esta é a única instrução que
System.out.print
System.out.print (“ (“ Introduza
Introduza um
um número
número inteiro
inteiro positivo:
positivo: ");
"); pode lançar uma excepção:
num
num == Integer.parseInt
Integer.parseInt (input.readLine()
(input.readLine() );); a excepção
ifif (num
(num >=>= 0)
0) break;
break; NumberFormatException.
System.out.println("O
System.out.println("O númeronúmero tem
tem que
que ser
ser inteiro
inteiro positivo
positivo ou
ou zero
zero ");
"); Podemos captura-la e tratar
}} while este erro usando try-catch
while (true);
(true);
do
do {{
System.out.print
System.out.print (( ““ Introduza
Introduza um
um número
número inteiro
inteiro positivo:
positivo: ");
");
try
try {{ //// aqui
aqui vai
vai oo código
código que
que pode
pode falhar
falhar
num
num == Integer.parseInt(input.readLine());
Integer.parseInt(input.readLine());
}} catch
catch (Exception
(Exception e){
e){
//// aqui
aqui oo codigo
codigo para
para tratar
tratar oo falho
falho
System.out.println
System.out.println (( "Erro...
"Erro... insira
insira um
um número
número válido...");
válido...");
}}
ifif (num
(num >=
>= 0)
0) break;
break;
System.out.println
System.out.println ("O
("O número
número tem
tem que
que ser
ser inteiro
inteiro positivo
positivo ou
ou zero
zero ");
");
}} while
while (true);
(true);
21
Problema 4
Problema 4: 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
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 44
22
Problema 4. Programa
(versão 1: usando o ciclo do…while)
import
import java.io.*;
java.io.*;
class
class Cap1Top4Pr4v1SomaSeqInt
Cap1Top4Pr4v1SomaSeqInt {{
Para simplificar os public
public static
static void
void main(String
main(String [[ ]] args)
args) throws
throws IOException
IOException {{
programas vamos double
double num, num, soma
soma == 0;0;
obviar o tratamento int
int n,
n, ii == 0;
0;
de erro com BufferedReader
BufferedReader input input == new
new BufferedReader
BufferedReader (new(new InputStreamReader
InputStreamReader (System.in));
(System.in));
try-catch dodo {{
System.out.print
System.out.print ("Introduza
("Introduza um um número
número inteiro
inteiro positivo:
positivo: ");
");
nn == Integer.parseInt(input.readLine());
Integer.parseInt(input.readLine());
}} while
while (n (n <=0);
<=0);
Este ciclo termina
quando i toma o
valor de n. Podemos do
do {{
reescreve-o usando i++;
i++; //// incrementa
incrementa oo contador
contador
o ciclo for System.out.print
System.out.print (( "Introduza
"Introduza oo "" ++ ii ++ "" número
número :: ");
");
num
num == Double.parseDouble(input.readLine());
Double.parseDouble(input.readLine());
soma
soma += += num;
num; //// Adiciona
Adiciona num
num aa soma
soma
}} while
while (i(i << n);
n);
System.out.println
System.out.println (( "A "A soma
soma dos dos números
números lidos
lidos éé "" ++ soma
soma ););
}} //// fim
fim main()
main()
}}
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 45
O Ciclo for
for (inicialização; condição; actualização) {
instruções;
}
inicialização:
inicialização: inicializa
inicializa aa variável
variável de
de controlo
controlo
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
condição:
condição: éé calculada
calculada antes
antes de
de cada
cada execução
execução das
das instruções.
instruções.
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:
actualização: éé executada
executada depois
depois da
da execução
execução das
das instruções
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
23
Problema 4. Programa
(versão 2: usando o ciclo for)
//// entrada
entrada ee processamento
processamento de
de dados
dados
do
do {{
System.out.print
System.out.print ("
("Introduza
Introduza um
um número
número inteiro positivo:: ");
inteiro positivo ");
nn == Integer.parseInt(input.readLine());
Integer.parseInt(input.readLine());
i é a variável de controlo.
}} while
while (n(n <=0);
<=0);
i é inicializada com o valor 1
Repetir:
Verificar a condição: i ≤ n ?
for
for (int
(int i=1;
i=1; i<=n;
i<=n; i++){
i++){
SE i≤n, o processo prossegue: System.out.print
System.out.print (( "Introduza
"Introduza oo "" ++ ii ++ "" número
número :: ");
");
1º. Executar as instruções num
num == Double.parseDouble
Double.parseDouble (input.readLine());
(input.readLine());
2º. Executar i++ soma
soma += += num;
num; //// Adiciona
Adiciona num
num aa soma soma
caso contrário (i>n): }}
⇒ o ciclo termina
//// saída
saída de
de dados
dados
System.out.println
System.out.println (( "A
"A soma
soma dos
dos números
números lidos
lidos éé "" ++ soma
soma ););
}} //// fim
fim main()
main()
}}
Iteração 3: (i =3)
1. Verificar a condição: i ≤3? ⇒ SIM ⇒ o ciclo prossegue
2. Executar as instruções: Ler o terceiro nú
número e adiciona-lo a soma
3. Executar a acção i++ ⇒ i = 4
Iteração 4: (i =4)
1. Verificar a condição: i ≤4? ⇒ Não ⇒ o ciclo termina
24
Problema 5
Problema 5: 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
25
Problema 5. Pseudo-Código
Inicializar
Inicializar soma
soma com
com 0; 0;
Ler
Ler oo número
número (num
num )) ;;
(num
Enquanto
Enquanto num num >> 00
digito
digito == num
num % % 10;
10;
num = num /
num = num / 10; 10;
soma
soma == soma
soma ++ digito;
digito
digito;
Fim
Fim Enquanto
Enquanto ;;
Escrever
Escrever nono ecrã
ecrã aa soma
soma dosdos dígitos
dígitos (soma
soma);
(soma);
Problema 5. Programa
(versão 1: usando o ciclo while)
import
import java.io.*;
java.io.*;
class
class Cap1Top4Pr5v1SomaDigitos
Cap1Top4Pr5v1SomaDigitos {{
public
public static
static void
void main(String
main(String [[ ]] args)
args) throws
throws IOException{
IOException{
int
int num,
num, digito,
digito, soma
soma == 0;
0;
BufferedReader
BufferedReader inputinput == new
new BufferedReader
BufferedReader (new(new InputStreamReader
InputStreamReader (System.in));
(System.in));
//// entrada
entrada ee validação
validação do
do número
número
do
do {{
System.out.print("Introduza
System.out.print("Introduza umum número
número inteiro
inteiro positivo:
positivo: ");
");
num
num == Integer.parseInt
Integer.parseInt (input.readLine());
(input.readLine());
}} while
while (num
(num <=0);
<=0);
//// processamento
processamento
while
while (num
(num >> 0)0) {{
digito
digito == num
num % % 10;
10;
Equivalente a: num
num /=/= 10;
10;
num = num /10
soma
soma += += digito;
digito;
}}
//// saída
saída
System.out.println
System.out.println (“
(“ A
A soma
soma dos
dos dígitos
dígitos é:
é: "" ++ soma);
soma);
}}
}}
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 52
26
Problema 5. Programa
(versão 2: usando o ciclo for)
processamento
while
while (num
(num >0){
>0){
digito
digito == num
num % % 10;
10;
num
num /=/= 10;
10;
soma
soma += += digito;
digito;
}}
Problema 5. Programa
(versão 2: usando o ciclo for)
import
import java.io.*;
java.io.*;
class
class Cap1Top4Pr5v2SomaDigitos
Cap1Top4Pr5v2SomaDigitos {{
public
public static
static void
void main(String
main(String [[ ]] args)
args) throws
throws IOException{
IOException{
int num, digito, soma = 0;
int num, digito, soma = 0;
BufferedReader
BufferedReader input
input == new
new BufferedReader
BufferedReader (new
(new InputStreamReader
InputStreamReader (System.in));
(System.in));
leitura do
do {{
System.out.print("Introduza
System.out.print("Introduza um
um número
número inteiro
inteiro positivo:
positivo: ");
");
num
num == Integer.parseInt
Integer.parseInt (input.readLine());
(input.readLine());
}} while
while (num
(num <=0);
<=0);
for
for (( ;num
;num >0;
>0; num/=10
num/=10 ){
){
processamento soma
soma +=+= num
num %% 10;
10;
}}
System.out.println
System.out.println (“
(“ A
A soma
soma dos
dos dígitos
dígitos é:
é: "" ++ soma);
soma);
escrita }}
}}
27
Problema 6
Problema 6: 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
28
Problema 6: Algoritmo
for
for (nLinha
(nLinha =1; =1; nLinha
nLinha <=
<= numLinhas;
numLinhas;
nLinha++)
nLinha++) {{
Se numLinhas = 4 //// 1º.
1º. Escrever
Escrever os os espaços
espaços
for
for (i(i =1;
=1; ii <=
<= numLinhas
numLinhas –– nLinha;
nLinha; ii ++)
++)
Para nLinha =1,
print(“
print(“ "); ");
3 espaços 1
//// 2º.
2º. Escrever
Escrever númerosnúmeros (ordem
(ordem crescente)
crescente)
Para nLinha =2,
2 espaços 121 for
for (i =1 ; i <= nLinha; ii ++)
(i =1 ; i <= nLinha; ++)
print(i
print(i ););
Para nLinha =3, //// 3º.
3º. Escrever
Escrever númerosnúmeros (ordem
(ordem decrescente)
decrescente)
1 espaço 12321
for
for (i(i =nLinha-1
=nLinha-1 ;; ii >=1;
>=1; ii --)
--)
print(i
print(i ););
Para nLinha =4,
1234321 //// 4º.
0 espaço 4º. Mudar
Mudar de de linha
linha
println();
println();
# espaços = numLinhas - nLinha }}
Problema 6: Programa
?
Algoritmos e Estruturas de Dados, 2007-2008 , Gladys Castillo 58
29