Exercicios PDF

06/11/2017 Exercicios
4th June 2012 Exercicios
Prática 1 – Introdução
Objetivo:
Conhecer o ambiente das aulas práticas
Primeiro contato com a IDE NetBeans
Escrever, compilar e executar programas em Java
Parte 1: Torres de Hanói

O problema das Torres de Hanói é objeto de estudo de disciplinas avançadas da área de Computação. Concebido em
1883 pelo matemático francês Edouard Lucas, consiste de um quebracabeças matemático composto por conjunto de
discos de diferentes diâmetros que devem ser movidos entre 3 torres até que todos os discos estejam em uma torre
diferente da torre original. Os movimentos devem obedecer 2 regras:
1. Mover apenas um disco por vez.

2. Um disco de diâmetro maior não pode ser colocado sobre um disco de diâmetro menor.
Segundo a lenda, o jogo foi inspirado numa versão “real” existente em um mosteiro em Hanói. Neste
mosteiro, monges ocupam-se da tarefa de mover 64 discos de ouro entre 3 torres de marfim.
Quando eles conseguirem mover todos os discos para a torre de destino o universo deixará de
existir.
a) Suponha que você conta com um agente (computador) que irá auxiliá-lo na execução da tarefa de resolver o
problema com 4 discos. Utilizando apenas o comando MOVER(origem, destino) estabeleça uma sequência de
operações para resolver o problema das Torres de Hanói com 4 discos.
b) Para um jogo com n discos, o menor número de movimentos possível é dado pela fórmula: T = 2n – 1
Qual é o menor número possível de movimentos necessários para resolver o problema dos monges? Se os movimentos
forem realizados à razão de um por segundo, quanto tempo levará para resolver o problema com 64 discos?
a) Resposta em Java:
import javax.swing.JOptionPane;
public class Laboratorio {
public static void main(String[] args) {
int disco;
double movimentos;
disco = Integer.parseInt (JOptionPane.showInputDialog("Digite a quantidade dos discos."));
movimentos = (Math.pow(2, disco)-1);
JOptionPane.showMessageDialog(null, "Quantidade de movimentos: "+movimentos);

System.out.println("Número de discos: "+disco +" >>movimentos: " +movimentos);
}
}
b)Número de discos: 64 >>movimentos: 1.8446744073709552E19
------------------------------------------------------------------------------------------------------
1. Elaborar um algoritmo em Java para calcular e apresentar o valor da expressão aritmética

b + b * c – 4 * c – a, onde a, b e c são números inteiros fornecidos pelo usuário.
Resposta em JAVA:
public class Laboratorio2 {
public static void main (String [] args){
int a,b,c;
a=Integer.parseInt(JOptionPane.showInputDialog("Digite o valor da letra a"));
b=Integer.parseInt(JOptionPane.showInputDialog("Digite o valor da letra b"));
c=Integer.parseInt(JOptionPane.showInputDialog("Digite o valor da letra c"));
JOptionPane.showMessageDialog(null, b+b*c-4*c-a);
}
}
-----------------------------------------------------------------------------
2. Elaborar um algoritmo em Java para transformar em reais um valor em dólares. O algoritmo deverá:
http://exemplosalgoritmo.blogspot.com.br/2012/06/exercicios.html 1/17
a. Pedir para o usuário digitar a cotação do dólar
b. Pedir para o usuário digitar um valor em dólares
c. Converter e apresentar o valor digitado em reais.
Apresente todas as informações em janelas gráficas (JOptionPane.showMessageDialog) .
Resposta em JAVA:
double dolar, real, umDolarEmReal;
umDolarEmReal = Double.parseDouble(JOptionPane.showInputDialog("Quanto esta 1 dolar em real?"));

