REVISÃO 1-Comandos Básicos Estrutura de Dados I

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

/**********************************************/
/* Revisão 1 - Comandos Básicos */
/**********************************************/
/******************************************************/
/* CURSO: Bach. Sistemas de Informação */
/* SEMESTRE: 2º semestre TURNO: Matutino	 */
/******************************************************/
/*********************************************************************************************/
/* Implementar cada um dos Exercícios abaixo. Preste atenção nos comandos utilizados. */
/*********************************************************************************************/
/******************************************************************/
/* PROGRAMAS USANDO COMANDOS BÁSICOS e o comando System.out.print */
/******************************************************************/
/***************************/
/* Exercício 0 -HelloWorld */
/***************************/
package helloworld;
import java.util.Scanner;
public class HelloWorld {
 public static void main(String[] args) {
 Scanner userInputScanner = new Scanner(System.in); // Entrada de dados do teclado
 System.out.print ("Qual é o seu nome? ");
 String userInputName = userInputScanner.nextLine(); // Vai ser lido do tipo String nalinha de baixo
 System.out.print ("Olá " + userInputName +"!");
 } 
}
/***********************************************/
/* Exercício 1 - Planejamento de aposentadoria */
/***********************************************/
package aposentadoria;
import java.util.Scanner;
public class Aposentadoria {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 double alvo, juros, contribuicao, saldo = 0;
 int anos = 0;
 
 System.out.print("Com quanto dinheiro você quer se aposentar: ");
 alvo = sc.nextDouble();
 System.out.print("Quanto dinheiro você vai contribuir o ano todo: ");
 contribuicao = sc.nextDouble();
 System.out.print("Taxa de juros em % (Exemplo: Digite 7.5 para 7.5%): ");
 juros = sc.nextDouble() / 100;
 
 while (saldo < alvo){ /* While é o Comando Enquanto */
 saldo = (saldo + contribuicao) * (1 + juros); /* Fómula do cálculo da Aposentadoria */
 anos++;
 }
 System.out.println("Voce pode se aposentar em " + anos + " anos.");
 } 
}
/************************************************************************************/
/* Exercício 2 - Programa que lê a base e a altura e calcula a área de um triângulo */
/* através da fórmula: */
/* AREA = (BASE * ALTURA) / 2 */
/* a = área ; b = base; h = altura */
/************************************************************************************/
package areatriangulo;
import java.util.Scanner;
public class AreaTriangulo {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 double a, b, h;
 
 System.out.print("Digite o valor da base: ");
 b = sc.nextDouble(); // b = base
 System.out.print("Digite o valor da altura: ");
 h = sc.nextDouble(); // h = altura
 
 a = (b * h)/2;
 System.out.println("Área = " + a);
 } 
}
/*********************************************************************************/
/* Exercício 3 -Programa que leia o salário de um funcionário, calcula e exibe o */
/* novo salário, sabendo que este sofreu um aumento de 25%. */
/*********************************************************************************/
/* 25% = 25 / 100 = 0.25 */
/* A fórmula utilizada será: aumento = salario + (salario * 0.25) */
/*********************************************************************************/
package aumentosalario;
import java.util.Scanner;
public class AumentoSalario {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 double salario, aumento;
 
 System.out.print("Digite o salário atual: ");
 salario = sc.nextDouble();
 aumento = salario + (salario * 0.25);
 System.out.println("O novo valor do salário é " + aumento);
 } 
}
/**************************************************************************************/
/* Exercício 4 -Programa que lê 2 nºs inteiros digitados e a opção SOMA, SUBTRAÇÃO */
/* MULTIPLICAÇÃO OU DIVISÃO e entra no Switch Case e imprime o resultado */
/* da conta. */
/**************************************************************************************/
package calculadora;
import java.util.Scanner;
public class Calculadora {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 String opcao;
 double n1, n2, resultado;
 
 System.out.print("Digite o 1º número: ");
 n1 = sc.nextDouble();
 System.out.print("Digite o 2º número: ");
 n2 = sc.nextDouble();
 
 System.out.print("\nCALCULADORA:\n\nA - Adição;\nS - Subtração;\nM - Multiplicação;\nD - Divisão.\n\nDigite uma das opções acima: ");
 opcao = sc.next();
 
