Algoritmos e fluxogramas

Eng.
Inf, 1ano Aulas Páticas Programação e Algoritmos 1
AULAS PRATICAS
Algoritmo
Durante o seu funcionamento o computador segue um programa, um conjunto de instruções bem definidas
que especificam exactamente o que tem de ser feito. Este conjunto de instruções é caracterizado
matematicamente como um algoritmo. Os algoritmos foram estudados muito antes do aparecimento dos
computadores modernos (por exemplo, para efectuar operações aritméticas com números decimais).
Um algoritmo pode ser definido como uma sequência finita de instruções bem definidas e não ambíguas, cada
uma das quais pode ser executada mecanicamente num período de tempo finito com uma quantidade de
esforço finita.
Um algoritmo está sempre associado com um dado objectivo, ou seja, com a solução de um dado problema. A
execução das instruções do algoritmo garante que o seu objectivo é atingido.
Exemplos informais de algoritmos
A descrição de sequências de acções para atingir objectivos tem um papel fundamental na nossa vida
quotidiana. Estamos constantemente a transmitir ou a seguir sequências de instruções, por exemplo, para
preencher impressos, para operar máquinas, para montar objectos, para nos deslocarmos para certo local, etc.
Características de um algoritmo
Existem inúmeros exemplos de algoritmos que utilizamos na nossa vida quotidiana (instruções para fazer uma
chamada telefónica, para procurarmos palavras em dicionários, etc.). Todos eles correspondem a sequências
de passos finitas de instruções que devem ser seguidas de modo a atingir um determinado objectivo.
No entanto, nem todas as sequências de passos para atingir um dado objectivo podem ser consideradas um
algoritmo, pois todo o algoritmo deve possuir três características: ser rigoroso (para não haver ambiguidade,
cada uma das suas instruções tenha uma e só uma interpretação), ser eficaz e ter a garantia de terminar.
Fluxogramas
Um fluxograma é a representação gráfica de um algoritmo. O fluxograma tem a vantagem de permitir
visualizar rapidamente a estrutura de programação utilizada.
Num fluxograma utiliza-se um conjunto de blocos predefinidos, por exemplo:
Início/fim decisão
saída/entrada repetição
de dados
calculo conexão
Existem diferentes tipos de fluxogramas elementares:
Fluxograma linear
Fluxograma com ramificação:
Multi ramificação
repetitivo (ou cíclico)
Pseudo código
Para ilustrar a execução de um algoritmo utiliza-se o chamado pseudo código, que não é mais do que a
utilização de uma linguagem convencional, esquemática, que não necessita de respeitar os “rigores” da sintaxe
das verdadeiras linguagens de programação.
Fluxograma linear (Sequência simples)
1). Elaborar o algoritmo, desenhar o fluxograma e escrever o pseudo código para poder calcular e visualizar o
salário de um trabalhador, recebendo o valor da taxa por hora em vigor e a quantidade das horas trabalhadas
via teclado.
início Entrada: valores de taxa por hora e horas trabalhadas
Saida: valor do Salário
taxaHora,
horasTrab Pseudo código:
início;
ler (taxaHora, horasTrab);
sal taxaHora x horasTrab sal horasTrab x taxaHora;
visualizar (sal);
fim.
sal
fim
1
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1
Exercícios: Elaborar o algoritmo, desenhar o fluxograma e escrever o pseudo código para resolução de
seguintes problemas:
1a) calcular o valor total a pagar (IVA incluído) na compra de N computadores de preço P com desconto de 5%
(os valores de N e P devem ser recebidos via teclado).
1b) determinar a quantidade de dias correspondentes a idade de utilizador. Converter para semanas e depois
para horas.
1c) ler uma temperatura em graus Celsius e apresentá-la em graus Fahrenheit (F = (9 x C + 160) : 5).
Fluxograma com ramificação
Selecção simples
2). Introduzir do teclado um número e visualizar uma mensagem somente se o número introduzido for igual a
zero.
início Entrada: um numero
Saida: uma mensagem se o numero for = 0
num Pseudo código:

Início;
ler (num);
+ Numero é se num = 0 então
num =0
igual a zero visualizar (“O numero introduzido é igual a zero”);
- fim.
fim -
Selecção em alternativa
3).Recebendo do teclado os valores das três notas de testes de um aluno calcular a média final e visualizar o
comentário sobre o aluno (aprovado/ reprovado).
Pseudo código:
início início Início;
ler (t1,t2,t3);
med (t1+t2+t3)/3;
t1, t2, t3 t1, t2, t3 se med >= 9.5 então
visualizar (“O aluno é Aprovado”)
med (t1+t2+t3)/3 med (t1+t2+t3)/3 senão
visualizar (“O aluno é Reprovado”);
fim.
+ O aluno é + coment ”Aprovado”
med med
Aprovado
- -
se med >=9.5 então
O aluno é coment ”Reprovado”
coment “Aprovado”
Reprovado
senão
coment “Reprovado”;
coment
visualizar (coment);
fim
fim
Compara as duas variantes de fluxograma. Qual é a diferença entre eles?
Exercícios:
3a) Calcular o salário de um funcionário que recebe um valor fixo por mes, a menos que comete faltas. No
caso de quantidade de faltas ultrapassassem 5 o salário é descontado em 3%.
3b) Determinar o valor de prémio ganho pelo vendedor de cadernos. A meta de venda é de 50 cadernos
num dia, o preço de um caderno é de 15,00 Mt. No caso de conseguir vender mais o vendedor recebe
prémio que é uma décima parte da quantidade vendida. Visualizar ainda o valor total ganho.
3c) Calcular e visualizar o Y.
ln x , se x > 0
Y= e x
, se x ≤ 0
2x - |x + 4|
2
4). Considera o exercício sobre o aluno aprovado/ reprovado e adiciona a possibilidade de dispensa.
início Pseudo código:
início
ler (t1,t2,t3);
t1, t2, t3 med (t1+t2+t3)/3;
se med >=14.5 então
coment “Dispensado”
med (t1+t2+t3)/3 senão
se med >= 9.5 então
coment “Admitido”
- + coment ”Dispens” senão
med>=14.5
coment “Excluido”;
- + visualizar (coment);
med >=9.5
- fim.
coment coment
- +
”Reprovado” ”Aprovado”
coment fim
Exercícios:
5). Calcular o salário de um funcionário dependendo de quantidade de faltas cometidas durante um mes. No
caso de quantidade de faltas ultrapassassem 5 o salário é descontado em 3%, se a quantidade de faltas
ultrapassasse 10 o salário é descontado em 10% e se a quantidade de faltas ultrapassasse 15 visualizar uma
mensagem: “Está suspenso!”
6). Entre dois valores diferentes introduzidos determinar qual é o maior.
início Pseudo código:

início
ler (x, y);
x, y
se x > y então
coment “o 1º valor introduzido é o maior”
- + coment “1º é senão
x >y
o maior” coment “o 2º valor introduzido é o maior”;
coment -“2º é fim.
o maior”
coment
fim
7). Entre dois valores introduzidos determinar o maior (prever a situação de valores serem iguais).
Pseudo código:
início
início
ler (x, y);
x, y se x = y então
coment “Os valores introduzidos são iguais”
senão
+ x=y + coment “são se x > y então
iguais”
coment “o 1º valor introduzido é o maior”
-
senão
coment “2º é o - + coment “1º é o coment “o 2º valor introduzido é o maior”;
x>y
maior” maior” visualizar (coment);
fim.
coment
fim
3
8). Entre três valores diferentes (não iguais entre si) determinar o menor.
Início Pseudo código:

início
ler (x, y, z);
x, y, z
se x>y então
se x>z então
- + + coment “o 1º valor é o maior”
x>y
senão
+ - - + coment “o 3º valor é o maior”
y>z x>z
senão
se y>z então
coment “o 2º valor é o maior”
coment “2º é coment “3º é coment “1º é
senão
o maior” o maior” o maior”
coment “o 3º valor é o maior”;
fim.
coment
fim
Exercícios:
9). Entre três valores diferentes introduzidos determinar o menor.
Fluxograma repetitivo. Uso de contador de repetições.
10). Supomos que pretende-se modificar o algoritmo do ex.1) de forma a permitir o processamento de salário
de mais do que um trabalhador. Neste caso temos que no fim do algoritmo anterior perguntar se utilizador
pretende introduzir dados sobre outro trabalhador. No caso “sim” devemos voltar para o bloco de leitura de
dados, no caso “não”, terminar.
início
início
cont 0
taxaHora, horasTrab
taxaHora horasTrab
sal taxaHora x horasTrab sal taxaHora x horasTrab
sal sal
cont cont + 1
Continuar: +
- Continuar: +
fim
-
cont
fim-
Caso pretender saber o número de vezes que os dados dos outros trabalhadores foram introduzidos, temos
que adicionar mais uma variável. Esta variável (chamamos por contador) será inicializada com o valor zero
(cont ← 0) e na medida que os dados serão introduzidos, o contador vai incrementar em 1 (cont+1).
Exercício:
11). Modificar o ex.4 de modo a permitir calcular e visualizar as quantidades dos alunos aprovados,
dispensados e excluídos de uma turma de 80 alunos.
4
Teste da condição é feito no fim. Início
12). Visualizar no ecrã 100 vezes seu nome