dolar= Double.parseDouble(JOptionPane.showInputDialog("Qual é o valor do dolar que deseja converter?"));
real = umDolarEmReal*dolar;
JOptionPane.showMessageDialog(null, "$"+ dolar + " = "+"R$"+real);
}
}
--------------------------------------------------------------------------------
Prática 2 – Expressões
1. Objetivo
Trabalhar com entrada e saída de dados em Java
Compilar um programa em Java
Executar um programa em Java
2. Recursos Necessários
Computador com compilador Java instalado
NetBeans
3. Procedimentos
Nesta prática, vamos trabalhar com comandos de atribuição, expressões, entrada e saída de dados.
A) Desenvolva um programa em Java que receba o salário de um funcionário,
calcule e mostre seu novo salário com reajuste de 20%.
Resposta em JAVA:
public class laboratorio1Lab2 {
double salario, reajusteSalario;
salario=Double.parseDouble(JOptionPane.showInputDialog("Digite o valor do salário"));

reajusteSalario=salario*0.2+salario;
JOptionPane.showMessageDialog(null, "Salario Atual: R$"+reajusteSalario);
}
}
----------------------------------------------------------------------------
B) Desenvolva um programa em Java que receba dois valores inteiros para as variáveis x e y,
efetue a troca dos valores, ou seja, x passa a ter o valor de y e y passa a ter o valor de x e mostre os valores trocados.
Resposta em JAVA:
public class laboratorio2 {
int x,y,guardax, guarday;

x=Integer.parseInt(JOptionPane.showInputDialog("Digite o valor do x"));
y=Integer.parseInt(JOptionPane.showInputDialog("Digite o valor do y"));
System.out.println("x,y");
System.out.println(x+","+y);
guardax=x;
guarday=y;
y=guardax;
x=guarday;
System.out.println(x+","+y);
}
}
-------------------------------------------------------------------------------
C) Desenvolva um programa em Java que receba uma temperatura em graus Celsius (C),
calcule e mostre a temperatura convertida para graus Fahrenheit (F).

Fórmula de conversão: F = (9 x C + 160) / 5.
Apresente todas as informações em janelas gráficas (JOptionPane.showMessageDialog) .
Resposta em JAVA:
public class laboratorio3 {
Double fahreneit, celsius;
celsius=Double.parseDouble(JOptionPane.showInputDialog("Digite a temperatura em Fahreneit"));

fahreneit = (9*celsius+160)/5;
JOptionPane.showMessageDialog(null, celsius + "C° = " + fahreneit + "F°");

}
}
-----------------------------------------------------------------------------
Prática 3 – Estruturas de decisão: if - else
1. Procedimentos
Nesta prática, vamos trabalhar com comandos de decisão (if e if / else).
A) Elaborar um algoritmo (pseudocódigo e código em Java) para:
Ler o sexo e a altura (h) de uma pessoa
Calcular e apresentar seu peso (massa) ideal dada por:
o Homens: (72.7 * h) – 58
o Mulheres: (62.1 * h) – 44.7
Resposta em JAVA:
import javax.swing.*;
char sexo;
double altura, pesoIdeal;
sexo = JOptionPane.showInputDialog("Qual é o sexo?").toUpperCase().charAt(0);
if (sexo=='H' || sexo=='M'){
altura = Double.parseDouble(JOptionPane.showInputDialog("Digite a altura"));
if(sexo=='M'){
pesoIdeal = (72.7 * altura)-58;

}else{
pesoIdeal = (62.1 * altura) -44.7;

}
JOptionPane.showMessageDialog(null, "Peso Ideal: " + pesoIdeal + "kg");
}else{
JOptionPane.showMessageDialog(null, "Sexo inválido");
}
}
}
----------------------------------------------------------------------
B) Desenvolva um algoritmo que receba dois valores numéricos reais e mostre o maior entre
esses dois números. Se os números forem iguais o programa deverá apresentar uma mensagem com a informação:
“Os números são iguais.”
Resposta em JAVA:
double n1,n2;
n1=Integer.parseInt(JOptionPane.showInputDialog("Digite o 1°número"));
n2=Integer.parseInt(JOptionPane.showInputDialog("Digite o 2°número"));
if (n1==n2){
JOptionPane.showMessageDialog(null, "Número 1 e número 2 são iguais");
}else{
if(n1>n2){
JOptionPane.showMessageDialog(null, "Número maior :" +n1);
}else{
JOptionPane.showMessageDialog(null, "Número maior: " + n2);
}
}
}
}
------------------------------------------------------------------------------
C) Desenvolva um algoritmo que receba um valor numérico inteiro e mostre na tela se esse valor é par ou ímpar.
Resposta em JAVA:
int n1;
n1=Integer.parseInt(JOptionPane.showInputDialog("Digite um número"));
if (n1/2==0){
JOptionPane.showMessageDialog(null,"Número " + n1+" é par");

}else{
JOptionPane.showMessageDialog(null, "Número " + n1+" é ímpar");

}
}
}
------------------------------------------------------------------------------
D) Desenvolva um algoritmo que receba o ano de nascimento de uma pessoa, calcule e mostre a sua idade.
O programa deverá também verificar se essa pessoa já tem idade para votar (16 anos ou mais)
e se tem idade para obter a Carteira Nacional de Habilitação (18 anos ou mais).
Apresentar na tela essas informações.
*Está Faltando(incompleto!)
int anoNascimento, anoAtual, idade;
anoNascimento = Integer.parseInt(JOptionPane.showInputDialog("Qual é o ano de nascimento?"));