 switch(opcao){
 case "A": case "a":
 resultado = n1 + n2;
 System.out.println("\nADIÇÃO!\nResultado = " + resultado);
 break;
 
 case "S": case "s":
 resultado = n1 - n2;
 System.out.println("\nSUBTRAÇÃO!\nResultado = " + resultado);
 break;
 
 case "M": case "m":
 resultado = n1 * n2;
 System.out.println("\nMULTIPLICAÇÃO!\nResultado = " + resultado);
 break;
 
 case "D": case "d":
 System.out.println("\nDIVISÃO!");
 if (n2 == 0){
 System.err.println("ERRO: Divisão por zero não existe!");
 } else {
 resultado = n1 / n2;
 System.out.println("\nResultado = " + resultado);
 }
 break;
 
 default:
 System.err.println("ERRO! Você digitou uma opção inválida.");
 } 
 } 
}
/****************************************************************************/
/* Exercício 5 -Programa de pagamento de comissão de vendedores de peças */
/* A comissão será de 5% do total da venda */
/****************************************************************************/
/****************************************/
/* Dados: */
/* Identificação do vendedor = id */
/* Código da peça = codPeca */
/* Preço unitário da peça = pUnico */
/* Quantidade vendida = qtde */
/* Preço total = pTotal */
/* Comissão = comissao */
/****************************************/
package comissao;
import java.util.Scanner;
import javax.swing.JOptionPane;
public class Comissao {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int id, codPeca, qtde;
 double pUnico, pTotal, comissao;
 
 System.out.print("Digite a identificação do vendedor: ");
 id = sc.nextInt(); //
id = identificação do vendedor
 System.out.print("Digite o código da peça: ");
 codPeca = sc.nextInt(); // codPeca = código da peça
 System.out.print("Digite a quantidade vendida: ");
 qtde = sc.nextInt(); // qtde = quantidade vendida
 System.out.print("Digite o preço único da peça: ");
 pUnico = sc.nextDouble(); // pUnico = preço único da peça
 
 pTotal = pUnico * qtde;
 comissao = pTotal * 0.05;
 
 System.out.println("Comissão total = " + comissao);
 } 
}
/************************************************************************************/
/* Exercício 6 -Programa que calcula o fatorial de um nº inteiro. Repita a operação */
/* de cálculo x vezes. */
/************************************************************************************/
package fatorial;
import java.util.Scanner;
public class Fatorial {
 public static void main(String[] args) {
 Scanner ent = new Scanner(System.in);
 int num, fat = 1, cont = 1;
 
 do {
 System.out.println("Digite um nº inteiro: ");
 num = ent.nextInt();
 for (int i = 1 ; i <= num ; i++){
 fat = fat * i;
 }
 System.out.println(num + "!" + " = " + fat);
 cont++;
 } while (cont < 2);
 } 
}
/*************************************************************************************/
/* Exercício 7 - Exemplo do uso do comando Para i = 1 até... */
/* FOR (para) = O CONT VAI SOMANDO 1. O contador do FOR sempre será um nº inteiro. */ 
/*************************************************************************************/
package for1;
public class For1 {
 public static void main(String[] args) {
 for (int cont = 1 ; cont <= 10 ; cont ++){ // Esse cont vai de 1 até 10 (inclusive); cont++ é o mesmo que escrever cont = cont + 1
 System.out.println(cont);
 }
 }
}
/*******************************************************************/
/* Exercício 8 - Exemplo de FOR (para) = O CONT VAI DIMINUINDO 1. */
/*******************************************************************/
package for2;
public class For2 {
 public static void main(String[] args) {
 for(int cont = 10; cont >= 1; cont--){ // Esse cont vai de 10 até 1 (inclusive); cont-- é o mesmo que escrever cont = cont - 1
 System.out.println(cont);
 }
 } 
}
/*********************************************************************************************/
/* Exercício 9 - Exemplo de FOR (para). Tem 2 contadores: SOBE e DESCE. Enquanto que o */
/* contador SOBE vai aumentando os nºs, o contador DESCE vai diminuindo. */
/* Os 2 vão ao mesmo tempo e imprime os 2 ao mesmo tempo. */
/*********************************************************************************************/
package for3;
public class For3 {
 public static void main(String[] args) {
 for(int sobe=1, desce=10 ; sobe<=10 && desce>=1; sobe++,desce--){
 System.out.printf("%d \t %d \n", sobe, desce);
 }
 } 
}
/**********************************************************************************************/
/* Exercício 10 -Um jogo possui 3 fases. Ao chegar na 3ªfase, o jogador somente consegue */
/* transpor um portal caso tenha acumulado 10 pontos (entre a 1ªe a 2ªfase. */
/* Este programa lê os pontos acumulados na 1ªe na 2ª fases e imprime se o */
/* jogador poderá transpor o portal */
/**********************************************************************************************/
package jogo;
import java.util.Scanner;
public class Jogo {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int F1, F2, total;
 