cont 0
Inicio
contador 0;
fazer (ou repetir) Visualizar
visualizar (“Antonio”); “Antonio”
contador contador+1;
enquanto contador < 100;
cont cont+1
fim.
ou
+
cont
contador 1; (inicializado com 1 e não com 0)
fazer -
visualizar (“Antonio”); fim
contador contador+1;
enquanto contador <= 100;
Teste da condição é feito no início.
Início
13). O exercício anterior pode ser resolvido de outra maneira:
Inicio cont 0
contador 0;
enquanto contador < 100 fazer
inicio - +
cont
visualizar “Antonio”;
contador contador+1; +
fim
Visualizar
fim. “Antonio”
cont cont+1
fim
14). Ler do teclado 200 números inteiros (positivos e negativos) e determinar a quantidade de números
negativos.
Soma dos primeiros 50 números Naturais: início

15) Somar 1+2+3+4+. . . +50
cont 1;
Inicio soma 0
contador 1;
soma soma+cont
soma 0;
cont cont+1
fazer
soma soma+contador; (soma é acumulador)
contador contador+1; sim
cont <=50
enquanto contador<=50;
visualizar (soma);
fim. vsualizar
(soma)
fim
Exercícios:
16) Fazer o mesmo, mas com teste de condição no inicio.
17) Achar o produto dos primeiros N números ímpares (2 variantes: testando a condição no inicio e no fim).
18) Veja o ex.1). Modifique-o para poder calcular o salário mensal (são 22 dias) dum trabalhador.
5
Programas e algoritmos
Um algoritmo, escrito de modo a poder ser executado por um computador, tem o nome de programa. Uma
grande parte do curso é dedicada ao desenvolvimento de algoritmos, e à sua codificação utilizando uma
linguagem de programação (Turbo Pascal, por exemplo).
A constituição de um programa é semelhante à de uma receita. Ao escrevemos um programa, começamos por
descrevermos, numa linguagem apropriada, um algoritmo que efectua a manipulação desses objectos.
Nos nossos programas, iremos manipular valores de variáveis. As variáveis vão-se comportar de um modo
análogo aos ingredientes da receita. Tipicamente, o computador começará por receber certos valores para
algumas das variáveis, após o que efectuará operações sobre essas variáveis, possivelmente atribuindo
valores a novas variáveis e, finalmente, chegara ao conjunto de valores que constituem o resultado do
programa.
Abordagem do topo para a base
Uma das maiores dificuldades relacionadas com o desenvolvimento de programas complicados é o controle da
sua complexidade, ou seja, o modo de limitar o nível de detalhe que temos que considerar em determinado
instante. Um método largamente difundido para limitar a complexidade de um problema é chamado top-down
design (abordagem do topo para base). Ao desenvolver a solução de um problema utilizando o top-down
design, começamos por dividir esse problema em outros mais simples.
PROGRAMAÇÃO EM JAVA
Nossa tarefa não só aprender a Java, mas também melhorar sua habilidade no uso de computador como
ferramenta para solução de problemas. Este processo, geralmente chamado de programação, é composto de
duas tarefas:
• formular um procedimento logicamente coreto e sem ambiguidades, para resolver um dado problema;
• traduzir tal procedimento para uma forma aceitável pelo computador.
“Um programa de computador é, antes de mais nada, um solucionador de problemas”. Um modelo de solução
de problemas inclui sete passos a seguir:
1. Deixar claro o problema.
2. Identificar as entradas e saídas.
3. Desenvolver um procedimento para a solução do problema.
4. Verificar manualmente o procedimento e corrigi-lo, se necessário.
5. Codificar o algoritmo numa linguagem de programação(LP).
6. Executar o programa com dados de teste, depurando (processo de detectar e remover erros - debugging)
quando necessário.
7. Refinar e documentar o programa.
Observamos antes, que a programação consiste em duas tarefas: desenvolvimento de algoritmos e
codificação.
Um algoritmo é uma série de passos usados para resolver um problema. Você produz um algoritmo por meio
de uma analise sistemática do problema. O algoritmo é expresso em uma linguagem chamada pseudocódigo,
que é parecida com uma LP, mas que evita detalhes excessivos (semelhante ao inglês). Em seguida, você
codifica, ou seja, traduz o algoritmo para linguagem que computador entenda (Pascal, Fortran ou outra). Para
isso você deve reduzi-lo a uma sequência de operações primitivas.
19). Criar um programa que escreva no ecrã a frase “Ola!!! Como está?”
public class Ola
{ public static void main(String args[])
{ System.out.println("Ola!!! Como está?"); //escreve Ola!!!
}
}
O processo de escrita, compilação e execução de um programa através de linha de comando de MS-DOS:
• Escrever o programa em Java utilizando para isso um qualquer processador de texto;
• Salvar o programa num ficheiro com extensão .java e com nome igual ao nome do programa;
• A partir de prompt do MS-DOS (antes disso, adiciona linha path=c:\j2sdk1.4.2\bin no ficheiro
autoexec.bat, para isso se usa o comando edit c:\>edit autoexec.bat) chamar o compilador de Java
referindo o ficheiro a compilar:
C:\Pratica> javac Ola.java
O compilador compila o código existente no ficheiro. Se não houver erros de sintaxe no código, este
passo resulta na criação de ficheiro contendo a versão do programa em bytecode com extensão .class.
• Executar o programa com o comando:
C:\Pratica> java Ola
Este comando lança o intérprete de Java que traduz as instruções em bytecode para o código binário
do computador que esteja a ser utilizado e promove a respectiva execução.
6
VISUALIZAÇÃO NO ECRÃ
20). Utiliza o ambiente do Gel. Pretende-se escrever a frase “Tres...dois...um zero...Ola!!!” com cada
palavra em nova linha
public class TresDoisUm
{ System.out.println("Tres...");
System.out.println("Dois...");
System.out.println("Um...");
System.out.println("Zero...");
System.out.println("Ola!!!");
}
}
Pode-se fazer o mesmo utilizando uma única instrução System.out.println e parâmetros \n e \t
public class TresDoisUmPoema
{ System.out.println("Tres...\n\tDois...\n\t\tUm...\n\t\t\tZero...\nOla!!!");
}
}
21) Codifique em Java o pseudocódigo do primeiro exercício feito nas aulas práticas (sobre o cálculo
do salário dum trabalhador). Compile e execute.
public class SalUmTrab
{ public static void main (String args[])
{ //Declaração de constante
final byte TAXA_HORA = 30;
//Declaração de variáveis
byte horasTrab;
float salario;
//Lê horas trabalhadas
System.out.println("Intr. a quantidade de horas trabalhadas ");
horasTrab = Le.umByte();
//Calcula salario
salario = horasTrab * TAXA_HORA;
//Mostra salario calculado
System.out.println("O salario do trabalhador = "+ salario+ ",00 Mt." +
" que corresponde a " + horasTrab + " hora(s) trabalhadas");
}
}
22).Ao chegar a cantina, o cliente dirige-se ao computador para encomendar a sua refeição. Surge-lhe o
seguinte menu:
MENU
Hamburger 12 Mt.
CheeseBurger 14.5 Mt.
Batatas fritas 5 Mt.
Sumo 3.5 Mt.
De seguida tem que responder a um conjunto de perguntas para indicar as quantidades que deseja:
Hamburger ?
CheeseBurger ?
Batatas fritas ?
Sumo ?
Finalmente surge-lhe no ecrã a seguinte mensagem:
Hamburger CheeseBurg Batatas fr Sumo A pagar
2 0 1 2 36.0
Elabore um programa para simular o funcionamento destas operações.
public class Hamburger_tab//Cap3,ex.4, A.Mendes
{ //Declaração de CONSTANTES
final double P_HAM=12.0, P_CHEESE=14.5, P_BAT=5.0, P_SUMO=3.5;
//Declaração de variáveis
byte ham,cheese,bat,sumo;
double total;
//Visualização do Menu
System.out.println ("**** MENU ****");
System.out.println ("Hamburger "+P_HAM+" Mt.");
System.out.println ("CheeseBurger "+P_CHEESE+" Mt.");
System.out.println ("Batatas fritas "+P_BAT+" Mt.");
7
System.out.println ("Sumo "+P_SUMO+" Mt.");

//Leitura de quantidades
System.out.println();
System.out.println ("**** Escolha as quantidades ****");
System.out.println ("Hamburger ? ");
ham = Le.umByte();
System.out.println ("CheeseBurger ? ");
cheese = Le.umByte ();
System.out.println ("Batatas fritas ? ");
bat = Le.umByte ();
System.out.println ("Sumo ? ");
sumo = Le.umByte ();
//Calculo de total a pagar
total = ham*P_HAM+cheese*P_CHEESE+bat*P_BAT+sumo*P_SUMO;
System.out.println ("\n**** Para pagar ****");
System.out.println("Hamburger\t"+"CheeseBurg\t"+"Batatas fr\t "+"Sumo \t"+"A pagar");
System.out.println(ham+"\t\t"+cheese+"\t\t"+bat+"\t\t"+sumo+"\t"+total+"Mt.");
}
}
DIVISÃO DE INTEIROS
23) Separar os dígitos de um número de 4 algarismos, lido do teclado.
O algarismo das unidades do número pode ser obtido calculando o resto da divisão do número por 10. Por
exemplo, se o número for 1234, o resto da divisão 1234 % 10 = 4. Mas esta operação apenas obtém o valor do
dígito das unidades. Para conseguir separar o algarismo das unidades, o número tem que ser dividido por 10.
Por exemplo, 1234 / 10 = 123 (divisão inteira).
public class SeparaDigitos //separaçao começa da direita
{ public static void main(String[] args)
{ System.out.println("Intr. um numero inteiro: ");
int n = Le.umInt();
System.out.print("Os digitos de numero "+n+" sao: ");
System.out.print(n%10); //visualiza 4
n /= 10; // que corresponde a n = n / 10 //n←123
System.out.print(", " + n%10); //visualiza 3
n /= 10; //n←12
System.out.print(", " + n%10); //visualiza 2
n /= 10; //n←1
System.out.println(", e " + n); //visualiza 1
}
}
24) Determine o menor número de notas e moedas a devolver de troco para uma compra até 50 Mt.
Considere o valor da compra como um número inteiro.
public class TrocosDe50 //Cap3,ex.5
{ // Declaração de variáveis
int compra, troco,
n_notas20,n_moedas10,n_moedas5,n_moedas2,n_moedas1,
troco20,troco10,troco5,troco2;
// Lê compra
System.out.println("Valor da compra = ");
compra = Le.umInt();
// Calcula o troco
troco = 50 - compra;
// Calcula número de notas de 20 meticais
n_notas20 = troco / 20;
// Calcula o troco que resta
troco20 = troco % 20;
// Calcula o número demoedas de 10 meticais no troco que restou
n_moedas10 = troco20 / 10;
troco10 = troco20 % 10;
// Calcula o número de moedas de 5 meticais
troco5 = troco10 % 5;
// Calcula o número de moedas de 2 meticais
// Calcula o troco que resta que é igual
// a quant. de moedas de 1 meticais
n_moedas1 = troco5 % 2;
8
// Mostra número de notas e moedas

System.out.println ("O troco = "+troco+"Mt.");
System.out.println ("Numero de notas de 20 = "+n_notas20);
System.out.println ("Numero de moedas de 10= "+n_moedas10);
System.out.println ("Numero de moedas de 5 = "+n_moedas5);
System.out.println ("O menor numero de notas e moedas a devolver troco = "+
(n_notas20+ n_moedas10+n_moedas5+n_moedas2+n_moedas1));
}
}
INSTRUÇÃO if SIMPLES
25). Ler dois valores inteiros, efectuar a adição e apresentar o seu resultado caso o valor somado seja
maior que 10.
public class MaiorDe10
{ int x,y;
long res;
System.out.println("Introduza o 1-o numero: ");
x = Le.umInt();
System.out.println("Introduza o 2-o numero: ");
y = Le.umInt();
res = x + y;
if (res > 10)
System.out.println("A soma entre "+x+" e "+y+" = "+res+" > 10");
}
}
INSTRUÇÃO if-else
26). Recebendo do teclado os valores das três notas de testes calcular a média final e visualizar o
comentário sobre o aluno (aprovado/ reprovado) acompanhado pela nota media arredondada.
public class AprovadoReprovado
{ float nota1,nota2,nota3;
double media;
System.out.println("Introduza 1a nota do teste: ");
nota1 = Le.umFloat();
media = (nota1+nota2+nota3)/3;
if (media>=9.5)
System.out.println("O aluno e Aprovado com a media "+Math.round(media));
else
System.out.println("O aluno e Reprovado com a media "+Math.round(media));
}
}
INSTRUÇÕES if-else ENCADEADAS
27). Determinar o tipo de bilhete que cada visitante de um parque em relação a idade introduzida
public class Bilhetes
{ byte idade;
System.out.println("Intr. a idade de visitante: ");
idade = Le.umByte();
if (idade <= 5)
System.out.println("Isento de pagamento");
else
if (idade <= 12)
System.out.println("Bilhete de crianca");
else
if (idade <= 65)
System.out.println("Bilhete normal");
else
System.out.println("Bilhete de 3a idade");
}
}
TESTES MÚLTIPLOS
28). Entre três valores decimais introduzidos determinar o maior.
9
public class MaiorDosTres