anoAtual = Integer.parseInt(JOptionPane.showInputDialog("Qual é o ano atual?"));
idade = anoAtual-anoNascimento;
JOptionPane.showMessageDialog(null, "Você tem ou vai ter "+idade+"anos");

}
}
---------------------------------------------------------------------------
Desafio) Desenvolver um algoritmo que receba três números inteiros e mostre o maior e o menor entre eles.
Resposta em JAVA:
int n1, n2, n3, maior=0, menor=0, meio=0;
n1 = Integer.parseInt(JOptionPane.showInputDialog("Digite 1° número"));
if((n1==n2) && (n2==n3)){
JOptionPane.showMessageDialog(null, "Todos tem mesmos números");

}else{
if(n1>n2){
if(n1>n3){
if(n2>n3){
maior=n1;
meio=n2;
menor=n3;
}else{
maior=n1;
meio=n3;
menor=n2;
}
}else{//n3>n1>n2..
maior=n3;
meio=n1;
menor=n2;
}
}else{//n2>n1
if(n1>n3){
maior=n2;
meio=n1;
menor=n3;
}else{//n2?n3>n1
if(n2>n3){
maior=n2;
meio=n3;
menor=n1;
}else{
maior=n3;
meio=n2;
menor=n1;
}
}
}
}
JOptionPane.showMessageDialog(null,"Maior: " + maior +"\nMeio: " + meio + "\nMenor: " + menor);
}
}
-------------------------------------------------------------------------------
Prática 4 – Estruturas de decisão de múltipla escolha (switch)
1. Procedimentos
Nesta prática, vamos trabalhar com comandos de decisão múltipla (switch).
A) Desenvolva um algoritmo que receba o valor de dois números inteiros, o símbolo
da operação aritmética desejada, calcule e mostre o resultado da operação aritmética, conforme a tabela abaixo:
Simbolo Operação aritmética
+ Adição
- Subtração
* Multiplicação
/ Divisão
^ Potenciação
m Resto da divisão
Resposta em JAVA:
int n1, n2;

double resultado=0;
char operacao;
boolean teste=true;
n1=Integer.parseInt(JOptionPane.showInputDialog("Digite 1°número"));
n2=Integer.parseInt(JOptionPane.showInputDialog("Digite 2°número"));
operacao = JOptionPane.showInputDialog("Digite: \n+: adição.\n-:Subtração.\n-:Multiplicação.\n/: Divisão.\n^ :Potenciação\nM: Resto

switch(operacao){
case '+':resultado = n1+n2;
break;
case '-':resultado = n1-n2;
break;
case '*':resultado = n1*n2;
break;
case '/':resultado = n1/n2;
break;
case '^':resultado = Math.pow(n1, n2);
break;
case 'M':resultado = n1%n2;
break;
default : teste=false;
break;
if (teste==true){
JOptionPane.showMessageDialog(null, "Resultado: " + resultado);
}else{
JOptionPane.showMessageDialog(null, "Operação inválida");
}
}
}
----------------------------------------------------------------------------
B) Desenvolva um algoritmo que receba a idade de um atleta e mostre a sua classificação em categorias,
conforme a tabela abaixo:
Idade Categoria
3 a 4 anos Mirim
5 a 7 anos Infantil A
8 a 7 anos Infantil B
11 a 13 anos Juvenil A
14 a 17 anos Juvenil B
18 a 50 anos Adulto
Mais de 50 abis Veterano
Observações:
- Apresente todas as informações em janelas gráficas (JOptionPane.showMessageDialog).
- No item B, é permitido o uso da estrutura de decisão if apenas nas faixas de 18 anos ou mais.
Resposta em JAVA:
public class NewClass {
int idade;
String categoria,mensagem="";
idade=Integer.parseInt(JOptionPane.showInputDialog("Digite a idade"));
if (idade <3){
mensagem="Não há categoria para bebê";
}else{
if (idade>50){
mensagem="Categoria: Veterano";
}else{
switch(idade){
case 3: case 4: mensagem="Categoria: Mirim";
break;
case 5: case 7: mensagem="Categoria: Infantil A";
break;
case 8: case 10: mensagem="Categoria: Infantil B";
break;
case 11: case 13: mensagem="Categoria: Juvenil A";
break;
case 14: case 17: mensagem="Categoria: Juvenil B";
break;
case 18: case 50: mensagem="Categoria: Adulto";
break;
}
}
}
JOptionPane.showMessageDialog(null,mensagem);
}
}
-------------------------------------------------------------------------
Prática 5 – Estruturas de Repetição – While