 System.out.print("Digite os pontos da 1ª fase: ");
 F1 = sc.nextInt();
 System.out.print("Digite os pontos da 2ª fase: ");
 F2 = sc.nextInt();
 
 total = F1 + F2;
 
 if (total >= 10){
 System.out.println ("\nTotal de pontos acumulados: " + total+ "\nOK! Poderá transpor o portal!");
 } else {
 System.out.println("\nTotal de pontos acumulados: " + total + "\nNão poderá transpor o portal!");
 }
 } 
}
/***********************************************************************************************/
/* Exercício 11 -Algoritmo que receba vários nºs positivos e que calcula e mostra: */
/* - a soma dos números digitados; */
/* - a quantidade de números digitados; */
/* - a média dos números digitados. */
/***********************************************************************************************/
package lacosdowhile;
import java.util.Scanner;
public class LacosDoWhile {
 public static void main(String[] args) {
 Scanner ent = new Scanner(System.in);
 double num, soma = 0, media = 0;
 int cont = 0;
 
 do {
 System.out.print("Digite um número: ");
 num = ent.nextDouble();
 if(num >= 0){ // se o número digitado for MAIOR que zero, executa a conta
 soma = num + soma; // soma o valor digitado AGORA com o digitado ANTES
 cont++; // conta quantas vezes o usuário digitou um número
 }
 } while (num >= 0); // se o número digitado for MAIOR que zero, faz o LOOP novamente
 
 media = soma / cont; // vai calcular a média entre a soma e a quantidade de nºs digitados pelo usuário
 System.out.println ("A soma é " + soma + "\nA quantidade de números digitados foi " + cont + "\nA média é " + media);
 } 
}
/******************************************************************************************************/
/* Exercício 12 -Programa que verifica se 3 nros digitados pelo usuário podem representar os lados */
/* de um triângulo. */
/* Considerando os nros como a, b e c deve-se obedecer a seguinte regra */
/* */
/* a < b + c | */
/* b < a + c |- se não obedecer essa regra, não é triângulo */
/* c < a + b | */
/******************************************************************************************************/
package ladosdeumtriangulo;
import java.util.Scanner;
public class LadosDeUmTriangulo {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 double LA, LB, LC; // LA = Lado A ; LB = Lado B ; LC = Lado C
 
 System.out.print("Digite o valor do Lado A: ");
 LA = sc.nextDouble();
 System.out.print("Digite o valor do Lado B: ");
 LB = sc.nextDouble();
 System.out.print("Digite o valor do Lado C: ");
 LC = sc.nextDouble();
 