{ double v1,v2,v3,maior;
System.out.println("Introduza 1o valor: ");
v1 = Le.umDouble();
v2 = Le.umDouble();
v3 = Le.umDouble();
if (v1 > v2 && v1 > v))
maior = v1;
else
if (v2 > v3)
maior = v2;
else
maior = v3;
System.out.println("O valor maior =" + maior);
}
}
29). Recebendo os coeficientes a,b e c de uma equação do 2o grão na forma ax2+bx+c=0 calcular e
visualizar as raízes, caso existam. (p.71)
public class EqQuadratica
{ double a,b,c;
System.out.println("Intr.o valor de a: ");
a = Le.umInt();
System.out.println("Intr.o valor de b: ");
b = Le.umInt();
System.out.println("Intr.o valor de c: ");
c = Le.umInt();
if (a == 0)
System.out.println ("no caso de A=0 a raiz e unica, X = B:C = "+(-b/c));
else
if (b == 0)
System.out.println ("no caso de B=0 X1="+Math.sqrt(-c/a)+ " e X2="+
(-Math.sqrt(-c/a)));
else
if (c == 0)
System.out.println ("no caso de C=0 X1=0 e X2="+(-b/a));
else
{ double d = b*b - 4*a*c;
if (d < 0)
System.out.println ("N.T.S.");
else
if (d == 0)
System.out.println ("Delta=0,a raiz é unica X= "+(-b/(2*a)));
else
{ double x1 = (-b+Math.sqrt(d))/(2*a);
double x2 = (-b-Math.sqrt(d))/(2*a);
System.out.println ("Para A="+a+" B="+b+" e C="+c+" as raizes sao:");
System.out.println ("X1= "+x1+" , "+"X2= "+x2);
}
}
}
}
INSTRUÇÃO switch – case
30).introduzindo um numero correspondente a um mês visualizar o nome do mês introduzido
public class MesCase
{ byte mes;
System.out.println ("Introduza o mes (1-12): ");
mes = Le.umByte();
switch (mes)
{ case 1: System.out.println ("Voce escolheu o mes de Janeiro!"); break;
case 2: System.out.println ("Voce escolheu o mes de Fevereiro!"); break;
case 3: System.out.println ("Voce escolheu o mes de Marco!"); break;
. . .
case 12: System.out.println ("Voce escolheu o mes de Dezembro!"); break;
default : System.out.println ("Mes invalido! ");
10
}
}
}
INSTRUÇÃO while
31). Recebendo um qualquer número positivo, devolver a soma dos seus dígitos. Por exemplo, se o
inteiro fornecido for 1234, o programa deverá devolver 10 (1+2+3+4).
Algoritmo: Para conseguir somar os dígitos, é necessário separá-los. Como o número de dígitos não é
conhecido, não é possível saber quantas vezes a operação de separação terá que ser realizada. Desta forma,
o processo de separação terá que ser repetido enquanto houver dígitos para somar (está é a condição).
Ler o número para a variável num
Inicializar a variável soma com zero
Enquanto num > 0 faz
digito = num % 10 (separa um dos dígitos e guarda na variável digito)
num = num / 10 (elimina o algarismo das unidades)
soma = soma + digito
Fim_Enquanto
Escrever o valor de soma
Em Java:
public class SomaDigitos //separa da direita
{ int num, digito, temp, soma = 0;
System.out.println("Intr. um numero maior que zero:");
num = Le.umInt();
temp = num;
while (num > 0)
{ digito = num % 10;
num = num / 10;
soma = soma + digito;
}
System.out.println("A soma dos digitos de "+temp+" = "+soma);
}
}
VALIDAÇÃO
No problema da soma dos dígitos, verificou-se que a solução não funcionava bem se o utilizador fornecesse
um número negativo em vez de um número positivo. Para evitar que o programa produza resultados
incorrectos, é conveniente verificar se o número fornecido está dentro da gama pretendida e, no caso negativo,
pedir ao utilizador que introduza um novo número. O algoritmo seguinte traduz este processo:
Pedir o número ao utilizador
Ler o número para a variável num
Se num < 0
Dá uma mensagem indicando que o número é incorrecto
Fim_Se
Se o número for incorrecto, deve repetir as instruções anteriores
Em Java:
public class SomaDigitosComValidacao
{ int num, digito, temp, soma = 0;
do //ciclo de validação
{ System.out.println("Intr. um numero maior que zero:");
num = Le.umInt();
temp = num;
if (num < 0)
System.out.println("Numero é negativo!");
} while (num < 0);
while (num > 0)
{ digito = num % 10;
num = num / 10;
soma = soma + digito;
}
System.out.println("A soma dos digitos de numero "+temp+" = "+soma);
}
}
32).ex 30 modificar acrescentando a validação
public class MesSwitchComValidacao
{ byte mes;
11
String m = ""; //inicialização

do
{ System.out.println ("Introduza o mes (1-12): ");
mes = Le.umByte();
if (mes < 1 || mes > 12)
System.out.println ("Mes invalido!");
} while (mes < 1 || mes > 12);
switch (mes)
{ case 1: m = "Janeiro"; break;
case 2: m = "Fevereiro"; break;
case 3: m = "Marco"; break;
. . .
case 12: m = "Dezembro"; break;
default : System.out.println ("Mes invalido!");
}
System.out.println ("Voce escolheu o mes de "+ m);
}
}
CICLO for
33) Calcular o factorial de um numero natural introduzido pelo utilizador.
public class For_Factorial
{ public static void main (String args [])
{ int num, temp;
long fact;
do
{ System.out.println("Intr.um numero natural positivo maior ou igual a zero: ");
num = Le.umInt();
temp = num;
if (num < 0)
System.out.println("Numero e incorrecto!");
} while (num < 0);
for (fact=1; num >=1; num--)

fact *= num;
System.out.println("Factorial de "+temp+ "="+ fact);
}
}
34). Lendo as alturas dos alunos de uma turma de 20 alunos, determinar quantos são baixos (menos
1,55m), de altura média (entre 1,55m e 1,70m) e altos (mais de 1,70m).
public class For_AltosBaixos
{ float altura;
int altos = 0, medios = 0, baixos = 0; //Inicialização dos contadores
// Para toda a turma

for (int i= 1; i <= 20; i++)
{ do //ciclo de validação
{ System.out.print("Altura do "+i+"-o aluno? ");
altura = Le.umFloat();
if (altura > 2.0)
System.out.println ("Altura > 2 metros! intr outra");
if (altura < 1.0)
System.out.println ("Altura < 1 metro! intr outra");
} while (altura < 1.0 || altura > 2.0);
if (altura > 1.7) // Determina se aluno é alto, médio ou baixo

altos ++;
else
if (altura > 1.55)
medios ++;
else
baixos ++;
}
System.out.println("Número de alunos altos = "+ altos);
System.out.println("Número de alunos médios = "+ medios);
System.out.println("Número de alunos baixos = "+ baixos);
}
}
12
DOIS CICLOS for