1. Procedimentos
Nesta prática, vamos trabalhar com a estrutura de repetição while do Java.
a) Desenvolva um programa que apresente a diferença entre a soma dos números pares e
a soma dos números ímpares, no intervalo de 1 a 100.
Dicas:
1. Utilize uma variável inteira para controlar a estrutura de repetição. O valor dessa
variável varia de 1 até 100, sendo o limite superior o critério de parada da
repetição.
2. Utilize uma variável para armazenar a soma dos números pares.
3. Utilize uma variável para armazenar a soma dos números ímpares.
Resposta em JAVA:
int par=0, impar=0;

double resultado;
for (int i=1; i<=100; i++){
if(i%2==0){
par +=i;
System.out.println("Par: " + par);
}else{
impar +=i;
System.out.println("Impar" + par);
}
}
resultado = par/impar;
JOptionPane.showMessageDialog(null,par + "/" + impar + "=" + resultado);
}
}
------------------------------------------------------------------------------------------------
b) Desenvolva um programa que receba números inteiros maiores que zero, digitados pelo
usuário até que o valor 0 (zero) seja digitado. O programa deverá determinar e mostrar
quantos valores pares foram digitados. Se o usuário fornecer valores menores que zero,
o programa deverá apresentar uma mensagem de erro e solicitar um novo número.
Resposta em JAVA:
int n1, par=0;
do{
do{
n1 = Integer.parseInt(JOptionPane.showInputDialog("Digite um número inteiro maiores que zero."));
if(n1<0){
JOptionPane.showMessageDialog(null, "Número Inválido!");
}
}while(n1<0);
if(n1%2==0 && n1!=0){
par++;
}
}while(n1!=0);
System.out.println("Teve " + par + " números pares");

}
}
------------------------------------------------------------------------------------------------
b) Desenvolva um programa que receba números inteiros maiores que zero, digitados pelo
usuário até que o valor 0 (zero) seja digitado. O programa deverá determinar e mostrar
quantos valores pares foram digitados. Se o usuário fornecer valores menores que zero,
o programa deverá apresentar uma mensagem de erro e solicitar um novo número.
Desafio) Escreva um aplicativo que exiba o seguinte padrão de um tabuleiro de xadrez:
* * * * * * * * Cada asterisco representa uma casa preta. Cada espaço
* * * * * * * * representa uma casa branca.
********
* * * * * * * *
********
* * * * * * * *
********
* * * * * * * *
Seu programa poderá utilizar apenas uma vez cada uma das três estruturas de saída, conforme
apresentado abaixo:
System.out.print( “* “ ); // Asterisco seguido de um espaço

System.out.print( “ “); // Apenas um espaço
System.out.println( ); // Comando de quebra de linha println
Dica: Será necessário utilizar mais de uma estrutura de repetição para montar a figura.
Resposta em JAVA:
public class NewClass2 {
int estrela=Integer.parseInt(JOptionPane.showInputDialog("Digite a quantidade de estrela desejada."));
for (int a=1; a<=estrela; a++){

if (a%2!=0){
for (int i=0;i<estrela;i++ ){
System.out.print("* ");
}
System.out.println();
}else{
for (int i=0;i<estrela;i++ ){
System.out.print(" *");
}
}
}
}
}
---------------------------------------------------------------------------
Prática 06 – Estruturas de Repetição – do/while e for
1. Procedimentos
Nesta prática, vamos trabalhar com as estruturas de repetição do/while e for do Java.
1ª Parte: do/while
a) Desenvolva um programa que receba números reais digitados pelo usuário.
O procedimento deverá ser repetido enquanto o usuário quiser continuar a fornecer valores.
O usuário deverá digitar ‘S’ ou ‘s’ para continuar ou ‘N’ ou ‘n’ para finalizar e o programa deve aceitar como resposta apenas essas letras.
Se outra letra for digitada, uma mensagem deve ser apresentada para o usuário e uma nova letra deve ser solicitada.
Quando o usuário digitar ‘N’ ou ‘n’, o programa deverá apresentar a média dos valores fornecidos.
Resposta em JAVA:
public class Laboratotio6 {
char saida;
double n1, media, total=0, contador=0;
do{
n1=Double.parseDouble(JOptionPane.showInputDialog("Digite um número"));
total+=n1;
contador++;
do{
saida = JOptionPane.showInputDialog("Digite:\n-N: Para terminar.\n-S: Para continuar.").toUpperCase().charAt(0);
if (!(saida=='N' || saida=='S')){
JOptionPane.showMessageDialog(null, "Letra inválido!");
}
}while(!(saida=='N' || saida=='S'));
}while(saida!='N');
media=total/contador;
JOptionPane.showMessageDialog(null, media);
}
}
----------------------------------------------------------------------------
b) Desenvolva um programa que receba um número N digitado pelo usuário e apresente como resultado
o valor de N!(fatorial N x (N-1) x (N-2) x (N-3) ... x 1).
Resposta em JAVA:


int n1=Integer.parseInt(JOptionPane.showInputDialog("Digite um número"));
int resposta=1;

for(int i=0; i<n1;i++){
resposta *= n1-i;
System.out.println(resposta);
}
JOptionPane.showMessageDialog(null, resposta);
}
}
------------------------------------------------------------------------------------------------------
2ª Parte: for
c) Desenvolva um algoritmo que calcule e mostre o quadrado dos números inteiros pares
compreendidos entre 10 e 150.
Resposta em JAVA:


for (int i=10; i<=150; i++){
if(i%2==0){
System.out.println(i + "*" + i + "=" + i*i);
}
}
}
}
-----------------------------------------------------------------------------------------------
d) Desenvolva um algoritmo que receba dois números inteiros, verifique qual é o maior entre eles,
calcule e mostre a média entre os números ímpares compreendidos entre esses dois números.
Resposta em JAVA:


int n1, n2;
double media;

n1=Integer.parseInt(JOptionPane.showInputDialog("Digite 1° valor."));
n2=Integer.parseInt(JOptionPane.showInputDialog("Digite 2° valor."));

if(n1==n2){
System.out.println("1° e 2° números são iguais: " + n1 + "=" + n2);
}else{
if(n1>n2){
System.out.println("1° número é o maior:" +n1);
}else{
System.out.println("2° número é o maior:" +n2);
}
}

media=n1+n2/2;
System.out.println("Média"+media);
}
}
----------------------------------------------------------------------------------------
Desafio) Escreva algoritmos que utilizem apenas estruturas de repetição for para desenhar na tela
as figuras abaixo:
Primeira figura)
**********
*********
********
*******
******
*****
****
***
**
*
Segunda figura)
*
**
***
****
*****
******
*******
********
*********
**********
Resposta em JAVA:


for (int t=0; t<9;t++){
for(int i=0; i<9-t; i++){
System.out.print("*");
}
}

for (int t=9; t>=0;t--){
for(int i=0; i<9-t; i++){
System.out.print("*");
}
}
}
}
---------------------------------------------------------------------------------------------
Prática 7 – Estrutura de Repetição – FOR

1. Procedimentos
a) Desenvolva um algoritmo para realizar uma pesquisa de intenção de voto para uma eleição
qualquer, considerando dois candidatos que serão informados pelo usuário na inicialização do
programa. Os votos devem ser computados através de códigos, sendo o código 1 para o primeiro
candidato, 2 para o segundo candidato e 0 para Branco/Nulo. O programa deverá apresentar
uma tela para o usuário com as informações de votação, conforme imagem abaixo:
[http://1.bp.blogspot.com/-Cz51JthVYcI/T84-
n2_X85I/AAAAAAAAAfE/Ha4gWuzsw5E/s1600/algoritmo.png]
Obs: devem ser apresentados os nomes dos candidatos (digitados pelo usuário) no lugar do
texto “Nome do primeiro candidato” e “Nome do segundo candidato”.
A cada voto, uma mensagem de confirmação deve ser apresentada ao usuário: “Deseja
confirmar seu voto? (S/N)”. Em caso de confirmação apresentar a mensagem “Voto Confirmado.
Fim”. Caso contrário, apresente a mensagem “Repita seu voto.”.
O algoritmo deve repetir esta operação para vários eleitores, até que o presidente da seção
eleitoral encerre a votação, digitando a senha 999 na tela de votação para computar os votos.
Neste momento, o algoritmo deverá apresentar o nome do candidato, a quantidade de votos que
ele recebeu, a quantidade de votos nulos/brancos e o vencedor da eleição.
Obs: o algoritmo deve validar a entrada do usuário, permitindo apenas a inclusão dos valores
informados nas perguntas.
Respostas em JAVA
String candidato1, candidato2;

int votoCandidato1=0, votoCandidato2=0, voto, nulo=0, senha=0;
char confirma;
boolean saiConfirma;
candidato1=JOptionPane.showInputDialog("Qual é o nome do 1° candidato?");

candidato2=JOptionPane.showInputDialog("Qual é o nome do 2° candidato?");
//1.Repita até colocar a senha