 if (LA <= (LB + LC)){
 if (LB <= (LA + LC)){
 if (LC <= (LA + LB)){
 System.out.println("Lado A = " + LA + "\nLado B = " + LB + "\nLado C = " + LC + "\nTriângulo OK!");
 } else { // (LC < LA + LB)
 if (LC > (LA + LB)){
System.out.println("Lado A = " + LA + "\nLado B = " + LB + "\nLado C = " + LC);
 System.out.println("Não é triângulo: Lado C > Lado A + Lado B\n" + LC + " > " + (LA + LB));
 }
 }
 } else { // (LB < LA + LC)
 if (LB > (LA + LC)){
 System.out.println("Lado A = " + LA + "\nLado B = " + LB + "\nLado C = " + LC);
 System.out.println("Não é triângulo: Lando B > Lado A + Lado C\n" + LB + " > " + (LA + LC));
 }
 }
 } else { // (LA < LB + LC)
 if (LA > (LB + LC)){
 System.out.println("Lado A = " + LA + "\nLado B = " + LB + "\nLado C = " + LC);
 System.out.println("Não é triângulo: Lado A > Lado B + Lado C\n" + LA + " > " + (LB + LC));
 }
 }
 }
}
/********************************************************************************************/
/* Exercício 13 -Programa que lê 3 notas de provas digitadas pelo usuário e calcule a média */
/********************************************************************************************/
package media3provas;
import java.util.Scanner;
public class Media3Provas {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int n1, n2, n3; // As notas só podem ser de nº inteiro
 double media; // A média retorna nº quebrado (real)
 
 System.out.print("DIgite a 1ª nota: ");
 n1 = sc.nextInt(); // n1 = 1ª nota
 System.out.print("DIgite a 2ª nota: ");
 n2 = sc.nextInt(); // n2 = 2ª nota
 System.out.print("DIgite a 3ª nota: ");
 n3 = sc.nextInt(); // n3 = 3ª nota
 
 media = (n1 + n2 + n3) / 3; // Calcula a médias das 3 notas digitadas
 System.out.println("Média = " + media);
 } 
}
/***********************************************************/
/* Exercício 14 -Programa que lê 5 notas e calcula a média */
/***********************************************************/
package mediacinconotas;
import java.util.Scanner;
public class MediaCincoNotas {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 double n1, n2, n3, n4, n5, media;
 
 System.out.print("Digite a 1ª nota: "); // n1 = 1ª nota
 n1 = sc.nextDouble();
 System.out.print("Digite a 2ª nota: "); // n2 = 2ª nota
 n2 = sc.nextDouble();
 System.out.print("Digite a 3ª nota: "); // n3 = 3ª nota
 n3 = sc.nextDouble();
 System.out.print("Digite a 4ª nota: "); // n4 = 4ª nota
 n4 = sc.nextDouble();
 System.out.print("Digite a 5ª nota: "); // n5 = 5ª nota
 n5 = sc.nextDouble();
 
 media = (n1 + n2 + n3 + n4 + n5)/5; // Cálculo da média
 
 System.out.println("Média = " + media);
 } 
}
/**********************************************************************************************/
/* Exercício 15 -Programa que lê 3 notas do aluno digitadas pelo usuário e calcula a media. O */
/* programa será encerrado quando o usuário digitar a 1ª nota negativa. Vai */
/* utilizar o WHILE. */
/**********************************************************************************************/
package mediatresnotaswhile;
import java.util.Scanner;
public class MediaTresNotasWhile {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 double n1, n2, n3, media;
 
 System.out.print("Digite a 1º nota: ");
 n1 = sc.nextDouble(); // n1 = 1ª nota
 
 if (n1 < 0){
 System.err.println("ATENÇÃO: Você digitou um valor negativo.");
 System.exit(0);
 } else {
 // Precisa saber se a 1ª nota é digitada negativa pelo usuário antes de entrar no while
 while(n1 >= 0 ){
 System.out.print("Digite a 2º nota: ");
 n2 = sc.nextDouble(); // n2 = 2ª nota
 System.out.print("Digite a 3º nota: ");
 n3 = sc.nextDouble(); // n3 = 3ª nota
 
 media = (n1 + n2 + n3)/3; // Cálculo da media
 System.out.println("A média é " + media);
 
 System.out.print("Digite a 1º nota: ");
 n1 = sc.nextDouble(); // n1 = 1ª nota
 
 if (n1 < 0){
 System.err.println("ATENÇÃO: Você digitou um valor negativo.");
 System.exit(0);
 }
 }
 }
 }
}
/***********************************************************************************************/
/* Exercício 16 -Programa que lê 6 nºs inteiros positivos (numero >= 0) digitados pelo usuário */
/* e imprime o maior e o menor deles. Vai ser utilizado um CONTADOR e o WHILE */
/***********************************************************************************************/
package menormaiorwhile;
import java.util.Scanner;
public class MenorMaiorWhile {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int n = 0, maior = 0, menor = 0, cont = 1;
 