35) Desenhar um triangulo na forma seguinte: *
public class ForForTriangulo * *
{ public static void main (String args []) * * *
{ final int MAX_LINHAS = 5; * * * *
for ( int linha = 1; linha <= MAX_LINHAS; linha++) * * * * *
{ for ( int z = 1; z <= linha; z++)
System.out.print ("* ");
}
}
}
36) Escrever os numeros na forma seguinte: 1
public class ForForNumeros 1 2
{ public static void main (String args []) 1 2 3
{ for ( int m = 1; m <= 4; m++) 1 2 3 4
{ for ( int k = 1; k <= m; k++) 1 2 3
System.out.print (k+" "); 1 2
System.out.println(); 1
}
for (int m = 3; m >= 1; m--)
{ for (int k = 1; k <= m; k++)
System.out.print(k+" ");
}
}
}
MODULARIZAÇÃO. PASSAGEM DE PARÂMETROS
37) Considere o ex.34 e escreve o programa separando em método a parte de cálculo do factorial
public class Factorial_Param
{ int valor = lerNumValidar();
System.out.println("Factorial de "+valor+ "="+ fact(valor));
}
public static int lerNumValidar()
{ int num;
do
{ System.out.println("Intr. numero natural positivo maior ou igual a zero: ");
num = Le.umInt();
if (num < 0)
} while (num < 0);
return num;
}
public static long fact(int n)
{ long f=1;
for (int k = n; k >0; k--)
f *= k;
return f;
}
}
38) Considere o ex.28 e escreve o programa dividido em métodos e com validação de input
public class Maior3_Par_comValidar
{ double v1 = validar (1); //passa para o método o valor 1
double v2 = validar (2); //passa para o método o valor 2
double v3 = validar (3); //passa para o método o valor 3
System.out.println("Entre:"+v1+", "+v2+" e "+v3+" o val.maior= "+ maior(v1,v2,v3));
}
public static double validar (int i)
{ double x;
do
{ System.out.println("Intr.o "+i+"-o numero positivo: ");
x = Le.umDouble();
if (x < 0)
} while (x < 0);
return x;
}
13
public static double maior (double a, double b, double c)

{ if (a > b && a > c)
return a;
else
if (b > c)
return b;
else
return c;
}
}
39) Achar a soma de N primeiros números naturais
public class SomaNaturais_Par_For
{ int quant = lerQuantValidar();
System.out.println("Total = " + calcSoma(quant));
}
public static int lerQuantValidar()
{ int q;
do
{ System.out.println("Intr. a quant. de numeros a somar: ");
q = Le.umInt();
if (q < 0)
System.out.println("Quantidade e incorrecta!");
} while (q < 0);
return q;
}
public static long calcSoma (int n)
{ long soma = 0;
for (int i = 1; i <= n; i++)
soma += i;
return soma;
}
}
40) Achar o produto de N números quaisquer introduzidos pelo utilizador
public class ProdutoN
{ int q = validarQuant();
visualProd(q);
}
public static int validarQuant()
{ int quant;
do
{ System.out.println("Intr. a quant. de numeros que pretende multiplicar: ");
quant = Le.umInt();
if (quant < 0)
System.out.println("Quantidade incorrecta! Tente de novo!");
} while (quant < 0);
return quant;
}
public static double calcularProd(int n)
{ double num, prod = 1.0;
for (int i = 1; i <= n; i++)
{ System.out.println("Intr. o proximo numero a multiplicar: ");
num = Le.umDouble();
prod *= num;
}
return prod;
}
public static void visualProd(int k)
{ System.out.println ("O produto de "+k+" numeros ="+ calcularProd(k)); }
}
41) Considere o ex.26 e modifique dividindo em métodos com passagem de parâmetros
public class AltosBaixos_Par
{ contar(); }
public static void contar()
{ int altos = 0, medios = 0, baixos = 0; double altura;
14
for (byte i= 1; i <= 20; i++)

{ altura = validar(i);
if (altura > 1.7)
altos ++;
else
if (altura > 1.55)
medios ++;
else
baixos ++;
}
visualizar (altos,baixos,medios); //chamada do método visualizar com 3 parâmetros
}
public static double validar(byte k)
{ double alt;
do
{ System.out.print("Altura do "+k+"-o aluno ? ");
alt = Le.umDouble();
System.out.println(alt); //para visualizar o valor lido
if (alt > 2.0)
System.out.println ("Valor de altura > 2 metros!Introduza outro valor!");
if (alt < 1.0)
System.out.println ("Valor de altura < 1 metro! Introduza outro valor!");
} while (alt < 1.0 || alt > 2.0);
return alt;
}
public static void visualizar (int a, int m, int b)
{ System.out.println("Número de alunos altos = "+ a);
System.out.println("Número de alunos medios = "+ m);
System.out.println("Número de alunos baixos = "+ b);
}
}
42) Recebendo do teclado os valores das três notas de testes de um aluno calcular a média final e
visualizar o comentário sobre o aluno (apr/repr/disp) acompanhado pela nota media arredondada.
public class AdmReprDisp_1Aluno
{ float nota1 = lerValidarUmaNota();
float nota2 = lerValidarUmaNota();
float nota3 = lerValidarUmaNota();
calcular (nota1,nota2,nota3);
}
public static float lerValidarUmaNota ()
{ float umaNota;
do
{ System.out.println("Intr. a nota: ");
umaNota = Le.umFloat();
if (umaNota<0 || umaNota>20)
System.out.println("Nota introduzida e invalida!");
} while (umaNota<0 || umaNota>20);
return umaNota;
}
public static void calcular (float n1,float n2,float n3)
{ float media = (n1+n2+n3)/3;
if (media>=14.5)
System.out.println("Dispensado com a media "+Math.round(media));
else
if (media < 9.5)
System.out.println("Reprovado com a media "+Math.round(media));
else
System.out.println("Admitido com a media "+Math.round(media));
}
}
43) Modifique o ex. anterior para uma turma de N alunos