do{
//1.1Repete até confirmar o voto.

do{
//1.1.1.Recebe voto do usuario e verifica se esta entre 0 a 2
do{
voto= Integer.parseInt(JOptionPane.showInputDialog("Escolha uma opçao de voto:"
+ "\n[1]"+candidato1+"\n[2]"+candidato2+"\n[0]Nulo"));
if (!(voto>=0 && voto<3)){

JOptionPane.showMessageDialog(null,"Voto inválido");
}
}while(!(voto>=0 && voto<3));
//1.1.2.Confirma voto
do{
confirma = JOptionPane.showInputDialog("Deseja confirmar o voto?\n[S]Sim\n[N]Não").toUpperCase().charAt(0);
if(!(confirma=='N' || confirma=='S')){
JOptionPane.showMessageDialog(null, "Confirmação inválida!");
}
}while(!(confirma=='N' || confirma=='S'));
if (confirma=='S'){
saiConfirma = true;
JOptionPane.showMessageDialog(null, "Voto confirmado.");
}else{
saiConfirma = false;
JOptionPane.showMessageDialog(null, "Repita seu voto.");
}
}while(saiConfirma==false);
//1.2.Acumula voto do 1.
switch(voto){
case 1: votoCandidato1++;
break;
case 2: votoCandidato2++;
break;
case 0: nulo++;
break;
}
senha = Integer.parseInt(JOptionPane.showInputDialog("Para sair digite a senha.\nPara continuar digite qualquer número"));

}while(senha!=999);
//2.Informa voto
JOptionPane.showMessageDialog(null, candidato1 + ": " + votoCandidato1 + "voto(s)\n"
+candidato1 + ": " + votoCandidato2 + "voto(s)\n"
+"Votos Nulos: " + nulo + "voto(s)\n");
}
}
------------------------------------------------------------------------------
b) Escrever um algoritmo para calcular e apresentar o resultado da seguinte expressão:

Exp = 1 + 1/2 + 1/3 + 1/4 + 1/5 + ... + 1/100
Resolva o exercício utilizando a estrutura de repetição for.
Dica: Será necessário utilizar um acumulador e um contador.
Respostas em JAVA
double total=0;
for(int i=1; i<=100; i++){

System.out.print(total + "+" + 1 + "/" + i + "=");
total=total+1/i;
System.out.println(total);
}
JOptionPane.showMessageDialog(null, total);
System.out.println(1/5);
}
--------------------------------------------------------------------------------
Prática 8 – Vetores
Desenvolva programas em Java para solucionar os seguintes problemas:
1. Desenvolva um algoritmo que armazene num vetor 10 valores numéricos inteiros digitados pelo usuário.
Em seguida, apresente os valores na ordem inversa da entrada.
Respostas em JAVA
int[] n1=new int[10];
for(int i=0; i<=9; i++){

n1[i]=Integer.parseInt (JOptionPane.showInputDialog("Digite um número"));
System.out.print(n1[i]+", ");
}
for(int i=9; i >=0; i--){

System.out.print(n1[i] + ", ");
}
}
}
------------------------------------------------------------------------------
Em seguida, o algoritmo deve solicitar um número para o usuário e apresentar todos os valores armazenados no vetor que sejam menores que est
Respostas em JAVA
public static void main(String [] args){
int [] n1= new int [10];

int n2;
for (int i=0; i<=9; i++){

n1[i]=Integer.parseInt(JOptionPane.showInputDialog("Digite um número"));
}
n2=Integer.parseInt(JOptionPane.showInputDialog("Digite um número para encontrar números menores"));
System.out.println("Números menores que " + n2);
for(int i=0; i<=9; i++){

if(n1[i] < n2){
System.out.println(n1[i]);
}
}
}
}
------------------------------------------------------------------------------
Em seguida, o algoritmo deverá analisar os dados do vetor, determinar e apresentar o maior e o menor dos valores digitados
Respostas em JAVA
int [] n1 = new int [20];

int maior=0, menor=0;
for (int i=0; i<=19; i++){

n1[i]=Integer.parseInt(JOptionPane.showInputDialog("Digite um número"));
}
for(int i=0; i<=19; i++){

if(n1[i]>maior){ //encontra maior
maior = n1[i];
}else{
if(n1[i]<menor){ //encontra menor
menor = n1[i];
}
}
}
System.out.println("Número maior: " + maior + "\nNúmero menor: " + menor);

}
}
----------------------------------------------------------------------------
4. Desenvolva um algoritmo que armazene num vetor 15 valores numéricos reais digitados pelo usuário.
Em seguida, o algoritmo deverá determinar e apresentar a média dos valores pares e a quantidade de valores menores que 10.5 armazenados no v
package laboratorio8;


double [] n1 = new double[15];
double totalPar=0, mediaPar;
int quantiPar=0, quantiMenorDezCinco=0;

//preenche vetor n1
for(int i=0; i<=14; i++){
n1[i] = Double.parseDouble(JOptionPane.showInputDialog("Disgite um numero"));
}

//Verifica: media do par
for (int i=0; i<=14; i++){
if(n1[i]%2==0){
totalPar += n1[i];
quantiPar ++;
}
}
mediaPar = totalPar/quantiPar;
System.out.println("Média dos valores pares: " + mediaPar);