 while((cont <= 6) && (n >= 0)){
 System.out.print("Digite o " + cont + "º inteiro positivo: ");
 n = sc.nextInt();
 if (n < 0){
 System.err.println("Você digitou um nº negativo!");
 System.exit(0);
 } else {
 if (n > maior){
 maior = n;
 } else {
 menor = n;
 }
 cont++;
 }
 }
 
 System.out.println("Maior nº digitado: " + maior + "\nMenor nº digitado: " + menor);
 } 
}
/*******************************************************************************/
/* Exercício 17 -Ler 3 números inteiros da entrada, imprimir o menor e o maior */
/*******************************************************************************/
package minmax;
import java.util.Scanner;
public class MinMax {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int n1, n2, n3;
 
 System.out.print ("Entre com o 1º nº: ");
 n1 = sc.nextInt();
 System.out.print ("Entre com o 2º nº: ");
 n2 = sc.nextInt();
 System.out.print ("Entre com o 3º nº: ");
 n3 = sc.nextInt();
 
 if (n1 > n2){
 if (n1 > n3){
 if (n2 < n3){
 System.out.println("O menor numero eh: " + n2);
 } else {
 System.out.println("O menor numero eh: " + n3);
 }
 System.out.println("O maior numero eh: " + n1);
 } else {
 if (n1 < n2){
 System.out.println("O menor numero eh: " + n1);
 } else {
 System.out.println("O menor numero eh: " + n2);
 }
 System.out.println("O maior numero eh: " + n3);
 } 
 } else {
 if (n2 > n3){
 if (n1 < n3){
 System.out.println("O menor numero eh: " + n1);
 } else {
 System.out.println("O menor numero eh: " + n3);
 }
 System.out.println("O maior numero eh: " + n2);
 } else {
 if (n1 < n2){
 System.out.println("O menor numero eh: " + n1);
 } else {
 System.out.println("O menor numero eh: " + n2);
 }
 System.out.println("O maior numero eh: " + n3);
 }
 }
}
}
/***************************************************************************************/
/* Exercício 18 -Ler 3 números inteiros da entrada, imprimir o menor e o maior - Versão Simplificada */
/***************************************************************************************/
package minmax01;
import java.util.Scanner;
public class MinMax01 {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int n1, n2, n3, maior, menor;
 
 System.out.print ("Entre com o 1º nº: ");
 n1 = sc.nextInt();
 System.out.print ("Entre com o 2º nº: ");
 n2 = sc.nextInt();
 System.out.print ("Entre com o 3º nº: ");
 n3 = sc.nextInt();
 
 maior = n1;
 menor = n1;
 
 if (n1 >= maior){
 maior = n1;
 } else {
 if (n1 <= menor){
 menor = n1;
 }
 }
 
 if (n2 >= maior){
 maior = n2;
 } else {
 if (n2 <= menor){
 menor = n2;
 }
 }
 
 if (n3 >= maior){
 maior = n3;
 } else {
 if (n3 <= menor){
 menor = n3;
 }
 }
 
 System.out.println("Maior = " + maior + "\nMenor = " + menor);
 }
}
/******************************************************************************************************/
/* Exercício 19 -Programa que lê 1 nº: se positivo armazena em A e se negativo e armazena em B */
/******************************************************************************************************/
package negativopositivo;
import java.util.Scanner;
public class NegativoPositivo {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in); 
 int n, A = 0, B = 0;
 
 System.out.print("Digite um nº: ");
 n = sc.nextInt();
 if(n > 0){ // Verifica se p nº digitado é positivo e atribui o nº ao A
 A = n;
 System.out.println("" + A + " é positivo");
 } else {
 if (n == 0){
 System.out.println("" + A + " é igual a 0 (zero)!");
 } else { // Verifica se p nº digitado é negativo e atribui o nº ao B
 B = n;
 System.out.println("" + B + " é negativo");
 }
 } 
 }
}
/***********************************************/
/* Exercício 20 -Programa que soma 2 nºs */
/***********************************************/
package numero;
public class Numero {
 public static void main(String[] args) {
 double x, y;
 x = 2;
 y = 3.0;
 y = y + x;
 System.out.println ("Soma = " + (x + y)); 
 } 
}
/*************************************************************************************************/
/* Exercício 21 -Programa que lê uma variável N e imprime somente se a mesma for maior que 100, */
/* caso contrário imprime 0 (zero) */
/*************************************************************************************************/
package numeromaiorque100;
import java.util.Scanner;
public class NumeroMaiorQue100 {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int n;
 