public class AdmReprDisp_Nalunos
{ int n = lerQuantValidarQuant();
decidir (n);
}
15
public static int lerQuantValidarQuant()

{ int quant;
do
{ System.out.print("Introduza a quantidade de alunos: ");
quant=Le.umInt();
System.out.println(quant);
if (quant <= 0)
System.out.println("a quantidade nao é valida");
} while(quant <= 0);
return quant;
}
public static float lerValidarUmaNota (int k)
{ float umaNota;
do
{ System.out.print("\tnota do "+k+"-o teste: ");
umaNota = Le.umFloat();
System.out.println(umaNota);
if (umaNota<0 || umaNota>20)
System.out.println("Nota introduzida e invalida!");
} while (umaNota<0 || umaNota>20);
return umaNota;
}
public static int calcular ()
{ float n1, n2, n3; int media;
n1 = lerValidarUmaNota(1);
media = Math.round((n1+n2+n3)/3);
return media;
}
public static void decidir (int q)
{ int m;
for (int i = 1; i <= q; i++)
{ System.out.println("Introduza as notas do "+i+" aluno:");
m = calcular ();
if (m >= 14.5)
System.out.println("Dispensado com a media "+m);
else
if (m < 9.5)
System.out.println("Reprovado com a media "+m);
else
System.out.println("Admitido com a media "+m);
}
}
}
ARRAY UNIDIMENSIONAL. ARRAY PASSADO COMO PARÂMETRO
44).Armazenar os dados sobre os códigos e preços de N livros. Achar o valor total de preços. Visualizar
no ecrã todos os dados armazenados na forma de duas colunas.
public class ArrayParamCodPrecoLivros
{ int quant = lerQuantValid();
int codigos[] = new int [quant];
float precos[] = new float[quant]; //ou int codigos[] = lerCodigos(quant);
codigos = lerCodigos(quant); // float precos[] = lerPrecos(quant);
precos = lerPrecos(quant);
System.out.println ("O valor total dos precos=" + calcSoma(precos));
visualDados(codigos,precos);
}
public static int lerQuantValid()
{ int q;
do
{ System.out.print("Intr. a quantidade de livros que deseja introduzir: ");
q = Le.umInt();
System.out.println(q);
if (q <= 0)
System.out.println("A quantidade introduzida é invalida!");
} while (q <= 0);
return q;
}
16
public static int[] lerCodigos(int k)

{ int cod[] = new int [k];
System.out.println("Introduza dados sobre "+k+" livros:");
for (int n = 0; n < k; n++)
{ System.out.println ("Introduza o codigo do "+(n+1)+"-o livro: ");
cod[n] = Le.umInt();
}
return cod;
}
public static float[] lerPrecos(int z)
{ float preco[] = new float[z];
System.out.println("Introduza precos de "+z+" livros:");
for (int n = 0; n < z; n++)
{ System.out.println ("Introduza o preco do "+(n+1)+"-o livro: ");
preco[n] = Le.umFloat();
}
return preco;
}
public static float calcSoma (float pr[])
{ float soma = 0;
for (int a = 0; a < pr.length; a++)
soma = soma + pr[a];
return soma;
}
public static void visualDados (int c[], float p[])
{ System.out.println ("Codigo\tPreco");
for (int b = 0; b < c.length; b++)
System.out.println (c[b]+"\t"+p[b]);
}
}
45).Contar a quantidade de números pares e impares num array de N elementos.
public class ArrayPassParamContParImparMENU
{ menu(); }
public static void menu()
{ int op;
byte quant = leQuantValida();
int valores[] = new int [quant];
do // Repete até escolher opção 4 (sair)
{ do
{ System.out.println ("\n1 - Armazenar valores num array");
System.out.println ("2 - Visualizar os valores armazenados");
System.out.println ("3 - Visualizar as quantidades de numeros pares e impares");
System.out.println ("4 - Sair");
System.out.print("Qual é a tua opção? ");
op = Le.umInt ();
System.out.println ("\tEscolheu opcao "+ op+"\n");
} while (op < 1 || op > 4);
switch (op)
{ case 1: valores = gerirArmazenar(quant);
System.out.println("Os "+quant+" valores foram armazenados com sucesso!");
break;
case 2: System.out.println("Estes sao valores armazenados no array:");
visualValores (valores);
break;
case 3: contarParImpares (valores);
break;
}
} while (op != 4);
}
public static byte leQuantValida()
{ byte x;
do
{ System.out.println("Quantos valores pretende armazenar? ");
x = Le.umByte();
if (x <= 0)
System.out.println("Quantidade incorrecta!");
} while (x <= 0);
17
return x;
}
public static int[] gerirArmazenar(byte q)
{ int val[] = new int [q]; //declaracao local da referencia
for (byte i=0; i < q; i++)
val[i] = (int)(Math.random()*100); //gere numeros aleatorios e armazena no array
return val;
}
public static void visualValores(int v[]) //recebe refer. ao array
{ for (byte k=0; k < v.length; k++)
System.out.print(v[k]+", ");
}
public static void contarParImpares (int x[])
{ byte contPar = 0, contImpar = 0;
for (byte j=0; j < x.length; j++)
if (x[j] % 2 == 0)
contPar++;
else
contImpar++;
System.out.println("na lista de "+x.length+" valores existem "+contPar+
" num.pares e "+contImpar+" num.impares");
}
}
47). Num array substituir todos os valores negativos pelos zeros e contar a quantidade de
substituições. Visualizar o array inicial e final.
public class ArrayPassParamSubstNegativos
{ public static void main (String []args)
{ int q = validarN();
int num[] = lerArmazenar(q);
System.out.println("Antes de substituir:");
visualizar(num);
System.out.println("a quantidade de substituicoes feitas= "+ substContar (num));
System.out.println("Depois de substituir:");
visualizar(num);
}
public static int validarN()
{ int quant;
do
{ System.out.println("introduza a quantidade");
quant=Le.umInt();
if(quant <= 0)
System.out.println("A quantidade nao e valida");
} while(quant <= 0);
return quant;
}
public static int[] lerArmazenar(int qua)
{ int z[]=new int [qua];
for (int i = 0; i < qua; i++)
{ System.out.println("introduza o"+(i+1)+"-o numero: ");
z[i]=Le.umInt();
}
return z;
}
public static int substContar(int x[])
{ for( int i = 0, cont = 0; i < x.length; i++)
if (x[i] < 0)
{ x[i]=0;
cont++;
}
return cont;
}
public static void visualizar(int y[])
{ for(int i=0;i<y.length;i++)
System.out.print (y[i] + ", ");
}
}
18
48).Multiplicar dois arrays de comprimento igual, criando um novo 3-o array. Conteúdo do 1-o são
números naturais: 1,2,3,.... Conteúdo do 2-o são múltiplos de 5.
public class ArrayParamMultArrays
{ int quant = lerQuantValidar();
int [] lista1,lista2,lista3 = new int [quant];
lista1 = criarAr1(quant);
lista2 = criarAr2(quant);
lista3 = multiplicar(lista1,lista2);
visualArray (lista1,1);
}
public static int lerQuantValidar()
{ int quant;
do
{ System.out.print("Introduza a quantidade de elementos pretendida: ");
quant=Le.umInt();
if (quant<=0)
System.out.println("a quantidade nao e valida");
} while(quant<=0);
return quant;
}
public static int[] criarAr1 (int q)
{ int v1[] = new int [q];
for (int i=0; i < q; i++)

v1[i] = i+1;
return v1;
}
public static int[] criarAr2 (int k)
{ int v2[] = new int [k];
for (int j=0; j < k; j++)
v2[j] = 5*(j+1);
return v2;
}
public static int[] multiplicar (int x[],int y[])
{ int v3[] = new int [y.length];
for (int z=0; z < v3.length; z++)
v3[z] = x[z]*y[z];
return v3;
}
public static void visualArray(int a[], int n)
{ System.out.println("Estes sao valores armazenados no "+n+"o array:");
for (int j=0; j < a.length; j++)
System.out.print(a[j]+", ");
}
}
49). Ler do teclado N caracteres e armazenar num array. Visualizar no ecrã o array criado e array
ordenado na ordem alfabética.
public class ArrayParamOrdenarChar
{ System.out.println("Quantos caracteres pretende introduzir: ");
int quant = Le.umInt();
char car[] = new char [quant];
car = introdCaract(quant);
System.out.println ("Conteudo do array antes de ordenacao: ");
visualLista(car);
ordenacao (car);
System.out.println ("Conteudo do array depois de ordenacao: ");
visualLista(car);
}
public static char[] introdCaract(int quan)
{ char x[] = new char [quan];
for (int i = 0; i < quan; i++)
{ System.out.print("Introduza o "+(i+1)+"-o caracter: ");
19
x[i] = Le.umChar();
System.out.println(x[i]);
}
return x;
}
public static void visualLista(char z[])
{ for (int j=0; j < z.length; j++)
System.out.print(z[j]+" ");
}
public static void ordenacao (char x[])
{ for (int i = 0; i < x.length-1;i++)
trocaElementos(x,i,indiceMin(x, i, x.length-1));
}
public static void trocaElementos(char m[], int a, int b)
{ char aux = m[a];
m[a] = m[b];
m[b] = aux;
}
public static int indiceMin(char w[], int inicio, int fim)
{ int i_menor = inicio;
for (int k = inicio+1; k <= fim; k++)
if (w[i_menor] > w[k])
i_menor = k;
return i_menor;
}
}
CLASSES E OBJECTOS
50). Numa turma de N (<30) rapazes e meninas pretende-se saber qual é o mais alto de cada sexo.
Elabore a classe Aluno, com a informação que considerar necessária, para utilizar num programa que
determine o pretendido.
public class AlunoR_M
{ // Atributos
private char sexo; // Sexo do aluno
private double altura; // Altura do aluno
// Construtor , equivale a validacao de sexo
public AlunoR_M ()
{ sexo = validarS();
altura = validarAlt();
}
private char validarS()
{ char s;
do
{ System.out.print("Sexo? ");
s = Le.umChar();
System.out.println (s);
} while (s != 'M' && s != 'm' && s != 'F' && s != 'f');
return s;
}
private double validarAlt()
{ double alt;
do
{ System.out.print("Altura? ");
alt = Le.umDouble();
System.out.println (altura);
} while (alt < 0.0 || alt > 2.5);
return alt;
}
// Devolve o sexo do aluno
public char getSexo ()
{ return sexo; }
// Devolve a altura do aluno
public double getAltura ()
{ return altura; }
}
------------------------------------------------
20
public class AlunoR_M_acharMaisAlto

