Você está na página 1de 29

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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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”;
visualizar (coment);
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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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”;
visualizar (coment);
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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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
{ public static void main(String args[])
{ 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
{ public static void main(String args[])
{ 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
{ public static void main (String args[])
{ //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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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
{ public static void main (String args[])
{ // 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;
// Calcula o troco que resta
troco10 = troco20 % 10;
// Calcula o número de moedas de 5 meticais
n_moedas5 = troco10 / 5;
// Calcula o troco que resta
troco5 = troco10 % 5;
// Calcula o número de moedas de 2 meticais
n_moedas2 = troco5 / 2;
// Calcula o troco que resta que é igual
// a quant. de moedas de 1 meticais
n_moedas1 = troco5 % 2;
8
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

// 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 ("Numero de moedas de 2 = "+n_moedas2);
System.out.println ("Numero de moedas de 1 = "+n_moedas1);
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
{ public static void main(String args[])
{ 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
{ public static void main(String args[])
{ float nota1,nota2,nota3;
double media;
System.out.println("Introduza 1a nota do teste: ");
nota1 = Le.umFloat();
System.out.println("Introduza 2a nota do teste: ");
nota2 = Le.umFloat();
System.out.println("Introduza 3a nota do teste: ");
nota3 = 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
{ public static void main(String args[])
{ 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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

public class MaiorDosTres


{ public static void main(String args[])
{ double v1,v2,v3,maior;
System.out.println("Introduza 1o valor: ");
v1 = Le.umDouble();
System.out.println("Introduza 2o valor: ");
v2 = Le.umDouble();
System.out.println("Introduza 3o valor: ");
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
{ public static void main(String args[])
{ 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
{ public static void main (String args[])
{ 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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

}
}
}
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
{ public static void main (String args[])
{ 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
{ public static void main (String args[])
{ 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
{ public static void main (String args[])
{ byte mes;

11
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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
{ public static void main (String args[])
{ 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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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 ("* ");
System.out.println();
}
}
}
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+" ");
System.out.println();
}
}
}
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
{ public static void main (String args [])
{ 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)
System.out.println("Numero e incorrecto!");
} 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
{ public static void main(String args[])
{ 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)
System.out.println("Numero e incorrecto!");
} while (x < 0);
return x;
}
13
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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
{ public static void main (String args [])
{ 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
{ public static void main (String args [])
{ 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
{ public static void main (String args[])
{ contar(); }
public static void contar()
{ int altos = 0, medios = 0, baixos = 0; double altura;

14
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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
{ public static void main(String args[])
{ 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
{ public static void main(String args[])
{ int n = lerQuantValidarQuant();
decidir (n);
}

15
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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);
n2 = lerValidarUmaNota(2);
n3 = lerValidarUmaNota(3);
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
{ public static void main (String args[])
{ 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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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
{ public static void main (String args[])
{ 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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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]+", ");
System.out.println();
}
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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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
{ public static void main (String args[])
{ int quant = lerQuantValidar();
int [] lista1,lista2,lista3 = new int [quant];
lista1 = criarAr1(quant);
lista2 = criarAr2(quant);
lista3 = multiplicar(lista1,lista2);
visualArray (lista1,1);
visualArray (lista2,2);
visualArray (lista3,3);
}
public static int lerQuantValidar()
{ int quant;
do
{ System.out.print("Introduza a quantidade de elementos pretendida: ");
quant=Le.umInt();
System.out.println(quant);
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]+", ");
System.out.println();
}
}
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
{ public static void main (String args[])
{ 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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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]+" ");
System.out.println();
}
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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

public class AlunoR_M_acharMaisAlto


{ public static void main (String args [])
{ 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
{ public static void main(String args[])
{ 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
{ public static void main (String args[])
{ String str = "Programar aprende-se programando";
int count = 0;
for (int i=0; i<str.length(); i++)

21
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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();
System.out.println(quant);
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
{ public static void main (String args [])
{ 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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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();
System.out.println(quant);
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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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


fl[ind].getPreco();
}
public String toString()
{ String visualizar = "";
for (int k = 0; k < fl.length; k++)
visualizar += fl[k].toString() + "\n"; //.toString() é opcional
return visualizar;
}
}
---------------------------------------------------
public class FlatTest
{ public static void main (String args [])
{ FlatTodos f = new FlatTodos();
System.out.println(" Lista de flats disponiveis: \n");
System.out.println(f); //equivale ao f.toString()
System.out.println();
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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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++;
}
public String toString()
{ 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
{ public static void main (String args[])
{ 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
{ public static void main (String args [])
{ System.out.print (" Quantas linhas pretende: ");
byte linhas = validar();
System.out.print (" Quantas colunas pretende: ");
25
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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]+" ");
System.out.println();
}
}
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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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);
g.drawString("(x2,y2)", x2, y2);
g.drawString("(x3,y3)", x3, y3);
g.drawString("(x4,y4)", x4, y4);
g.drawString("(x5,y5)", x5, y5);
g.drawString("(x6,y6)", x6, y6);
}
}
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);
public void paint (Graphics g)
{ 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.setColor(Color.black);
g.fillArc(headX - smileRadius, headY - smileRadius,
2 * smileRadius, 2 * smileRadius, 20, 50);
27
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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


}
}
62) Desenho de Happy Face com animação (sorriso feliz – triste)
import java.awt.*;
import java.applet.Applet;
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);
public void paint (Graphics g)
{ int i = 0;
while (i < 50) {
g.setColor(Color.black);
// 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.*; //*
import java.applet.Applet;
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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007
Eng.Inf, 1ano Aulas Páticas Programação e Algoritmos 1

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-50,TOP+80,100,60);
g.setColor(Color.black);
g.fillOval(MID-10,TOP+10,5,5);
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);
} catch (Exception e) {}
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;
public void paint (Graphics g)
{ 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);
} catch (Exception e) {}
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
Elab. por engª Tatiana Kovalenko Fev-Jun 2007