 System.out.print("Digite um nº: ");
 n = sc.nextInt();
 
 if (n > 100){
 System.out.println("Nº digitado: " + n);
 System.out.println("" + n + " é maior que 100");
 } else {
 System.out.println("Nº digitado: " + n);
 n = 0;
 System.out.println("" + n + " (zero)");
 }
 } 
}
/*************************************************************************************************/
/* Exercício 22 -Programa que lê um nº digitado pelo usuário e imprime se o nº é maior ou menor */
/* ou igual a 5. */
/*************************************************************************************************/
package nummaiorque5;
import java.util.Scanner;
public class NumMaiorQue5 {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int num;
 
 System.out.print("Digite um número: ");
 num = sc.nextInt();
 
 if(num > 5){ // Nº > 5
 System.out.println ("Número maior que 5!");
 } else {
 if (num == 5){ // Nº = 5
 System.out.println ("Número igual a 5!");
 } else { // Nº < 5
 System.out.println ("Número menor ou igual a 5!");
 }
 }
 } 
}
/******************************************************************/
/* Exercício 23 -Programa que calcula o fatorial de um nº inteiro */
/******************************************************************/
package outrofatorial;
import java.util.Scanner;
public class OutroFatorial {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int fat, result = 1;
 
 System.out.print("Digite um nº inteiro: ");
 fat = sc.nextInt(); // Entrada de dados
 
 // Cálculo do fatorial
 for (int i = fat; i > 0; i--) {
 result = result * i;
 }
 
 // Saída do resultado
 System.out.println(""+ fat +"! = " + result);
 } 
}
/****************************************************************************************************/
/* Exercício 24 -Programa que calcula dedados 3 nº, eles podem representar os lados de um triângulo */
/****************************************************************************************************/
/* Regra: */
/* a < b + c | */
/* b < a + c |- se não obedecer essa regra, não é triângulo */
/* c < a + b | */
/****************************************************************************************************/
package outroladosdeumtriangulo;
import java.util.Scanner;
public class OutroLadosDeUmTriangulo {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 double LA, LB, LC; // LA = Lado A ; LB = Lado B ; LC = Lado C
 
 System.out.print("\"Digite o valor do Lado A: "); // LA
 LA = sc.nextDouble();
 System.out.print("\"Digite o valor do Lado B: "); // LB
 LB = sc.nextDouble();
 System.out.print("\"Digite o valor do Lado C: "); // LC
 LC = sc.nextDouble();
 
 if((LA < LB + LC) && (LB < LA + LC) && (LC < LA + LB)){
 System.out.println("Nºs digitados:\nLado A = " + LA + "\nLado B = " + LB + "\nLado C = " + LC + "\n\nEstes nºs formam um triângulo!");
 } else {
 System.out.println("Nºs digitados:\nLado A = " + LA + "\nLado B = " + LB + "\nLado C = " + LC + "\n\nEstes nºs não formam um triângulo!");
 }
 }
}
/***************************************************************************/
/* Exercício 25 -Programa que lê 1 nota e imprime se o aluno passou ou não */
/***************************************************************************/
package passeiounao;
import java.util.Scanner;
public class PasseiOuNao {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 float nota; //armazena a nota digitada
 