{ int quant = lerValidarQuantAlunos();
determMaisAlto(quant);
}
public static int lerValidarQuantAlunos()
{ int num;
do
{ System.out.print("Numero de alunos da turma = ");
num = Le.umInt();
System.out.println(num);
if (num < 1) System.out.println ("Numero de alunos tem que ser positivo.");
if (num > 30) System.out.println ("Numero de alunos tem que ser <= a 30");
} while (num < 1 || num > 30);
return num;
}
public static void determMaisAlto(int n)
{ double rapaz_mais_alto = 0; //inicializaçao das var. para o valor maior
double menina_mais_alta = 0;
// Para a turma
for (int i = 1 ; i <= n ; i++)
{ System.out.println (i+"-o aluno: ");
AlunoR_M aluno = new AlunoR_M (); // cria objecto aluno
if (aluno.getSexo() == 'M' || aluno.getSexo() == 'm') //procura de rapaz mais alto
{ if (aluno.getAltura() > rapaz_mais_alto)
rapaz_mais_alto = aluno.getAltura();
}
else
if (aluno.getAltura() > menina_mais_alta) // procura de menina mais alta
menina_mais_alta = aluno.getAltura();
}
visualizar(rapaz_mais_alto,menina_mais_alta);
}
public static void visualizar (double altMaxR,double altMaxM)
{ System.out.print("O rapaz mais alto mede "+altMaxR+"m");
System.out.println(" e a menina mais alta mede "+altMaxM+"m");
}
}
CLASSE String e CLASSE StringTokenizer
51). Lendo um nome completo composto por 3 ou mais palavras (por ex. Ana Maria Jose Pinto) devolve,
o 1o e o ultimo nome completo e o resto dos nomes abreviados (Ana M.J. Pinto)
import java.util.*;
public class TestarStringTokenizer
{ int conta, i=0;
System.out.println("Introduza o nome desejado");
String nome = Le.umaString();
StringTokenizer divisor = new StringTokenizer(nome);
cont = divisor.countTokens(); //metodo que faz contagem de partes separadas por espaço
String a[] = new String[cont]; //definiçao de um array de Stringues
while (divisor.hasMoreTokens())
{ a[i] = divisor.nextToken(); //armazena um nome no array
i++;
}
System.out.print(a[0] + " ");` //visualiza o 1-o elem(nome) inteiro
for(int j = 1; j < (a.length-1); j++)
System.out.print(a[j].charAt(0) + ". "); //visualiza, a partir de 2-o, abreviado
System.out.println(a[cont - 1]); //visualiza o ultimo elem.(apelido) inteiro
}
}
52) Contar a quantidade de vogais numa cadeia de caracteres
public class ContarVogais
{ String str = "Programar aprende-se programando";
int count = 0;
for (int i=0; i<str.length(); i++)
21
if (str.charAt(i)=='a' || str.charAt(i)=='e' || str.charAt(i)=='i'

|| str.charAt(i)=='o' || str.charAt(i)=='u')
count++;
System.out.println(count);
}
}
53). Converter cadeias de caracteres armazenadas no array de stringues para minúsculas e maiúsculas
public class ArrayStringesMinMaius {
public static void main(String[] args)
{ String anArray[] = {"Olga", "Jose", "Pedro" };
for(int i=0; i < anArray.length; i++)
{ System.out.println("em minusculas: " + anArray[i].toLowerCase());
System.out.println("em maiusculas: " + anArray[i].toUpperCase());
}
}
}
ARRAY DE OBJECTOS
54). Resolver o exercício sobre N Trabalhadores utilizando um array de objectos.
public class Trabalhador
{
. . . //o conteúdo é o mesmo como no exemplo dado na aula teórica
}
------------------------------------------------------------
public class TrabalhadoresTodos
{ //Atributo
private Trabalhador trab[];
//Construtor
public TrabalhadoresTodos()
{ System.out.print("Quantos Trabalhador existem?: ");
int quant = validarQuant();
trab = new Trabalhador[quant];
for (int i = 0; i < quant; i++)
trab[i] = new Trabalhador(); //cria dentro do ciclo os obj. que sao trab.
}
private int validarQuant()
{ int q;
do
{ q = Le.umInt();
if (q <0)
System.out.println("Quantidade negativa!Tente de novo");
} while (q <0);
return q;
}
public float calcIdadeMedia()
{ float soma = 0;
for (int j = 0; j < trab.length; j++)
soma += trab[j].getIdade();
return soma / trab.length;
}
public String toString()
{ String visualizar = "";
for (int k = 0; k < trab.length; k++)
visualizar += trab[k] + "\n"; //.toString() é opcional
return visualizar;
}
}
-------------------------------------------------------
public class TrabalhadoresTest
{ TrabalhadoresTodos tt = new TrabalhadoresTodos();
System.out.println(" Lista de Quadro de pessoal da empresa: ");
System.out.println(tt); //equivale ao tt.toString();
System.out.println(" A idade media de trabalhadores = "+
tt.calcIdadeMedia());
}
}
22
55). Escreve uma aplicação em Java que permita achar a flat do tipo3 cujo aluguer é o mais barato e
que fica no andar não superior a 5º de todos os existentes na base de dados duma imobiliária. Elabore
a classe Flat com a informação sobre o tipo de flat (2-5), andar (1-15) e valor de aluguer em USD (100-
2000). Armazene toda a informação num array de objectos. Visualize no ecrã todos os dados
introduzidos e calculados. Valide todos os dados numéricos criando um único método para isso.
public class Flat
{ private int tipo;
private int andar;
private int precoAlug;
//construtor
public Flat()
{ System.out.println ("Introduza o tipo do flat (2-5): ");
tipo = validar(2,5);
System.out.println ("Introduza o andar(1-15): ");
andar = validar(1,15);
System.out.println ("Introduza o valor de aluguer USD(100-2000): ");
precoAlug = validar(100,2000);
}
private int validar(int a, int b)
{ int x;
do
{ x = Le.umInt();
if (x < a || x > b)
System.out.println("valor invalido!");
} while (x < a || x > b);
return x;
}
public int getTipo() { return tipo; }
public int getPreco() { return precoAlug; }
public int getAndar() { return andar; }
//acumula num String os dados de uma flat
public String toString ()
{ return tipo+"\t"+andar+"\t"+precoAlug; }
}
-------------------------------------------------------
public class FlatTodos
{ //Atributo
private Flat fl[];
//Construtor
public FlatTodos()
{ System.out.print("Quantos flat existem?: ");
int quant = validarQuant();
fl = new Flat[quant];
for (int i = 0; i < quant; i++)
fl[i] = new Flat();
}
private int validarQuant()
{ int q;
do
{ q = Le.umInt();
if (q <0)
System.out.println(" Quantidade negativa!");
} while (q <0);
return q;
}
private int precoAlugBarato()
{ int b=2000, indice=0;
for (int j = 0; j < fl.length; j++)
if (fl[j].getPreco()<b && fl[j].getTipo()==3 && fl[j].getAndar()<5)
{ b = fl[j].getPreco(); //guarda o preco mais barato
indice = j; //guarda o indice do objecto cujo aluger é menor
}
return indice;
}
public String infoFlatEscolhida()
{ int ind = precoAlugBarato();
23
return "tipo: "+fl[ind].getTipo()+",andar: "+fl[ind].getAndar()+",aluguer: "+

fl[ind].getPreco();
}
{ String visualizar = "";
for (int k = 0; k < fl.length; k++)
visualizar += fl[k].toString() + "\n"; //.toString() é opcional
return visualizar;
}
}
---------------------------------------------------
public class FlatTest
{ FlatTodos f = new FlatTodos();
System.out.println(" Lista de flats disponiveis: \n");
System.out.println(f); //equivale ao f.toString()
System.out.println("Info sobre flat tipo3 mais barato no andar < 5º\n"+
f.infoFlatEscolhida());
}
}
USO DE FICHEIRO DE TIPO TEXTO
56) Escreva num ficheiro 10 linhas com números de 1 a 10 em cada linha
import java.io.*;
public class EscreverNoFichNumerosEmLinhas
{ public static void main (String args[]) throws IOException
{ final int MAX = 10;
String nomeFich = "numeros10.txt";
int umNumero;
FileWriter fw = new FileWriter(nomeFich);
BufferedWriter fichOut = new BufferedWriter(fw);
for (int linha = 1; linha <= MAX; linha++)
{ for (int i = 1; i <= MAX; i++)
fichOut.write(i + " "); //faz conversao automaticamente
fichOut.newLine(); //muda de linha
}
fichOut.close();
System.out.println ("O ficheiro de saida foi criado com nome "+nomeFich);
}
}
57) Ler do ficheiro com o nome DadosIn.txt dados sobre inventário de N peças (nome, quant. e preço)
e armazenar num array de objectos. Calcular quantidade total de peças. Visualizar no ecrã o conteúdo
do array.
DadosIn.txt ParafusoA4 140 3.56
Prego3x255 120 0.48
Tubo20x355 199 1.09
Bracadeira 207 8.98
import java.text.DecimalFormat;
public class PecaInventario
{ private String nome;
private int quant;
private float preco;
private DecimalFormat moeda;
//construtor que inicializa os atributos atrvés de passagem de parâmetros
public PecaInventario (String nomePeca, int q, float pr)
{ nome = nomePeca;
quant = q;
preco = pr;
moeda = new DecimalFormat ("###,###.00 Mt");
}
public String toString ()
{ return nome + "\t" + quant + " de preco " + moeda.format(preco); }
}
-------------------------------------------------------------
import java.util.StringTokenizer;
import java.io.*;
public class PecasInventTodas
{ private PecaInventario listaPecas[];
24
private int max, cont;

private long totalQuant;
public PecasInventTodas()
{ max = 10;
listaPecas = new PecaInventario[max];
cont = 0;
totalQuant = 0;
}
public void lerDoFich()
{ StringTokenizer umaCadeia; //uma porcao de informacao a ser dividia por Str.Tokenizer
String umaLinha, nom, nomeFich = "DadosIn.txt";
int qua;
float pre;
try
{ FileReader fread = new FileReader (nomeFich);
BufferedReader inFile = new BufferedReader (fread);
umaLinha = inFile.readLine();
while (umaLinha != null)
{ umaCadeia = new StringTokenizer (umaLinha);
nom = umaCadeia.nextToken(); //extrai o nome
qua = Integer.parseInt(umaCadeia.nextToken()); //extrai e converta a quant.
pre = Float.parseFloat(umaCadeia.nextToken()); //extrai e converta o preco
criaArray(nom,qua,pre); //armazena no array de obj
umaLinha = inFile.readLine();
} //fim do ciclo while
inFile.close();
} //fim do try-catch
catch (FileNotFoundException exception)
{ System.out.println("Ficheiro "+ nomeFich + " nao encontrado!"); }
catch (IOException exception)
{ System.out.println(exception); }
}
private void criaArray (String nomeP, int quan, float prec)
{ listaPecas[cont] = new PecaInventario (nomeP,quan,prec);
totalQuant += quan;
cont++;
}
{ String vis = "Quant. de pecas no ficheiro de invent.: "+ cont + "\n";
for (int n = 0; n < cont; n++)
vis += listaPecas[n] + "\n"; //.toString() é opcional
vis += "Quantidade total das pecas = " + totalQuant + "\n";
return vis;
}
}
----------------------------------------------------------------
import java.io.*;
public class PecasInventarioTest
{ PecasInventTodas lista = new PecasInventTodas();
lista.lerDoFich();
System.out.println (lista); //visualisa o conteudo do array de objectos
} //referenciado pelo lista
}
Quant. de pecas no ficheiro de invent.: 4
ParafusoA4 140 de preco 3.56 Mt
Prego3x255 120 de preco 0.48 Mt
Tubo20x355 199 de preco 1.09 Mt
Bracadeira 207 de preco 8.98 Mt
Quantidade total das pecas = 666
ARRAY BIDIMENSIONAL
58) Achar a soma de valores da N- ma coluna, escolhida pelo utilizador num array X x Y
public class Array2SomaColunaNarrayXY
{ System.out.print (" Quantas linhas pretende: ");
byte linhas = validar();
System.out.print (" Quantas colunas pretende: ");
25
byte colunas = validar();

float tabela[][] = criarArray(linhas, colunas);
visualArray(tabela);
byte numColSoma = pergNumCol(colunas); //pergunta utilizador o num. da coluna
byte numColReal = (byte) (numColSoma - 1); //calcula o num. da coluna para Java
System.out.println("Soma da "+numColSoma+"-a coluna = "+
somaColunaN(tabela,numColReal));
}
public static byte validar()
{ byte x;
do
{ x = Le.umByte();
System.out.println (x);
if (x < 0)
System.out.println("valor invalido!");
} while (x < 0);
return x;
}
public static float[][] criarArray (byte l,byte c)
{ float x[][] = new float [l][c];
for(byte i = 0; i < l; i++)
for(byte j = 0; j < c; j++)
{ System.out.print("Intr. o "+(i+1)+","+(j+1)+" valor=");
x[i][j] = Le.umFloat();
System.out.println(x[i][j]);
}
return x;
}
public static void visualArray(float y[][])
{ for (byte i=0; i < y.length; i++) //visualiza na forma de tabela
{ for (byte j=0; j < y[0].length; j++)
System.out.print(y[i][j]+" ");
}
}
public static byte pergNumCol(byte nCol) //recebe a quant-de de colunas existente
{ byte nc=0;
do
{ System.out.print("Soma de que coluna pretende? ");
nc = Le.umByte(); System.out.println(nc);
if (nc < 0 || nc > nCol)
System.out.println("Num. de coluna invalida, deve ser entre 1 e "+nCol);
} while (nc < 0 || nc > nCol);
return nc;
}
public static float somaColunaN(float y[][], byte nColSomar)
{ float soma = 0;
for (int i = 0; i < y.length; i++)
soma = soma + y[i][nColSomar];
return soma;
}
}
APPLETS
59). Programar a visualiação no ecrã do desenho de casa com a escrita de coordenadas
import java.awt.*; //E.Koffman, pag.154
import java.applet.Applet; (x2,y2)
public class ApplDesenharCasa extends Applet

{ //os 4 coordenadas: para telhado e rectângulo - casa
(x1,y1) (x3,y3)
int x1 = 100; int y1 = 200;
int x2 = 300; int y2 = 100;
int x3 = 500; int y3 = 200; (x5,y5)
int x4 = 500; int y4 = 400;
//canto esquerdo superior para a porta
int x5 = 275; int y5 = 325; (x4,y4)
//canto direito inferior para a porta (x6,y6)
int x6 = 325; int y6 = 400;
26
public void paint (Graphics g)

{ setBackground (Color.lightGray);
//Desenhando o telhado
g.setColor (Color.red);
g.drawLine (x1,y1,x2,y2);
g.drawLine (x2,y2,x3,y3);
//Desenhando a casa como rectângulo //Alternativa para fig.preenchidas:
g.setColor (Color.yellow);
g.drawRect (x1,y1,x4-x1,y4-y1); // ou g.fillRect(x1,y1,x4-x1,y4-y1);
//Desenhsndo a porta // ou g.setColor(Color.red);
g.drawRect (x5, y5, x6 - x5, y6 - y5); // ou g.fillRect(x5,y5,x6-x5,y6-y5);
//Escrevendo as coordenadas
g.setColor(Color.black);
g.drawString("(x1,y1)", x1, y1);
}
}
60) Programar a visualização no ecrã do desenho “Happy Face”
import java.awt.*; //E.Koffman, pag.157
import java.applet.Applet;
public class ApplHappyFace extends Applet
{ int maxX = 500; int maxY = 400; //dimensions da janela
// centro de cabeça e o raio de cabeça
int headX = maxX / 2; int headY = maxY / 2;
int headRadius = maxY / 4;
// posiçao dos olhos e raio dos olhos
int leftEyeX = headX - headRadius / 4;
int rightEyeX = headX + headRadius / 4;
int eyeY = headY - headRadius / 4;
int eyeRadius = headRadius / 10;
// posiçao de nariz e raio de nariz
int noseX = headX; int noseY = headY + headRadius / 4;
int noseRadius = eyeRadius;
// raio do sorriso
int smileRadius = (int) Math.round(0.75 * headRadius);
{ g.setColor(Color.black); // Desenho de cabeça.
g.drawOval(headX-headRadius,headY-headRadius,2*headRadius,2*headRadius);
g.setColor(Color.blue); // Desenho do olho esquerdo.
g.fillOval(leftEyeX-eyeRadius,eyeY-eyeRadius,2*eyeRadius,2*eyeRadius);
g.setColor(Color.blue); // Desenho do olho direito.
g.fillOval(rightEyeX-eyeRadius,eyeY-eyeRadius,2*eyeRadius,2*eyeRadius);
g.setColor(Color.yellow); // Desenho de nariz
g.fillOval(noseX-noseRadius,noseY-noseRadius,2*noseRadius,2*noseRadius);
g.setColor(Color.red); // Desenho de sorriso
g.drawArc(headX-smileRadius,headY-smileRadius,2*smileRadius,2*smileRadius, 210, 120);
} (x-r,y-r)
}
Para desenhar um segmento do circulo preenchido:
g.fillArc(x-r, y-r, 2*r, 20,30);
61) É possível criar um applet que acrescenta algo ao applet já existente. (x,y)
import java.awt.*;
public class ApplPirata extends ApplHappyFace (x+r,y+r)
{ public void paint (Graphics g)
{ super.paint(g); // Draw a happy face
//Add an eye patch.
g.fillArc(headX - smileRadius, headY - smileRadius,
2 * smileRadius, 2 * smileRadius, 20, 50);
27
g.drawString("Sou pirata", headX - headRadius, maxY - 20);

}
}
62) Desenho de Happy Face com animação (sorriso feliz – triste)
import java.awt.*;
public class ApplAnimHappyFace extends Applet
{ int maxX = 500; int maxY = 400;
int headX = maxX / 2; int headY = maxY / 2;
int headRadius = maxY / 4;
int leftEyeX = headX - headRadius / 4;
int rightEyeX = headX + headRadius / 4;
int eyeY = headY - headRadius / 4;
int eyeRadius = headRadius / 10;
int noseX = headX; int noseY = headY + headRadius / 4;
int noseRadius = eyeRadius;
int smileRadius = (int) Math.round(0.75 * headRadius);
{ int i = 0;
while (i < 50) {
// Draw head
g.drawOval(headX-headRadius,headY-headRadius,2*headRadius,2*headRadius);
// Draw left eye
g.setColor(Color.blue);
g.fillOval(leftEyeX-eyeRadius,eyeY-eyeRadius,2*eyeRadius,2*eyeRadius);
// Draw right eye.
g.setColor(Color.blue);
g.fillOval(rightEyeX-eyeRadius,eyeY-eyeRadius,2*eyeRadius,2*eyeRadius);
// Draw nose.
g.setColor(Color.yellow);
g.fillOval(noseX-noseRadius,noseY-noseRadius,2*noseRadius,2*noseRadius);
if (i % 2 == 0)
{ g.setColor(Color.red);
g.drawArc(headX-smileRadius,headY+smileRadius*3/4,
2*smileRadius,2*smileRadius,50,80);
g.drawString( " E S T O U T R I S T E ! ! !",50,50);
}
else
{ g.setColor(Color.red);
g.drawArc(headX-smileRadius,headY-smileRadius,
2*smileRadius,2*smileRadius,210,120);
g.drawString( " E S T O U F E L I Z ! ! !",50,50);
}
i++;
try
{ Thread.sleep(1200);
} catch (Exception e) {}
g.clearRect(0, 0, getSize().width, getSize().height);
}
}
}
63) Desenho de Snowman com animação (mãos, sorriso e frase)
import java.awt.*; //*
public class ApplAnimSnowman extends Applet
{ public void paint (Graphics g)
{ final int MID = 150;
final int TOP = 50;
setBackground(Color.cyan);
int i = 1;
while (i<=50) //em vez de while (true)
{ g.setColor(Color.blue);
g.fillRect(0,175,300,50);
g.setColor(Color.yellow);
28
g.fillOval(-40,-40,80,80);
g.setColor(Color.white);
g.fillOval(MID-20,TOP,40,40);
g.fillOval(MID-35,TOP+35,70,50);
g.fillOval(MID+5,TOP+10,5,5);
if (i % 2 == 0)
{ g.drawArc(MID-10,TOP+20,20,10,180,180);
g.drawLine(MID-25,TOP+60,MID-50,TOP+40);
g.drawLine(MID+25,TOP+60,MID+55,TOP+60);
g.drawString("Ta frio!Que bom!",5,55);
}
else
{ g.drawArc(MID-10,TOP+20,20,10,0,180);
g.drawLine(MID-25,TOP+60,MID-50,TOP+60);
g.drawLine(MID+25,TOP+60,MID+55,TOP+40);
g.drawString("Esta calor! Vou derreter!",5,55);
}
i++;
g.drawLine(MID-20,TOP+5,MID+20,TOP+5);
g.fillRect(MID-15,TOP-20,30,25);
try
{ Thread.sleep(500);
g.clearRect(0, 0, getSize().width, getSize().height);
}
}
}
64). Rectângulo em movimento
import java.awt.*; //Cap6.2 Deitel
import java.applet.*;
public class ApplAnimRectMoveHoriz extends Applet
{ final int COMPRIMENTO = 30;
final int LARGURA = 20;
final int DX = 10;
{ int maxX = getSize().width; // Obtém dimensões do Applet
int maxY = getSize().height;
int x = 0;
boolean direcao = true;
while (true) { // Ciclo nunca termina
g.setColor (Color.black);
g.fillRect(x, (maxY-LARGURA)/2, COMPRIMENTO, LARGURA); // Desenha rectângulo
try // Espera
{ Thread.sleep (300);
g.clearRect(x, (maxY-LARGURA)/2, COMPRIMENTO, LARGURA); // Apaga rectângulo
if (direcao) // Verifica se chegou aos limites do Applet
{ x = x + DX;
if ((x + COMPRIMENTO) > maxX) // Sim, inverte deslocamento
{ x = x - DX;
direcao = false;
}
}
else // Sim, inverte deslocamento
{ x = x - DX;
if (x < 0)
{ x = x + DX;
direcao = true;
}
}
}
}
}
29

Algoritmos e fluxogramas

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Algoritmos e fluxogramas

Загружено:

Авторское право:

Доступные форматы

Eng.

Inf, 1ano Aulas Páticas Programação e Algoritmos 1

num Pseudo código:

Compara as duas variantes de fluxograma. Qual é a diferença entre eles?

início Pseudo código:

Início Pseudo código:

sal taxaHora x horasTrab sal taxaHora x horasTrab

Teste da condição é feito no fim. Início

12). Visualizar no ecrã 100 vezes seu nome

Soma dos primeiros 50 números Naturais: início

System.out.println ("Sumo "+P_SUMO+" Mt.");

// Mostra número de notas e moedas

public class MaiorDosTres

String m = ""; //inicialização

for (fact=1; num >=1; num--)

// Para toda a turma

if (altura > 1.7) // Determina se aluno é alto, médio ou baixo

DOIS CICLOS for

public static double maior (double a, double b, double c)

for (byte i= 1; i <= 20; i++)

43) Modifique o ex. anterior para uma turma de N alunos

public static int lerQuantValidarQuant()

public static int[] lerCodigos(int k)

for (int i=0; i < q; i++)

public class AlunoR_M_acharMaisAlto

if (str.charAt(i)=='a' || str.charAt(i)=='e' || str.charAt(i)=='i'

return "tipo: "+fl[ind].getTipo()+",andar: "+fl[ind].getAndar()+",aluguer: "+

private int max, cont;

byte colunas = validar();

public class ApplDesenharCasa extends Applet

public void paint (Graphics g)

g.drawString("Sou pirata", headX - headRadius, maxY - 20);

Вам также может понравиться