//Verifica: Quantidade do n1<10.5
for (int i=0; i<=14; i++){
if(n1[i]<10.5){
quantiMenorDezCinco++;
}
}
System.out.println("Temos " + quantiMenorDezCinco + " números menores que 10.5");
}
}
------------------------------------------------------------------------------
Prática 9 – Matrizes
Desenvolva programas em Java para solucionar os seguintes problemas:
A) Desenvolva um algoritmo que:

- Armazene valores reais digitados pelo usuário numa matriz de dimensões 2 x 3.
- Crie e armazene numa segunda matriz o dobro dos valores contidos na primeira matriz.
- Apresente na tela os elementos da segunda matriz.
Respostas em JAVA
public static void main(String [] args) {
int [][] n1= new int [2][3];

int [][] n2= new int [2][3];
//Preenche matriz
for (int i=0; i<=1; i++){
for (int n=0; n<=2; n++){ //preenche coluna
n1[i][n] = Integer.parseInt(JOptionPane.showInputDialog("Digite um número"));
}
}
//Dobra matriz
for (int i=0; i<=1; i++){
for (int n=0; n<=2; n++){
n2[i][n] = (n1[i][n]*2);
}
}
System.out.println("Dobro dos valores digitados:");
//Apresenda matriz.
for (int i=0; i<=1; i++){
for (int n=0; n<=2; n++){
System.out.print(n2[i][n] + ",");
}
}
}
}
---------------------------------------------------------------------
B) Desenvolva um algoritmo para o cálculo da média dos alunos de uma turma. O programa deverá:
- Perguntar ao usuário a quantidade de alunos da turma.

- Criar uma matriz com nº de linhas igual à quantidade de alunos e três colunas.
- Para cada aluno:
a) Perguntar ao usuário a nota do aluno no 1º bimestre e armazenar na primeira coluna da linha
correspondente ao aluno na matriz.

b) Perguntar ao usuário a nota do aluno no 2º bimestre e armazenar na segunda coluna da linha

c) Calcular a média aritmética das notas do aluno e armazenar na terceira coluna da linha

- Calcular e mostrar a média geral da turma (a soma de todas as médias dividida pela quantidade de alunos).
- Apresentar as notas e a média de cada aluno, no seguinte formato:
Aluno 1: Nota 1: <nota 1>; Nota 2: <nota 2>; Média: <média>

Aluno 2: Nota 1: <nota 1>; Nota 2: <nota 2>; Média: <média>
...
Aluno N: Nota 1: <nota 1>; Nota 2: <nota 2>; Média: <média>
Exemplo:
Aluno 5: Nota 1: 8; Nota 2: 10; Média: 9
Respostas em JAVA
public class Treinando {

int quantiAluno;
double totalMedia=0, mediaSala;
quantiAluno = Integer.parseInt(JOptionPane.showInputDialog("Digite a quantidade dos alunos"));
double [][] alunos= new double[quantiAluno][3];
//Preenche matriz alunos

for (int i=0; i<=quantiAluno-1; i++){
for (int n=0; n<=2; n++){
if(n!=2){
alunos[i][n]= Double.parseDouble (JOptionPane.showInputDialog("Digite a média do " + (n+1)+"° Bimenstre"));
}else{
//calcula média do aluno
alunos[i][2]= (alunos[i][0]+alunos[i][1])/2;
}
}
}
//Calcula e mostra: Média da turma

for(int i=0; i<=quantiAluno-1; i++){
totalMedia += alunos[i][2];
}
mediaSala = totalMedia/quantiAluno;
System.out.println("Média da sala: "+mediaSala);
//Apresenta: Nota1, Nota2 e Média de cada aluno

for (int i=0; i<=quantiAluno-1; i++){
System.out.print("Aluno" + (i+1) + "-> ");
for (int n=0; n<=2; n++){
if(n!=2){
System.out.print("Nota"+(n+1)+": " + alunos[i][n] + "; ");
}else{
//Mostra média
System.out.print("Média: " + alunos[i][2]);
}
}
}
}
}
------------------------------------------------------------------------------
Prática 10 – Procedimentos
Escrever um algoritmo em Java para executar algumas operações com vetor e matriz.
O programa deve apresentar o seguinte menu para o usuário:
[http://1.bp.blogspot.com/-
xvNNaOAFGLI/T9DpHmtxNFI/AAAAAAAAAfQ/g8e4m1tVh20/s1600/Sem+t%C3%ADtulo.png]
Para cada operação selecionada pelo usuário, desenvolver um procedimento que executa a tarefa.
O método principal deve utilizar os demais procedimentos de acordo com a opção do menu selecionada pelo usuário.
O programa deve ser executado repetidamente até o usuário selecionar a opção SAIR.
Descrição dos procedimentos:
1. O procedimento deve armazenar num vetor X valores numéricos reais digitados pelo usuário, onde X é o número de
elementos do vetor, que também é informado pelo usuário.
Em seguida, percorrer o vetor somando as posições e no final mostrar a média geral dos números.
2. O procedimento deve armazenar num vetor 10 valores numéricos inteiros digitados pelo
usuário. Em seguida, percorrer o vetor somando os números pares e também somando os
números ímpares. Ao final da execução, o procedimento deve apresentar a diferença entre a
soma dos números pares e a soma dos números ímpares.
3. O procedimento deve criar uma matriz de dimensões 2 x 3 e preenchê-la com valores reais.
Em seguida, percorrer a matriz imprimindo os valores armazenados no padrão de matriz, ou
seja, para cada linha apresentar suas colunas.
4. O procedimento deve criar uma matriz de dimensões 3 x 4, preenchê-la com números inteiros
e depois percorrê-la imprimindo a sua matriz transposta. Matriz transposta: linha vira coluna e
coluna vira linha.
Postado há 4th June 2012 por Resuminho
Visualizar comentários