 System.out.print("Digite sua nota:
");
 nota = sc.nextFloat();
 
 if ((nota <= 10) && (nota >= 0)){
 if (nota >= 7.0){
 System.out.printf("Aprovado!\nSua nota foi %.2f\n", nota);
 } else {
 if (nota >= 5.0){
 System.out.printf("Recuperação!\nSua nota foi %.2f\n", nota);
 } else{
 System.out.printf("Reprovado!\nSua nota foi %.2f\n", nota);
 }
 }
 } else {
 System.out.printf("ERRO: Digite uma nota entre 0 e 10!\n");
 }
 } 
}
/*****************************************************************************************/
/* Exercício 26 -Programa que lê a altura e o sexo de uma pessoa e calcula o peso ideal, */
/* utilizando as fórmulas: */
/* Para homens: (72.7 * h) - 58 */
/* Para mulheres: (62.1 * h) - 44.7 */
/*****************************************************************************************/
package pesoideal;
import java.util.Scanner;
public class PesoIdeal {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 
 double h, PI = 0; //h = altura; PI = Peso Ideal
 String sexo;
 
 System.out.print("Digite a altura: ");
 h = sc.nextDouble();
 System.out.print("SEXO:\n\nF - Feminino\nM - Masculino\n\nDigite uma das opções acima: ");
 sexo = sc.nextLine();
 
 if ((sexo.charAt(0) == 'M') || (sexo.charAt(0) == 'm')){ // Sexo masculino
 PI = (72.7 * h) - 58;
 System.out.println("O peso ideal é " + PI);
 } else {
 if ((sexo.charAt(0) == 'F') || (sexo.charAt(0) == 'f')){ // Sexo feminino
 PI = (62.1 * h) - 44.7;
 System.out.println("O peso ideal é " + PI);
 } else {
 System.out.println("Sexo inexistente!");
 }
 }
 } 
}
/*********************************************************************/
/* Exercício 27 -Programa que lê um nº e calcula o quadrado do mesmo */
/*********************************************************************/
package quadrado;
import java.util.Scanner;
public class Quadrado {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int n, quad;
 System.out.print("Digite um nº inteiro: ");
 n = sc.nextInt();
 
 quad = n * n;
 
 System.out.println("O quadrado de " + n + " é " + quad + "\n\n(" + n + ") + (" + n + ") = " + quad);
 } 
}
/**************************************************************************************************/
/* Exercício 28 -Programa que lê 2 nºs inteiros n1 e n2 digitados pelo usuário, soma o quadrado */
/* deles e imprime o resultado. O programa deve fazer isso até que o usuário digite */
/* um valor negativo. Utiliza o comando o WHILE. */
/**************************************************************************************************/
package quadradowhile;
import java.util.Scanner;
public class QuadradoWhile {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int resultado, n1, n2;
 
 System.out.print("Digite o valor do 1º número: ");
 n1 = sc.nextInt();
 
 if (n1 < 0){
 System.err.println("ATENÇÃO: Você digitou um valor negativo.");
 System.exit(0);
 } else {
 while (n1 >= 0){
 System.out.print("Digite o valor do 2º número: ");
 n2 = sc.nextInt();
 
 if (n2 < 0){
 System.err.println("ATENÇÃO: Você digitou um valor negativo.");
 System.exit(0);
 } else {
 resultado = (n1 * n1) + (n2 * n2);
 System.out.println("Resultado = " + resultado + "\n\n(" + (n1 * n1) + ") + (" + (n2 * n2) + ") = " + resultado);
 System.out.print("Digite o valor do 1º número: ");
 n1 = sc.nextInt();
 }
 
 if (n1 < 0){
 System.err.println("ATENÇÃO: Você digitou um valor negativo.");
 System.exit(0);
 }
 }
 }
 } 
}
/**************************************************************************************************/
/* Exercício 29 -Programa que lê 2 nºs inteiros n1 e n2 digitados pelo usuário, soma o quadrado */
/* deles e imprime o resultado. O programa deve fazer isso até que o usuário digite */
/* um valor negativo. Vai utilizar o WHILE. */
/**************************************************************************************************/
/* Outra versão do arquivo QuadradoWhile */
/**************************************************************************************************/
package quadradowhile01;
import java.util.Scanner;
public class QuadradoWhile01 {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int resultado, n1, n2, quadN1, quadN2;
 
 System.out.print("Digite o valor do 1º número: ");
 n1 = sc.nextInt();
 if (n1 < 0){
 System.err.println("ATENÇÃO: Você digitou um valor negativo.");
 System.exit(0);
 } else {
 while (n1 >= 0){
 System.out.print("Digite o valor do 2º número: ");
 n2 = sc.nextInt();
 
 if (n2 < 0){
 System.err.println("ATENÇÃO: Você digitou um valor negativo.");
 System.exit(0);
 } else {
 quadN1 = (n1 * n1); // Calcula o quadrado do n1
 quadN2 = (n2 * n2); // Calcula o quadrado do n2
 resultado = quadN1 + quadN2;
 System.out.println("1º número = " + n1 + "\n2º número = " + n2 + "\n\nQuadrado do 1º numero = " + quadN1 + "\nQuadrado do 2º número = " + quadN2 + "\n\nResultado = " + quadN1 + " + " + quadN2 + " = " + resultado);
 
 System.out.print("\nDigite o valor do 1º nº: ");
 n1 = sc.nextInt();
 }
 
 if (n1 < 0){
 System.err.println("ATENÇÃO: Você digitou um valor negativo.");
 System.exit(0);
 }
 }
 }
 } 
}
/*******************************************************************************************/
/* Exercício 30 -Programa que lê 5 notas do aluno digitadas pelo usuário e calcula a soma. */
/* Será utilizado o WHILE e um contador que irá de 1 a 5. */
/*******************************************************************************************/
package soma5notaswhilecont;
import java.util.Scanner;
public class Soma5NotasWhileCont {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 double soma = 0, nota;
 int cont = 1;
 
 while (cont <= 5){
 System.out.print("Digite a " + cont + "ª nota: ");
 nota = sc.nextDouble();
 soma = soma + nota;
 cont = cont + 1;
 }
 System.out.println("A soma das notas é " + soma);
 } 
}
/**********************************************************************************/********/
/* Exercício 31 -Programa que lê 2 nºs digitados pelo
usuário, soma e imprime o resultado */
/*******************************************************************************************/
package somadoisnumeros;
import java.util.Scanner;
public class SomaDoisNumeros {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 double n1,n2, soma;
 
 System.out.print("Digite o 1º número: ");
 n1 = sc.nextDouble();
 System.out.print("Digite o 2º número: ");
 n2 = sc.nextDouble();
 
 soma = n1 + n2;
 
 if (soma < 7){
 System.out.printf("\nSoma = %.2f", soma); 
 System.out.print("\nA soma é menor que 7.0!\n");
 } else {
 if (soma == 7){
 System.out.printf("\nSoma = %.2f", soma); 
 System.out.print("\nA soma é igual a 7.0!\n");
 } else {
 System.out.printf("\nSoma = %.2f", soma); 
 System.out.print("\nA soma é maior que 7.0!\n");
 }
 }
 } 
}
/*********************************************************************************************/
/* Exercício 32 -Programa que calcula a soma do quadrado de 3 nºs inteiros. O usuário digita */
/* 3 nºs inteiros. */
/* SOMA = (n1 * n1) + (n2 * n2) + (n3 * n3) */
/*********************************************************************************************/
package somaquadrado;
import java.util.Scanner;
public class SomaQuadrado {
 public static void main(String[] args) {
 Scanner sc = new Scanner(System.in);
 int n1, n2, n3, soma;
 
 System.out.print("Digite o 1º nº inteiro: ");
 n1 = sc.nextInt();
 System.out.print("Digite o 2º nº inteiro: ");
 n2 = sc.nextInt();
 System.out.print("Digite o 3º nº inteiro: ");
 n3 = sc.nextInt();
 
 soma = (n1 * n1) + (n2 * n2) + (n3 * n3);
 System.out.println("SOMA DOS QUADRADOS:\nResultado = " + soma + "\n(" + (n1 * n1) + ") + (" + (n2 * n2) + ") + ("+ (n3 * n3) + ") = " + soma);
 } 
}
/****************************************************************/
/* Exercício 33 -Programa que escreve na tela: Vivam os gatos! */
/****************************************************************/
package teste;
public class Teste {
 public static void main(String[] args) { // Início da função main
 // Declarando classe pública
 // Classe principal entre chaves
 System.out.println("Vivam os gatos!"); // Escreve na tela
 } // Final da função main
}
}