Exercicios PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Exercicios PDF

Enviado por

Direitos autorais:

Formatos disponíveis

06/11/2017 Exercicios

4th June 2012 Exercicios

Parte 1: Torres de Hanói

1. Mover apenas um disco por vez.

public class Laboratorio {

public static void main(String[] args) {

disco = Integer.parseInt (JOptionPane.showInputDialog("Digite a quantidade dos discos."));

movimentos = (Math.pow(2, disco)-1);

JOptionPane.showMessageDialog(null, "Quantidade de movimentos: "+movimentos);

b)Número de discos: 64 >>movimentos: 1.8446744073709552E19

1. Elaborar um algoritmo em Java para calcular e apresentar o valor da expressão aritmética

public class Laboratorio2 {

public static void main (String [] args){

Apresente todas as informações em janelas gráficas (JOptionPane.showMessageDialog) .

public class Laboratorio3 {

public static void main (String [] args){

double dolar, real, umDolarEmReal;

umDolarEmReal = Double.parseDouble(JOptionPane.showInputDialog("Quanto esta 1 dolar em real?"));

A) Desenvolva um programa em Java que receba o salário de um funcionário,

calcule e mostre seu novo salário com reajuste de 20%.

public class laboratorio1Lab2 {

public static void main(String[] args) {

double salario, reajusteSalario;

salario=Double.parseDouble(JOptionPane.showInputDialog("Digite o valor do salário"));

public class laboratorio2 {

public static void main(String[] args) {

int x,y,guardax, guarday;

calcule e mostre a temperatura convertida para graus Fahrenheit (F).

public class laboratorio3 {

public static void main (String [] args){

Double fahreneit, celsius;

celsius=Double.parseDouble(JOptionPane.showInputDialog("Digite a temperatura em Fahreneit"));

JOptionPane.showMessageDialog(null, celsius + "C° = " + fahreneit + "F°");

Prática 3 – Estruturas de decisão: if - else

public class Laboratorio3 {

public static void main(String[] args) {

sexo = JOptionPane.showInputDialog("Qual é o sexo?").toUpperCase().charAt(0);

pesoIdeal = (72.7 * altura)-58;

pesoIdeal = (62.1 * altura) -44.7;

public class Laboratorio4 {

public static void main (String [] args){

public class Laboratorio5 {

public static void main (String [] args){

JOptionPane.showMessageDialog(null,"Número " + n1+" é par");

JOptionPane.showMessageDialog(null, "Número " + n1+" é ímpar");

Apresentar na tela essas informações.

public class Laboratorio6 {

public static void main (String [] args){

int anoNascimento, anoAtual, idade;

anoNascimento = Integer.parseInt(JOptionPane.showInputDialog("Qual é o ano de nascimento?"));

JOptionPane.showMessageDialog(null, "Você tem ou vai ter "+idade+"anos");

public class Laboratorio7 {

public static void main (String [] args){

int n1, n2, n3, maior=0, menor=0, meio=0;

if((n1==n2) && (n2==n3)){

JOptionPane.showMessageDialog(null, "Todos tem mesmos números");

Prática 4 – Estruturas de decisão de múltipla escolha (switch)

Nesta prática, vamos trabalhar com comandos de decisão múltipla (switch).

A) Desenvolva um algoritmo que receba o valor de dois números inteiros, o símbolo

public static void main(String[] args) {

int n1, n2;

operacao = JOptionPane.showInputDialog("Digite: \n+: adição.\n-:Subtração.\n-:Multiplicação.\n/: Divisão.\n^ :Potenciação\nM: Resto

conforme a tabela abaixo: