├── .gitattributes ├── nivel1 ├── 000-HelloWorld │ └── src │ │ └── Main.java ├── 003-ZooJavaPoo │ └── src │ │ ├── models │ │ ├── Macaco.java │ │ ├── Leao.java │ │ └── Animal.java │ │ ├── app │ │ └── Main.java │ │ └── services │ │ └── Zoologico.java ├── 034-SimuladorDado │ └── src │ │ └── simulador │ │ └── dado │ │ └── SimuladorDado.java ├── 011-CalcularAreaCirculo │ └── src │ │ └── calcular │ │ └── area │ │ └── circulo │ │ └── CalcularAreaCirculo.java ├── 036-NumeroEntre10E20 │ └── src │ │ └── verificador │ │ └── NumeroEntre10E20.java ├── 008-SaudacaoPersonalizada │ └── src │ │ └── saudacao │ │ └── personalizada │ │ └── SaudacaoPersonalizada.java ├── 038-MultiploDeTresOuCinco │ └── src │ │ └── multiplo │ │ └── MultiploDeTresOuCinco.java ├── 001-Palindromo │ └── src │ │ └── Main.java ├── 026-ArraySomenteNegativos │ └── src │ │ └── negativos │ │ └── ArraySomenteNegativos.java ├── 033-TrocarValorDuasVariaveis │ └── src │ │ └── troca │ │ └── valor │ │ └── duas │ │ └── variaveis │ │ └── Main.java ├── 025-ArraySomentePositivos │ └── src │ │ └── positivos │ │ └── ArraySomentePositivos.java ├── 002-SomarNumerosUnicos │ └── src │ │ └── Main.java ├── 071-ArrayTamanho │ └── src │ │ └── tamanho │ │ └── ObterTamanhoDoArray.java ├── 030-ConversorHorario │ └── src │ │ └── conversor │ │ └── horario │ │ └── ConversorMinutosHoras.java ├── 010-ApenasDigitosEmString │ └── src │ │ └── apenas │ │ └── digitos │ │ └── em │ │ └── string │ │ └── ApenasDigitosEmString.java ├── 039-LetraVogal │ └── src │ │ └── verificador │ │ └── vogal │ │ └── LetraVogal.java ├── 024-ArrayInverterOrdem │ └── src │ │ └── inverter │ │ └── ArrayInverterOrdem.java ├── 031-DiasSemana │ └── src │ │ └── dias │ │ └── semana │ │ └── DiasSemana.java ├── 023-ArrayTemONumero │ └── src │ │ └── encontrar │ │ └── numero │ │ └── ArrayTemONumero.java ├── 037-VerificarVoto │ └── src │ │ └── verificacao │ │ └── voto │ │ └── VerificarVoto.java ├── 019-ArrayNumerosImpares │ └── src │ │ └── impares │ │ └── ArrayNumerosImpares.java ├── 020-ArrayNomes │ └── src │ │ └── nomes │ │ └── ArrayNomes.java ├── 006-NumeroPrimo │ └── src │ │ └── numeroprimo │ │ └── Main.java ├── 007-InverterString │ └── src │ │ └── inverterstring │ │ └── Main.java ├── 021-ArrayMediaDoAluno │ └── src │ │ └── media │ │ └── ArrayMediaDoAluno.java ├── 013-MaiorNumeroEmTres │ └── src │ │ └── maior │ │ └── numero │ │ └── em │ │ └── tres │ │ └── MaiorNumeroEmTres.java ├── 015-ArrayImprimirCincoNumerosInteiros │ └── src │ │ └── imprimir │ │ └── cinco │ │ └── numeros │ │ └── inteiros │ │ └── ArrayImprimirCincoNumerosInteiros.java ├── 042-QuadradoDeUmNumero │ └── src │ │ └── calcular │ │ └── quadrado │ │ └── CalcularQuadrado.java ├── 009-OperacoesAritmeticas │ └── src │ │ └── operacoes │ │ └── aritmeticas │ │ └── OperacoesAritmeticas.java ├── 032-CalculadoraIMC │ └── src │ │ └── calculadora │ │ └── imc │ │ └── CalculadoraIMC.java ├── 014-CalcularMediaLista │ └── src │ │ └── calcular │ │ └── media │ │ └── lista │ │ └── CalcularMediaLista.java ├── 005-Fatorial │ └── src │ │ └── fatorial │ │ └── Main.java ├── 040-CondicoesBooleanas │ └── src │ │ └── condicoes │ │ └── booleanas │ │ └── CondicoesBooleanas.java ├── 004-ContadorDeVogais │ └── src │ │ └── contador │ │ └── Main.java ├── 078-ClassificacaoIdade │ └── src │ │ └── classificacao │ │ └── ClassificacaoIdade.java ├── 041-AreaRetangulo │ └── src │ │ └── area │ │ └── retangulo │ │ └── CalcularAreaRetangulo.java ├── 029-SetRemoverNomesRepetidos │ └── src │ │ └── remover │ │ └── repetidos │ │ └── SetRemoverNomesRepetidos.java ├── 016-ArraySomarElementosInteiros │ └── src │ │ └── somar │ │ └── ArraySomarElementosInteiros.java ├── 018-ArrayNumerosPares │ └── src │ │ └── pares │ │ └── ArrayNumerosPares.java ├── 012-CelsiusFahrenheit │ └── src │ │ └── celsius │ │ └── fahrenheit │ │ └── CelsiusFahrenheit.java ├── 035-JogoDeAdivinhacaoSimples │ └── src │ │ └── jogo │ │ └── de │ │ └── adivinhacao │ │ └── JogoDeAdivinhacaoSimples.java ├── 027-HashMapParesChaveValor │ └── src │ │ └── chave │ │ └── valor │ │ └── HashMapParesChaveValor.java ├── 017-ArrayMediaElementosInteiros │ └── src │ │ └── media │ │ └── ArrayMediaElementosInteiros.java ├── 022-ArrayMaiorEMenorTextos │ └── src │ │ └── maior │ │ └── menor │ │ └── textos │ │ └── ArrayMaiorEMenorTextos.java └── 028-HashMapNomeIdade │ └── src │ └── nome │ └── idade │ └── HashMapNomeIdade.java ├── nivel2 ├── 020-RestoDaDivisao │ └── src │ │ └── divisao │ │ ├── App.java │ │ ├── DivisaoService.java │ │ ├── Divisao.java │ │ └── ConsoleUI.java ├── 039-LambdaThread │ └── src │ │ └── thread │ │ └── LambdaThread.java ├── 032-LambdaImprimirElementos │ └── src │ │ └── imprimir │ │ └── elementos │ │ └── LambdaImprimirElementos.java ├── 035-LambdaSomarInteiros │ └── src │ │ └── somar │ │ └── inteiros │ │ └── LambdaSomarInteiros.java ├── 033-LambdaSomentePares │ └── src │ │ └── somente │ │ └── pares │ │ └── LambdaSomentePares.java ├── 037-LambdaOrdenarListaStrings │ └── src │ │ └── ordenar │ │ └── strings │ │ └── LambdaOrdenarListaStrings.java ├── 036-LambdaMaiorElemento │ └── src │ │ └── maior │ │ └── elemento │ │ └── LambdaMaiorElemento.java ├── 038-LambdaContaLetraInicial │ └── src │ │ └── conta │ │ └── letras │ │ └── ContaLetraInicial.java ├── 041-MapQuadradosInteiros │ └── src │ │ └── mapquadrados │ │ └── MapQuadradosInteiros.java ├── 042-FiltrarStringsMais5Caracteres │ └── src │ │ └── filtrarstrings │ │ └── FiltrarStringsMais5Caracteres.java ├── 034-LambdaStringParaMaiusculas │ └── src │ │ └── string │ │ └── para │ │ └── maiusculas │ │ └── LambdaStringParaMaiusculas.java ├── 027-NormalizarTexto │ └── src │ │ └── normalizar │ │ └── texto │ │ └── NormalizarTexto.java ├── 040-LambdaPercorrerListaInteiros │ └── src │ │ └── percorrerlista │ │ └── PercorrerListaInteiros.java ├── 022-MinimoMultiploComum │ └── src │ │ └── minimo │ │ └── multiplo │ │ └── comum │ │ └── MinimoMultiploComum.java ├── 048-SkipLimitInteiros │ └── src │ │ └── skiplimit │ │ └── SkipLimitInteiros.java ├── 021-MaximoDivisorComum │ └── src │ │ └── maximo │ │ └── divisor │ │ └── comum │ │ └── MaximoDivisorComum.java ├── 047-DistinctInteiros │ └── src │ │ └── distinctinteiros │ │ └── DistinctInteiros.java ├── 007-Tabuada │ └── src │ │ └── tabuada │ │ └── Tabuada.java ├── 003-DuplicadosArray │ └── src │ │ └── duplicadosarray │ │ └── Main.java ├── 012-CaixaEletronico │ └── src │ │ ├── model │ │ └── Conta.java │ │ └── app │ │ └── Main.java ├── 009-ContadorDePalavras │ └── src │ │ └── contador │ │ └── de │ │ └── palavras │ │ └── ContadorDePalavras.java ├── 026-MediaPonderada │ └── src │ │ └── media │ │ └── ponderada │ │ └── MediaPonderada.java ├── 015-SomarPositivos │ └── src │ │ └── somar │ │ └── positivos │ │ └── SomarPositivos.java ├── 010-PrimeiroCaractereRepetido │ └── src │ │ └── primeiro │ │ └── caractere │ │ └── repetido │ │ └── PrimeiroCaractereRepetido.java ├── 013-ValidadorDeSenha │ └── src │ │ └── validador │ │ └── de │ │ └── senha │ │ └── ValidadorDeSenha.java ├── 002-Fibonacci │ └── src │ │ └── fibonacci │ │ └── Main.java ├── 046-MinMaxNomesPorTamanho │ └── src │ │ └── minmaxnomes │ │ └── MinMaxNomesPorTamanho.java ├── 043-ReduceProdutoInteiros │ └── src │ │ └── reduceproduto │ │ └── ReduceProdutoInteiros.java ├── 008-VerificarAnagramas │ └── src │ │ └── verificar │ │ └── anagramas │ │ └── VerificarAnagramas.java ├── 028-SimuladorDeEstoque │ └── src │ │ └── simulador │ │ └── estoque │ │ ├── Produto.java │ │ └── ControleEsqtoque.java ├── 029-GeradorMegaSena │ └── src │ │ └── gerador │ │ └── megasena │ │ └── Gerador.java ├── 001-SomaDosDigitos │ └── src │ │ └── somadosdigitos │ │ └── Main.java ├── 018-ClassificacaoTriangulos │ └── src │ │ └── classificacao │ │ └── triangulos │ │ └── ClassificacaoTriangulos.java ├── 023-BuscaBinaria │ └── src │ │ └── busca │ │ └── binaria │ │ └── BuscaBinaria.java ├── 031-GeradorSenha │ └── src │ │ └── gerador │ │ └── senha │ │ └── GeradorSenha.java ├── 014-ElementosRepetidos │ └── src │ │ └── elementos │ │ └── repetidos │ │ └── ElementosRepetidos.java ├── 016-OrdenarArrayDeInteiros │ └── src │ │ └── ordenar │ │ └── inteiros │ │ └── OrdenarArrayDeInteiros.java ├── 019-Potencia │ └── src │ │ └── potencia │ │ └── Potencia.java ├── 005-FrequenciaCaracteres │ └── src │ │ └── frequencia │ │ └── caracteres │ │ └── FrequenciaCaracteres.java ├── 011-CaracteresUnicos │ └── src │ │ └── caracteres │ │ └── unicos │ │ └── CaracteresUnicos.java ├── 045-VerificarMatchInteiros │ └── src │ │ └── verificarmatch │ │ └── VerificarMatchInteiros.java ├── 025-RotacionarArray │ └── src │ │ └── array │ │ └── rotacao │ │ └── RotacionarArray.java ├── 030-IntercalarListas │ └── src │ │ └── intercalar │ │ └── listas │ │ └── Listas.java ├── 049-TakeWhileMenores50 │ └── src │ │ └── takewhile │ │ └── TakeWhileMenores50.java ├── 024-MatrizQuadradaSimetrica │ └── src │ │ └── matriz │ │ └── quadrada │ │ └── simetrica │ │ └── MatrizQuadradaSimetrica.java ├── 006-ParOuImpar │ └── src │ │ └── par │ │ └── ou │ │ └── impar │ │ └── ParOuImpar.java ├── 044-CompararStreamParallel │ └── src │ │ └── compararstream │ │ └── Comparar.java ├── 004-MaiorEMenor │ └── src │ │ └── maior │ │ └── e │ │ └── menor │ │ └── Main.java └── 017-StringEmTitulo │ └── src │ └── string │ └── em │ └── titulo │ └── StringEmTitulo.java ├── nivel3 ├── 002-Pares1A100 │ └── src │ │ └── pares │ │ └── Pares1A100.java ├── 020-Tabuada1ao10 │ └── src │ │ └── tabuada │ │ └── Tabuada.java ├── 016-TrianguloAsteriscosEsquerda │ └── src │ │ └── triangulo │ │ └── esquerda │ │ └── TrianguloEsquerda.java ├── 003-SomaComLaco │ └── src │ │ └── soma │ │ └── SomaComLaco.java ├── 017-TrianguloAsteriscosDireita │ └── src │ │ └── triangulo │ │ └── direita │ │ └── TrianguloDireita.java ├── 001-ContagemRegressiva │ └── src │ │ └── contagem │ │ └── regressiva │ │ └── ContagemRegressiva.java ├── 018-TrianguloSimetrico │ └── src │ │ └── triangulo │ │ └── simetrico │ │ └── TrianguloSimétrico.java ├── 008-SomaComLaco │ └── src │ │ └── soma │ │ └── SomaComLaco.java ├── 014-InverterNumero │ └── src │ │ └── inverter │ │ └── numero │ │ └── InverterNumero.java ├── 012-NumeroPrimoComBreak │ └── src │ │ └── numero │ │ └── primo │ │ └── NumeroPrimoComBreak.java ├── 013-ContadorDeDigitos │ └── src │ │ └── contador │ │ └── ContadorDeDigitos.java ├── 019-NumeroArmstrong │ └── src │ │ └── numero │ │ └── armstrong │ │ └── NumeroArmstrong.java ├── 010-GeradorDePotencia │ └── src │ │ └── potencia │ │ └── GeradorDePotencia.java ├── 005-MenuComDoWhile │ └── src │ │ └── menu │ │ └── MenuComDoWhile.java ├── 009-NumeroPerfeito │ └── src │ │ └── numero │ │ └── perfeito │ │ └── NumeroPerfeito.java ├── 022-Cronometro │ └── src │ │ └── cronometro │ │ └── Cronometro.java ├── 007-TabuadaEmLoop │ └── src │ │ └── tabuada │ │ └── TabuadaEmLoop.java ├── 011-MediaDeNotasComLaco │ └── src │ │ └── media │ │ └── MediaDeNotasComLaco.java ├── 004-NumeroSecreto │ └── src │ │ └── numero │ │ └── secreto │ │ └── NumeroSecreto.java ├── 006-ContaNumeros │ └── src │ │ └── conta │ │ └── numeros │ │ └── ContaNumeros.java ├── 021-RelogioDigital │ └── src │ │ └── relogio │ │ └── digital │ │ └── RelogioDigital.java └── 015-JogoNumeroSecreto │ └── src │ └── jogo │ └── JogoNumeroSecreto.java ├── .gitignore ├── outros ├── 001-ConversorDecimalBinario │ └── src │ │ └── conversor │ │ └── decimal │ │ └── binario │ │ └── Conversor.java └── 002-ConversorBinarioDecimal │ └── src │ └── conversor │ └── binario │ └── decimal │ └── Conversor.java ├── LICENSE ├── README.md └── Lista de Desafios /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | -------------------------------------------------------------------------------- /nivel1/000-HelloWorld/src/Main.java: -------------------------------------------------------------------------------- 1 | public class Main { 2 | public static void main(String[] args) { 3 | System.out.println("Hello World!"); 4 | } 5 | } -------------------------------------------------------------------------------- /nivel2/020-RestoDaDivisao/src/divisao/App.java: -------------------------------------------------------------------------------- 1 | package divisao; 2 | 3 | public class App { 4 | public static void main(String[] args) { 5 | new ConsoleUI().iniciar(); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /nivel1/003-ZooJavaPoo/src/models/Macaco.java: -------------------------------------------------------------------------------- 1 | package models; 2 | 3 | public class Macaco extends Animal { 4 | public Macaco() { 5 | super("Cebus apella", "Uh uh ah ah!"); 6 | } 7 | 8 | @Override 9 | public void emitirSom() { 10 | System.out.println("Macaco: " + getSom()); 11 | } 12 | } -------------------------------------------------------------------------------- /nivel2/020-RestoDaDivisao/src/divisao/DivisaoService.java: -------------------------------------------------------------------------------- 1 | package divisao; 2 | 3 | public class DivisaoService { 4 | public int calcularResultado(Divisao divisao) { 5 | return divisao.getDividendo() / divisao.getDivisor(); 6 | } 7 | 8 | public int calcularResto(Divisao divisao) { 9 | return divisao.getDividendo() % divisao.getDivisor(); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /nivel2/039-LambdaThread/src/thread/LambdaThread.java: -------------------------------------------------------------------------------- 1 | package thread; 2 | 3 | public class LambdaThread { 4 | public static void main(String[] args) { 5 | Runnable tarefa = () -> System.out.println("Executando a tarefa em uma nova thread!"); 6 | 7 | Thread thread = new Thread(tarefa); 8 | thread.start(); 9 | 10 | System.out.println("Thread principal continua executando..."); 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /nivel2/032-LambdaImprimirElementos/src/imprimir/elementos/LambdaImprimirElementos.java: -------------------------------------------------------------------------------- 1 | package imprimir.elementos; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | public class LambdaImprimirElementos { 7 | public static void main(String[] args) { 8 | List listaDeInteiros = Arrays.asList(1,2,3,4,5,6,7,8,9,10); 9 | listaDeInteiros.forEach(n -> System.out.println(n)); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /nivel3/002-Pares1A100/src/pares/Pares1A100.java: -------------------------------------------------------------------------------- 1 | package pares; 2 | 3 | public class Pares1A100 { 4 | public static void main(String[] args) { 5 | 6 | /** 7 | * Use um for ou while para imprimir todos os números pares entre 1 e 100. 8 | */ 9 | 10 | for (int i = 0; i < 101; i++) { 11 | if (i % 2 == 0) { 12 | System.out.println(i); 13 | } 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /nivel2/035-LambdaSomarInteiros/src/somar/inteiros/LambdaSomarInteiros.java: -------------------------------------------------------------------------------- 1 | package somar.inteiros; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | public class LambdaSomarInteiros { 7 | public static void main(String[] args) { 8 | List listaDeInteiros = Arrays.asList(1,2,3,4,5,6,7,8,9,10); 9 | System.out.println(listaDeInteiros.stream() 10 | .reduce(0, (a,b) -> a + b)); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /nivel2/033-LambdaSomentePares/src/somente/pares/LambdaSomentePares.java: -------------------------------------------------------------------------------- 1 | package somente.pares; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | public class LambdaSomentePares { 7 | public static void main(String[] args) { 8 | List listaDeInteiros = Arrays.asList(1,2,3,4,5,6,7,8,9,10); 9 | listaDeInteiros.stream() 10 | .filter(n -> n % 2 == 0) 11 | .forEach(System.out::println); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /nivel1/003-ZooJavaPoo/src/models/Leao.java: -------------------------------------------------------------------------------- 1 | package models; 2 | 3 | public class Leao extends Animal { 4 | public Leao() { 5 | super("Panthera leo", "Rugido!"); 6 | } 7 | 8 | @Override 9 | public void emitirSom() { 10 | System.out.println("Leão: " + getSom()); 11 | } 12 | } 13 | 14 | //super(...) chama o construtor da classe Animal. 15 | //@Override: implementa o método abstrato da classe mãe. 16 | //Usa getSom() da superclasse (herança + encapsulamento). -------------------------------------------------------------------------------- /nivel3/020-Tabuada1ao10/src/tabuada/Tabuada.java: -------------------------------------------------------------------------------- 1 | package tabuada; 2 | 3 | public class Tabuada { 4 | 5 | public static void main(String[] args) { 6 | for (int i = 1; i <= 10; i++) { 7 | System.out.println("==============="); 8 | gerarTabuada(i); 9 | } 10 | } 11 | 12 | public static void gerarTabuada(int num) { 13 | for (int i = 0; i <= 10; i++) { 14 | System.out.printf("%d x %d = %d%n", num, i, (num * i)); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /nivel1/034-SimuladorDado/src/simulador/dado/SimuladorDado.java: -------------------------------------------------------------------------------- 1 | package simulador.dado; 2 | 3 | import java.util.Random; 4 | 5 | public class SimuladorDado { 6 | 7 | public static void main(String[] args) { 8 | System.out.println("Número do dado: " + jogarDado()); 9 | } 10 | 11 | 12 | 13 | public static int jogarDado(){ 14 | int[] dado = {1,2,3,4,5,6}; 15 | Random random = new Random(); 16 | int index = random.nextInt(dado.length); 17 | return dado[index]; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /nivel2/037-LambdaOrdenarListaStrings/src/ordenar/strings/LambdaOrdenarListaStrings.java: -------------------------------------------------------------------------------- 1 | package ordenar.strings; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | public class LambdaOrdenarListaStrings { 7 | public static void main(String[] args) { 8 | List listaDeCompras = Arrays.asList("Feijão", "Arroz", "Macarrão", "Alface", "Tomate", "Vinho", "Água", "Batata"); 9 | listaDeCompras.sort((a , b) -> a.compareTo(b)); 10 | System.out.println("Lista de Compras Ordenada: " + listaDeCompras); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /nivel2/036-LambdaMaiorElemento/src/maior/elemento/LambdaMaiorElemento.java: -------------------------------------------------------------------------------- 1 | package maior.elemento; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.Optional; 6 | 7 | public class LambdaMaiorElemento { 8 | public static void main(String[] args) { 9 | List listaDeElementos = Arrays.asList(1,2,3,4,5,6,7,8,9,10); 10 | Optional maior = listaDeElementos.stream() 11 | .max((a, b) -> Integer.compare(a, b)); 12 | maior.ifPresent(m -> System.out.println("Maior presente: " + m)); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /nivel2/038-LambdaContaLetraInicial/src/conta/letras/ContaLetraInicial.java: -------------------------------------------------------------------------------- 1 | package conta.letras; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | public class ContaLetraInicial { 7 | public static void main(String[] args) { 8 | List palavras = Arrays.asList("Amor", "Sol", "Avião", "Lua", "Amizade", "Estrela"); 9 | 10 | long quantidade = palavras.stream() 11 | .filter(p -> p.startsWith("A")) 12 | .count(); 13 | 14 | System.out.println("Quantidade de palavras que começam com 'A': " + quantidade); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /nivel2/020-RestoDaDivisao/src/divisao/Divisao.java: -------------------------------------------------------------------------------- 1 | package divisao; 2 | 3 | public class Divisao { 4 | private final int dividendo; 5 | private final int divisor; 6 | 7 | public Divisao(int dividendo, int divisor) { 8 | if (divisor == 0) { 9 | throw new IllegalArgumentException("Divisor não pode ser zero."); 10 | } 11 | this.dividendo = dividendo; 12 | this.divisor = divisor; 13 | } 14 | 15 | public int getDividendo() { 16 | return dividendo; 17 | } 18 | 19 | public int getDivisor() { 20 | return divisor; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /nivel1/011-CalcularAreaCirculo/src/calcular/area/circulo/CalcularAreaCirculo.java: -------------------------------------------------------------------------------- 1 | package calcular.area.circulo; 2 | 3 | import java.util.Scanner; 4 | 5 | public class CalcularAreaCirculo { 6 | public static void main(String[] args) { 7 | Scanner input = new Scanner(System.in); 8 | System.out.print("Digite o valor do Raio: "); 9 | double valor = input.nextDouble(); 10 | double areaCirculo = calcularArea(valor); 11 | System.out.printf("Área do Círculo: %.2f%n", areaCirculo); 12 | } 13 | 14 | public static double calcularArea(double raio) { 15 | return raio * raio * Math.PI; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /nivel1/036-NumeroEntre10E20/src/verificador/NumeroEntre10E20.java: -------------------------------------------------------------------------------- 1 | package verificador; 2 | 3 | import java.util.Scanner; 4 | 5 | public class NumeroEntre10E20 { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | 9 | System.out.print("Digite um número: "); 10 | int numero = scanner.nextInt(); 11 | 12 | if (numero >= 10 && numero <= 20){ 13 | System.out.println("✅ O número está entre 10 e 20 (inclusive)."); 14 | } else { 15 | System.out.println("❌ O número NÃO está entre 10 e 20."); 16 | } 17 | scanner.close(); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /nivel2/041-MapQuadradosInteiros/src/mapquadrados/MapQuadradosInteiros.java: -------------------------------------------------------------------------------- 1 | package mapquadrados; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.stream.Collectors; 6 | 7 | public class MapQuadradosInteiros { 8 | public static void main(String[] args) { 9 | List numeros = Arrays.asList(2,4,6,8,10); 10 | 11 | List quadrados = numeros.stream() 12 | .map(n -> n * n) 13 | .collect(Collectors.toList()); 14 | 15 | System.out.printf("Lista original: " + numeros); 16 | System.out.printf("\nLista dos quadrados: " + quadrados); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /nivel3/016-TrianguloAsteriscosEsquerda/src/triangulo/esquerda/TrianguloEsquerda.java: -------------------------------------------------------------------------------- 1 | package triangulo.esquerda; 2 | 3 | import java.util.Scanner; 4 | 5 | public class TrianguloEsquerda { 6 | public static void main(String[] args) { 7 | Scanner input = new Scanner(System.in); 8 | System.out.println("Deseja uma pirâmide com quantas linhas? "); 9 | int tamanho = input.nextInt(); 10 | gerarTriangulo(tamanho); 11 | } 12 | 13 | public static void gerarTriangulo(int tamanho) { 14 | for (int linha = 1; linha <= tamanho; linha++) { 15 | System.out.println("*".repeat(linha)); 16 | } 17 | } 18 | } -------------------------------------------------------------------------------- /nivel3/003-SomaComLaco/src/soma/SomaComLaco.java: -------------------------------------------------------------------------------- 1 | package soma; 2 | 3 | import java.util.Scanner; 4 | 5 | public class SomaComLaco { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | 9 | int contador = 0; 10 | int soma = 0; 11 | 12 | do { 13 | System.out.printf("Informe o %dº número: ", contador + 1); 14 | int valor = scanner.nextInt(); 15 | 16 | soma += valor; 17 | contador++; 18 | 19 | } while (contador != 10); 20 | 21 | System.out.println("\nA soma dos valores é " + soma); 22 | scanner.close(); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /nivel1/008-SaudacaoPersonalizada/src/saudacao/personalizada/SaudacaoPersonalizada.java: -------------------------------------------------------------------------------- 1 | package saudacao.personalizada; 2 | 3 | import java.util.Scanner; 4 | 5 | public class SaudacaoPersonalizada { 6 | public static String criarSaudacao(String texto) { 7 | return "Olá, " + texto + "!"; 8 | } 9 | 10 | public static void main(String[] args) { 11 | Scanner scanner = new Scanner(System.in); 12 | 13 | System.out.print("Digite seu nome: "); 14 | String nome = scanner.nextLine(); 15 | 16 | String resultado = criarSaudacao(nome); 17 | System.out.println(resultado); 18 | 19 | scanner.close(); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /nivel3/017-TrianguloAsteriscosDireita/src/triangulo/direita/TrianguloDireita.java: -------------------------------------------------------------------------------- 1 | package triangulo.direita; 2 | 3 | import java.util.Scanner; 4 | 5 | public class TrianguloDireita { 6 | public static void main(String[] args) { 7 | Scanner input = new Scanner(System.in); 8 | System.out.println("Digite o tamanho da pirâmide: "); 9 | int tamanho = input.nextInt(); 10 | gerarTriangulo(tamanho); 11 | input.close(); 12 | 13 | } 14 | 15 | public static void gerarTriangulo(int tamanho) { 16 | for (int linha = 1; linha <= tamanho; linha++) { 17 | System.out.println(" ".repeat(tamanho - linha) + "*".repeat(linha)); 18 | } 19 | } 20 | } -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled class files 2 | *.class 3 | 4 | # Log files 5 | *.log 6 | *.log.* 7 | 8 | # Package files 9 | *.jar 10 | *.war 11 | *.nar 12 | *.ear 13 | *.zip 14 | *.tar.gz 15 | *.rar 16 | 17 | # IntelliJ IDEA 18 | /.idea/ 19 | *.iml 20 | /out/ 21 | /gen/ 22 | 23 | # Maven/Gradle 24 | /target/ 25 | /build/ 26 | /.gradle/ 27 | /bin/ 28 | 29 | # Other IDEs/Editors 30 | .vscode/ 31 | 32 | # Node.js 33 | node_modules/ 34 | npm-debug.log* 35 | yarn-debug.log* 36 | 37 | # Mac OS X 38 | .DS_Store 39 | 40 | # Windows 41 | Thumbs.db 42 | Desktop.ini 43 | 44 | # Secrets and sensitive data 45 | *.properties 46 | *.yaml 47 | *.yml 48 | 49 | # Other 50 | *.ctxt 51 | .mtj.tmp/ 52 | hs_err_pid* 53 | replay_pid* 54 | -------------------------------------------------------------------------------- /nivel1/038-MultiploDeTresOuCinco/src/multiplo/MultiploDeTresOuCinco.java: -------------------------------------------------------------------------------- 1 | package multiplo; 2 | 3 | import java.util.Scanner; 4 | 5 | public class MultiploDeTresOuCinco { 6 | public static void main(String[] args) { 7 | Scanner scanner =new Scanner(System.in); 8 | 9 | System.out.print("Informe um número inteiro: "); 10 | int numeroInformado = scanner.nextInt(); 11 | 12 | String resultado = (numeroInformado % 3 == 0 || numeroInformado % 5 == 0) 13 | ? numeroInformado + " é múltiplo de 3 ou de 5." 14 | : numeroInformado + " não é múltiplo de 3 nem de 5."; 15 | 16 | System.out.println(resultado); 17 | 18 | scanner.close(); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /outros/001-ConversorDecimalBinario/src/conversor/decimal/binario/Conversor.java: -------------------------------------------------------------------------------- 1 | package conversor.decimal.binario; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Conversor { 6 | // Veja um conversor bacana em https://basesnumericas.pages.dev/conversor 7 | 8 | public static void main(String[] args) { 9 | Scanner input = new Scanner(System.in); 10 | System.out.println("Digite um numero: "); 11 | long numero = input.nextLong(); 12 | System.out.printf("%d (base 10) = %s (base 2)%n", numero, converter(numero)); 13 | input.close(); 14 | } 15 | 16 | 17 | public static String converter(long numero){ 18 | return Long.toBinaryString(numero); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /nivel1/003-ZooJavaPoo/src/app/Main.java: -------------------------------------------------------------------------------- 1 | package app; 2 | 3 | import models.Leao; 4 | import models.Macaco; 5 | import services.Zoologico; 6 | 7 | public class Main { 8 | public static void main(String[] args) { 9 | Zoologico zoo = new Zoologico(); 10 | 11 | // Criar animais 12 | Leao leao = new Leao(); 13 | Macaco macaco = new Macaco(); 14 | 15 | // Adicionar ao zoológico 16 | zoo.adicionarAnimal(leao); 17 | zoo.adicionarAnimal(macaco); 18 | 19 | // Mostrar sons 20 | zoo.listarAnimaisEmitirSom(); 21 | } 22 | } 23 | 24 | //Instancia o serviço Zoologico. 25 | //Cria os animais (Leao, Macaco). 26 | //Adiciona à lista e executa o método emitirSom() para cada um. -------------------------------------------------------------------------------- /nivel1/001-Palindromo/src/Main.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | public class Main { 3 | public static boolean isPalindrome(String texto) { 4 | String textoLimpo = texto.replaceAll("[^a-zA-Z0-9]", "").toLowerCase(); 5 | String textoInvertido = new StringBuilder(textoLimpo).reverse().toString(); 6 | return textoLimpo.equals(textoInvertido); 7 | } 8 | 9 | public static void main(String[] args) { 10 | Scanner scanner = new Scanner(System.in); 11 | 12 | System.out.println("=== Verificador de palíndromo ==="); 13 | System.out.print("Digite uma palavra ou frase: "); 14 | String str1 = scanner.nextLine(); 15 | System.out.println(str1 + " é palíndromo? " + isPalindrome(str1)); 16 | 17 | } 18 | } -------------------------------------------------------------------------------- /nivel2/042-FiltrarStringsMais5Caracteres/src/filtrarstrings/FiltrarStringsMais5Caracteres.java: -------------------------------------------------------------------------------- 1 | package filtrarstrings; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.stream.Collectors; 6 | 7 | public class FiltrarStringsMais5Caracteres { 8 | public static void main(String[] args) { 9 | List palavras = Arrays.asList("exemplo", "casa", "aviao", "programacao", "java", "stream", "filtro"); 10 | 11 | List resultado = palavras.stream() 12 | .filter(s -> s.trim().length() > 5) 13 | .collect(Collectors.toList()); 14 | 15 | System.out.printf("Lista original: " + palavras); 16 | System.out.printf("\nLista com mais de 5 caracteres: " + resultado); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /nivel1/026-ArraySomenteNegativos/src/negativos/ArraySomenteNegativos.java: -------------------------------------------------------------------------------- 1 | package negativos; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class ArraySomenteNegativos { 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | int[] numerosInformados = new int[10]; 10 | 11 | for (int i = 0; i < numerosInformados.length; i++) { 12 | System.out.print("Informe o " + (i + 1) + "° número: "); 13 | numerosInformados[i] = scanner.nextInt(); 14 | } 15 | int[] somenteNegativos = Arrays.stream(numerosInformados).filter(n -> n < 0).toArray(); 16 | System.out.println("Array de negativos: " + Arrays.toString(somenteNegativos)); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /nivel1/033-TrocarValorDuasVariaveis/src/troca/valor/duas/variaveis/Main.java: -------------------------------------------------------------------------------- 1 | package troca.valor.duas.variaveis; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Main { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.printf("Digite o valor de A: "); 9 | int a = sc.nextInt(); 10 | System.out.printf("Digite o valor de B: "); 11 | int b = sc.nextInt(); 12 | // Operador xor 13 | a = a ^ b; 14 | b = b ^ a; 15 | a = a ^ b; 16 | // XOR (ou exclusivo): 17 | // 0 ^ 0 = 0 18 | // 1 ^ 1 = 0 19 | // 0 ^ 1 = 1 20 | // 1 ^ 0 = 1 21 | 22 | System.out.println("A: " + a + " | B: " + b); 23 | 24 | sc.close(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /nivel3/001-ContagemRegressiva/src/contagem/regressiva/ContagemRegressiva.java: -------------------------------------------------------------------------------- 1 | package contagem.regressiva; 2 | 3 | import java.util.Scanner; 4 | 5 | public class ContagemRegressiva { 6 | public static void main(String[] args) { 7 | /** 8 | * Peça ao usuário um número inteiro e faça uma contagem regressiva até 0, exibindo os números um por um. 9 | */ 10 | 11 | Scanner scanner = new Scanner(System.in); 12 | 13 | System.out.print("Informe um número inteiro: "); 14 | int numero = scanner.nextInt(); 15 | 16 | System.out.println("\nContagem regressiva: "); 17 | for (int i = numero; i >= 0; i--) { 18 | System.out.println(i); 19 | } 20 | System.out.println("Fim!"); 21 | scanner.close(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /nivel3/018-TrianguloSimetrico/src/triangulo/simetrico/TrianguloSimétrico.java: -------------------------------------------------------------------------------- 1 | package triangulo.simetrico; 2 | 3 | import java.util.Scanner; 4 | 5 | public class TrianguloSimétrico { 6 | public static void main(String[] args) { 7 | Scanner input = new Scanner(System.in); 8 | System.out.println("Deseja uma pirâmide com quantas linhas? "); 9 | int linhas = input.nextInt(); 10 | gerarTriangulo(linhas); 11 | input.close(); 12 | } 13 | 14 | public static void gerarTriangulo(int tamanho) { 15 | int i = 0; 16 | 17 | for (int linha = 1; linha <= tamanho; linha++) { 18 | i++; 19 | System.out.println(" ".repeat(tamanho - linha) + "*".repeat(i * 2 - 1) + " ".repeat(tamanho - linha)); 20 | } 21 | } 22 | } 23 | 24 | -------------------------------------------------------------------------------- /nivel1/025-ArraySomentePositivos/src/positivos/ArraySomentePositivos.java: -------------------------------------------------------------------------------- 1 | package positivos; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.Scanner; 6 | 7 | public class ArraySomentePositivos { 8 | public static void main(String[] args) { 9 | Scanner scanner = new Scanner(System.in); 10 | int[] numerosInformados = new int[10]; 11 | 12 | for (int i = 0; i < numerosInformados.length; i++) { 13 | System.out.print("Informe o " + (i + 1) + "° número: "); 14 | numerosInformados[i] = scanner.nextInt(); 15 | } 16 | 17 | int[] numerosPositivos = Arrays.stream(numerosInformados).filter(n -> n > 0).toArray(); 18 | 19 | System.out.println("Array de positivos: " + Arrays.toString(numerosPositivos)); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /nivel2/034-LambdaStringParaMaiusculas/src/string/para/maiusculas/LambdaStringParaMaiusculas.java: -------------------------------------------------------------------------------- 1 | package string.para.maiusculas; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.stream.Collectors; 6 | 7 | public class LambdaStringParaMaiusculas { 8 | public static void main(String[] args) { 9 | List nomes = Arrays.asList("ana", "gui", "lia", "bia", "carlos", "josé"); 10 | nomes.stream() 11 | .map(String::toUpperCase) 12 | .forEach(System.out::println); 13 | 14 | List listaNomesMaiusculos = nomes.stream() 15 | .map(String::toUpperCase) 16 | .collect(Collectors.toList()); 17 | 18 | System.out.println("\nLista final em maiúsculas: " + listaNomesMaiusculos); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /nivel2/027-NormalizarTexto/src/normalizar/texto/NormalizarTexto.java: -------------------------------------------------------------------------------- 1 | package normalizar.texto; 2 | 3 | import java.text.Normalizer; 4 | import java.util.Scanner; 5 | 6 | public class NormalizarTexto { 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | 10 | System.out.print("Informe um texto que deseja normalizar: "); 11 | String textoDigitado = scanner.nextLine(); 12 | 13 | String semAcentos = Normalizer.normalize(textoDigitado, Normalizer.Form.NFD) 14 | .replaceAll("\\p{M}", ""); // O regex \\p{M} remove todos os diacríticos (acentos, cedilhas etc.). 15 | 16 | String normalizado = semAcentos.toLowerCase(); 17 | 18 | System.out.println("\nTexto normalizado:"); 19 | System.out.println(normalizado); 20 | 21 | scanner.close(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /nivel2/040-LambdaPercorrerListaInteiros/src/percorrerlista/PercorrerListaInteiros.java: -------------------------------------------------------------------------------- 1 | package percorrerlista; 2 | 3 | import java.util.Arrays; 4 | import java.util.Iterator; 5 | import java.util.List; 6 | 7 | public class PercorrerListaInteiros { 8 | public static void main(String[] args) { 9 | List inteiros = Arrays.asList(1,2,3,4,5,6,7,8,9, 10); 10 | 11 | // Parte 1: Usando Iterator 12 | System.out.println("Percorrendo com Interator: "); 13 | Iterator iterator = inteiros.iterator(); 14 | while (iterator.hasNext()) { 15 | Integer numero = iterator.next(); 16 | System.out.println(numero); 17 | } 18 | 19 | // Parte 2: Usando Stream 20 | System.out.println("\nPercorrendo com Stream:"); 21 | inteiros.stream().forEach(System.out::println); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /nivel3/008-SomaComLaco/src/soma/SomaComLaco.java: -------------------------------------------------------------------------------- 1 | package soma; 2 | 3 | import java.util.Scanner; 4 | 5 | public class SomaComLaco { 6 | public static void main(String[] args) { 7 | /** 8 | * 032. Soma até número negativo 9 | * O programa deve somar os números digitados 10 | * até que o usuário informe um número negativo. 11 | */ 12 | Scanner scanner = new Scanner(System.in); 13 | 14 | int soma = 0; 15 | int valor = 0; 16 | 17 | while (valor >= 0) { 18 | System.out.print("Informe um valor inteiro (negativo para sair): "); 19 | valor = scanner.nextInt(); 20 | if (valor >= 0) { 21 | soma += valor; 22 | } 23 | } 24 | System.out.printf("\nA soma dos valores é: " + soma); 25 | scanner.close(); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /nivel1/003-ZooJavaPoo/src/services/Zoologico.java: -------------------------------------------------------------------------------- 1 | package services; 2 | 3 | import models.Animal; 4 | import java.util.ArrayList; 5 | import java.util.List; 6 | 7 | public class Zoologico { 8 | private List animais; 9 | 10 | public Zoologico() { 11 | this.animais = new ArrayList<>(); 12 | } 13 | 14 | public void adicionarAnimal(Animal animal) { 15 | animais.add(animal); 16 | } 17 | 18 | public void listarAnimaisEmitirSom() { 19 | for (Animal animal : animais) { 20 | animal.emitirSom(); 21 | } 22 | } 23 | } 24 | 25 | //Cria uma lista de Animal, que pode armazenar tanto Leao quanto Macaco → polimorfismo. 26 | //adicionarAnimal(): adiciona um novo animal. 27 | //listarAnimaisEmitindoSom(): percorre a lista e chama emitirSom() (cada animal se comporta de forma diferente, mesmo método → polimorfismo na prática). -------------------------------------------------------------------------------- /nivel3/014-InverterNumero/src/inverter/numero/InverterNumero.java: -------------------------------------------------------------------------------- 1 | package inverter.numero; 2 | 3 | import java.util.Scanner; 4 | 5 | public class InverterNumero { 6 | /** 7 | * 038. Inverter número inteiro 8 | * Digite: 12345 9 | * Saída: 54321 10 | * (Dica: use while com % e /) 11 | */ 12 | 13 | public static void main(String[] args) { 14 | Scanner scanner = new Scanner(System.in); 15 | 16 | System.out.println("==== INVERSOR DE NÚMEROS ===="); 17 | System.out.print("Informe um número inteiro: "); 18 | int numero = scanner.nextInt(); 19 | 20 | System.out.print("Número invertido: "); 21 | while (numero !=0) { 22 | int digito = numero % 10; 23 | numero = numero / 10; 24 | 25 | System.out.print(digito); 26 | } 27 | 28 | scanner.close(); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /nivel1/003-ZooJavaPoo/src/models/Animal.java: -------------------------------------------------------------------------------- 1 | package models; 2 | 3 | public abstract class Animal { 4 | private String nomeCientifico; 5 | private String som; 6 | 7 | //Construtor 8 | public Animal(String nomeCientifico, String som) { 9 | this.nomeCientifico = nomeCientifico; 10 | this.som = som; 11 | } 12 | 13 | //Getters 14 | public String getNomeCientifico(){ 15 | return nomeCientifico; 16 | } 17 | 18 | public String getSom(){ 19 | return som; 20 | } 21 | 22 | //Método abstrato (para ser implementado nas subclasses) 23 | public abstract void emitirSom(); 24 | } 25 | 26 | //abstract: essa classe não pode ser instanciada diretamente. 27 | //Atributos privados ➝ encapsulamento. 28 | //Construtor: obriga a passar nome e som ao criar um animal. 29 | //emitirSom() é abstrato → cada animal implementa o som do seu jeito. -------------------------------------------------------------------------------- /nivel1/002-SomarNumerosUnicos/src/Main.java: -------------------------------------------------------------------------------- 1 | import java.util.HashMap; 2 | import java.util.Map; 3 | 4 | public class Main { 5 | 6 | public static int somarNumerosUnicos(int[] numeros) { 7 | Map frequencia = new HashMap<>(); 8 | for(int num : numeros) { 9 | frequencia.put(num, frequencia.getOrDefault(num, 0)+ 1); 10 | } 11 | 12 | int soma = 0; 13 | for (Map.Entry entrada : frequencia.entrySet()) { 14 | if (entrada.getValue() == 1) { 15 | soma += entrada.getKey(); 16 | } 17 | } 18 | 19 | return soma; 20 | } 21 | 22 | public static void main(String[] args) { 23 | int[] numeros = {2, 3, 4, 2, 4}; 24 | int resultado = somarNumerosUnicos(numeros); 25 | System.out.println("Soma dos números únicos: " + resultado); 26 | } 27 | } -------------------------------------------------------------------------------- /nivel2/022-MinimoMultiploComum/src/minimo/multiplo/comum/MinimoMultiploComum.java: -------------------------------------------------------------------------------- 1 | package minimo.multiplo.comum; 2 | 3 | import java.util.Scanner; 4 | 5 | public class MinimoMultiploComum { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | System.out.print("Digite o primeiro número: "); 9 | int a = scanner.nextInt(); 10 | System.out.print("Digite o segundo número: "); 11 | int b = scanner.nextInt(); 12 | 13 | int maximoDivisorComum = calcularMDC(a, b); 14 | int minimoMultiploComum = (a * b) / maximoDivisorComum; 15 | 16 | System.out.println("MMC de " + a + " e " + b + " é: " + minimoMultiploComum); 17 | } 18 | 19 | // Método recursivo do MDC 20 | public static int calcularMDC(int a, int b) { 21 | if (b == 0) return a; 22 | return calcularMDC(b, a % b); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /nivel2/048-SkipLimitInteiros/src/skiplimit/SkipLimitInteiros.java: -------------------------------------------------------------------------------- 1 | package skiplimit; 2 | 3 | import java.util.List; 4 | import java.util.stream.Collectors; 5 | import java.util.stream.IntStream; 6 | 7 | public class SkipLimitInteiros { 8 | public static void main(String[] args) { 9 | // Exemplo: números de 1 a 30 10 | List numeros = IntStream.rangeClosed(1,30) 11 | .boxed() 12 | .collect(Collectors.toList()); 13 | 14 | // Pular os 5 primeiros e pegar os 10 seguintes 15 | List resultado = numeros.stream() 16 | .skip(5) // pula 1,2,3,4,5 17 | .limit(10) // pega os próximos 10 (6..15) 18 | .collect(Collectors.toList()); 19 | 20 | System.out.println("Lista original: " + numeros); 21 | System.out.println("Resultado (skip 5, limit 10): " + resultado); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /outros/002-ConversorBinarioDecimal/src/conversor/binario/decimal/Conversor.java: -------------------------------------------------------------------------------- 1 | package conversor.binario.decimal; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Conversor { 6 | // Veja um conversor bacana em https://basesnumericas.pages.dev/conversor 7 | 8 | public static void main(String[] args) { 9 | Scanner input = new Scanner(System.in); 10 | System.out.println("Digite um numero: "); 11 | String numero = input.nextLine(); 12 | System.out.printf("%s (base 2) = %d (base 10)%n", numero, converter(numero)); 13 | input.close(); 14 | } 15 | 16 | public static long converter(String numero) { 17 | try { 18 | return Long.parseLong(numero, 2); 19 | } catch (NumberFormatException e) { 20 | System.out.println("Erro: o número informado não é binário!"); 21 | return -1; 22 | } 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /nivel2/021-MaximoDivisorComum/src/maximo/divisor/comum/MaximoDivisorComum.java: -------------------------------------------------------------------------------- 1 | package maximo.divisor.comum; 2 | 3 | import java.util.Scanner; 4 | 5 | public class MaximoDivisorComum { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | System.out.print("Digite o primeiro número: "); 9 | int a = scanner.nextInt(); 10 | System.out.print("Digite o segundo número: "); 11 | int b = scanner.nextInt(); 12 | 13 | int maximoDivisorComum = calcularMDC(a, b); 14 | System.out.println("O MDC de " + a + " e " + b + " é: " + maximoDivisorComum); 15 | } 16 | 17 | public static int calcularMDC(int a, int b) { 18 | // Caso base: quando o segundo número é 0, retornamos o primeiro 19 | if (b == 0) { 20 | return a; 21 | } 22 | // Chamada recursiva: MDC(b, a % b) 23 | return calcularMDC(b, a % b); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /nivel2/047-DistinctInteiros/src/distinctinteiros/DistinctInteiros.java: -------------------------------------------------------------------------------- 1 | package distinctinteiros; 2 | 3 | import java.util.*; 4 | import java.util.stream.Collectors; 5 | 6 | public class DistinctInteiros { 7 | public static void main(String[] args) { 8 | 9 | // 1) Usando Stream.distinct() 10 | List numeros = Arrays.asList(1,1,2,3,4,5,6,6,7,7,8,8,9,9,9,10); 11 | List unicos = numeros.stream() 12 | .distinct() 13 | .collect(Collectors.toList()); 14 | 15 | System.out.println("Original: " + numeros); 16 | System.out.println("Únicos (stream.distinct): " + unicos); 17 | 18 | // 2) Alternativa one-pass usando LinkedHashSet (preserva ordem) 19 | Set setUnicos = new LinkedHashSet<>(numeros); 20 | List unicosOnePass = new ArrayList<>(setUnicos); 21 | System.out.println("Únicos (LinkedHashSet one-pass): " + unicosOnePass); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /nivel2/007-Tabuada/src/tabuada/Tabuada.java: -------------------------------------------------------------------------------- 1 | package tabuada; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Tabuada { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | 9 | try { 10 | System.out.println("==== INICIALIZANDO PROGRAMA ===="); 11 | System.out.print("Digite um número para ver a tabuada: "); 12 | int numero = scanner.nextInt(); 13 | 14 | System.out.println("\nTabuada de " + numero + ":"); 15 | 16 | for (int i = 1; i <= 10; i++) { 17 | int resultado = numero * i; 18 | System.out.println(numero + " x " + i + " = " + resultado); 19 | } 20 | System.out.println("====================="); 21 | } catch (Exception e) { 22 | System.out.println("[ERRO!]Informe um número inteiro válido!"); 23 | } finally { 24 | scanner.close(); 25 | } 26 | } 27 | } -------------------------------------------------------------------------------- /nivel1/071-ArrayTamanho/src/tamanho/ObterTamanhoDoArray.java: -------------------------------------------------------------------------------- 1 | package tamanho; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | import java.util.Scanner; 6 | 7 | public class ObterTamanhoDoArray { 8 | public static void main(String[] args) { 9 | // Exemplo 1: array de inteiros 10 | int[] numeros = {1, 2, 3, 4, 5, 6}; 11 | System.out.println("Array de inteiros: " + java.util.Arrays.toString(numeros)); 12 | System.out.println("Tamanho: " + numeros.length); 13 | 14 | // Exemplo 2: array de Strings 15 | String[] nomes = {"Ana", "Beatriz", "Carlos"}; 16 | System.out.println("\nArray de Strings: " + java.util.Arrays.toString(nomes)); 17 | System.out.println("Tamanho: " + nomes.length); 18 | 19 | // Exemplo 3: array vazio 20 | double[] vazios = {}; 21 | System.out.println("\nArray vazio: " + java.util.Arrays.toString(vazios)); 22 | System.out.println("Tamanho: " + vazios.length); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /nivel1/030-ConversorHorario/src/conversor/horario/ConversorMinutosHoras.java: -------------------------------------------------------------------------------- 1 | package conversor.horario; 2 | 3 | import java.util.Scanner; 4 | 5 | public class ConversorMinutosHoras { 6 | 7 | public static void main(String[] args) { 8 | Scanner input = new Scanner(System.in); 9 | System.out.print("Digite quantos minutos deseja converter: "); 10 | int minutos = input.nextInt(); 11 | System.out.println(converterHorario(minutos)); 12 | input.close(); 13 | } 14 | 15 | public static String converterHorario(int minutos) { 16 | int hora = minutos / 60; 17 | int dias = 0; 18 | if (hora > 23) { 19 | dias = hora / 24; 20 | hora = hora % 24; 21 | } 22 | int minuto = minutos % 60; 23 | if (dias > 0) { 24 | return String.format("%d %s, %02d:%02d", dias, (dias == 1 ? "dia" : "dias"), hora, minuto); 25 | } 26 | return String.format("%02d:%02d", hora, minuto); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /nivel1/010-ApenasDigitosEmString/src/apenas/digitos/em/string/ApenasDigitosEmString.java: -------------------------------------------------------------------------------- 1 | package apenas.digitos.em.string; 2 | 3 | import java.util.Scanner; 4 | 5 | public class ApenasDigitosEmString { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | System.out.print("Informe uma string: "); 9 | String input = scanner.nextLine(); 10 | 11 | boolean somenteDigitos = true; 12 | 13 | for (int i = 0; i < input.length(); i++) { 14 | char c = input.charAt(i); 15 | if (c < '0' || c > '9') { // verifica se não é dígito 16 | somenteDigitos = false; 17 | break; // sai do laço assim que encontrar um não dígito 18 | } 19 | } 20 | 21 | if (somenteDigitos) { 22 | System.out.println("A string contém apenas dígitos."); 23 | } else { 24 | System.out.println("A string contém caracteres que não são dígitos."); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /nivel2/003-DuplicadosArray/src/duplicadosarray/Main.java: -------------------------------------------------------------------------------- 1 | package duplicadosarray; 2 | 3 | import java.util.*; 4 | 5 | public class Main { 6 | public static void main(String[] args) { 7 | 8 | int[] numeros = {1, 2, 2, 3, 4, 4, 5}; 9 | 10 | Set setSemDuplicados = new LinkedHashSet<>(); 11 | 12 | for (int num : numeros) { 13 | setSemDuplicados.add(num); 14 | } 15 | 16 | Integer[] resultado = setSemDuplicados.toArray(new Integer[0]); 17 | 18 | System.out.println("Array sem duplicados: " + Arrays.toString(resultado)); 19 | } 20 | } 21 | 22 | // Set Cria uma coleção que não aceita repetidos 23 | // LinkedHashSet Mantém a ordem original dos elementos 24 | // for (int num : numeros) Percorre cada número do array 25 | // setSemDuplicados.add(num) Adiciona ao Set, mas ignora os duplicados automaticamente 26 | // toArray(new Integer[0]) Transforma o Set de volta em um array 27 | // Arrays.toString(...) Converte o array para uma String bonitinha para impressão -------------------------------------------------------------------------------- /nivel3/012-NumeroPrimoComBreak/src/numero/primo/NumeroPrimoComBreak.java: -------------------------------------------------------------------------------- 1 | package numero.primo; 2 | 3 | import java.util.Scanner; 4 | 5 | public class NumeroPrimoComBreak { 6 | /** 7 | * 036. Número Primo com break 8 | * Dado um número, 9 | * verifique se é primo 10 | * interrompendo o laço assim que encontrar um divisor. 11 | */ 12 | 13 | public static void main(String[] args) { 14 | Scanner scanner = new Scanner(System.in); 15 | 16 | System.out.print("Informe um número inteiro positivo: "); 17 | int n = scanner.nextInt(); 18 | 19 | boolean ehPrimo = true; 20 | 21 | for (int i = 2; i < n; i++) { 22 | if (n % i == 0) { 23 | ehPrimo = false; 24 | break; 25 | } 26 | } 27 | 28 | if (ehPrimo) { 29 | System.out.println(n + " é primo."); 30 | } else { 31 | System.out.println(n + " NÃO é primo."); 32 | } 33 | 34 | scanner.close(); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /nivel1/039-LetraVogal/src/verificador/vogal/LetraVogal.java: -------------------------------------------------------------------------------- 1 | package verificador.vogal; 2 | 3 | import java.util.Scanner; 4 | 5 | public class LetraVogal { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | 9 | System.out.println("===== Verificador de Vogal ====="); 10 | System.out.print("Informe uma letra (a-z): "); 11 | String entrada = scanner.nextLine().trim(); 12 | 13 | if (entrada.length() != 1 || !Character.isLetter(entrada.charAt(0))){ 14 | System.out.println("[ERRO] Informe apenas uma letra válida!"); 15 | } else { 16 | char letra = Character.toLowerCase(entrada.charAt(0)); 17 | String vogais = "aeiou"; 18 | 19 | String resultado = vogais.contains(String.valueOf(letra)) 20 | ? letra + " é vogal!" 21 | : letra + " não é vogal!"; 22 | 23 | System.out.println(resultado); 24 | } 25 | 26 | scanner.close(); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /nivel1/024-ArrayInverterOrdem/src/inverter/ArrayInverterOrdem.java: -------------------------------------------------------------------------------- 1 | package inverter; 2 | 3 | import java.util.Arrays; 4 | import java.util.Collections; 5 | import java.util.Scanner; 6 | 7 | public class ArrayInverterOrdem { 8 | public static void main(String[] args) { 9 | Scanner scanner = new Scanner(System.in); 10 | Integer[] numeros = new Integer[10]; 11 | 12 | for (int i = 0; i < numeros.length; i++) { 13 | System.out.print("Informe o " + (i + 1) + "° número: "); 14 | 15 | while (!scanner.hasNextInt()) { 16 | System.out.print("Entrada inválida! Digite o " + (i + 1) + "° número inteiro: "); 17 | scanner.next(); 18 | } 19 | numeros[i] = scanner.nextInt(); 20 | } 21 | scanner.close(); 22 | 23 | System.out.println("Array Original: " + Arrays.toString(numeros)); 24 | 25 | Collections.reverse(Arrays.asList(numeros)); 26 | System.out.println("Array invertido: " + Arrays.toString(numeros)); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /nivel3/013-ContadorDeDigitos/src/contador/ContadorDeDigitos.java: -------------------------------------------------------------------------------- 1 | package contador; 2 | 3 | import java.util.Scanner; 4 | 5 | public class ContadorDeDigitos { 6 | 7 | /** 8 | * 037. Contar dígitos de um número 9 | * Peça um número inteiro 10 | * Conte quantos dígitos ele possui usando while. 11 | */ 12 | 13 | public static void main(String[] args) { 14 | Scanner scanner = new Scanner(System.in); 15 | 16 | System.out.print("Informe um número inteiro: "); 17 | int numero = scanner.nextInt(); 18 | 19 | if (numero == 0) { 20 | System.out.println("Quantidade de dígitos: 1"); 21 | } else { 22 | numero = Math.abs(numero); // Garante que o número seja positivo 23 | 24 | int contador = 0; 25 | 26 | while (numero != 0) { 27 | numero = numero / 10; 28 | contador++; 29 | } 30 | System.out.println("Quantidade de dígitos: " + contador); 31 | } 32 | scanner.close(); 33 | } 34 | } -------------------------------------------------------------------------------- /nivel3/019-NumeroArmstrong/src/numero/armstrong/NumeroArmstrong.java: -------------------------------------------------------------------------------- 1 | package numero.armstrong; 2 | 3 | import java.util.Scanner; 4 | 5 | public class NumeroArmstrong { 6 | public static void main(String[] args) { 7 | Scanner input = new Scanner(System.in); 8 | System.out.println("Digite um numero: "); 9 | int numero = input.nextInt(); 10 | if (checkArmstrong(numero)) { 11 | System.out.println("É Armstrong!"); 12 | } else { 13 | System.out.println("Não é!"); 14 | } 15 | input.close(); 16 | } 17 | 18 | public static boolean checkArmstrong(int numero) { 19 | String string = String.valueOf(numero); 20 | int tamanho = string.length(); 21 | int soma = 0; 22 | int num; 23 | for (int i = 0; i < string.length(); i++) { 24 | num = Integer.parseInt(string.charAt(i) + ""); 25 | soma += Math.pow(num, tamanho); 26 | } 27 | if (soma == numero) { 28 | return true; 29 | } 30 | return false; 31 | } 32 | } -------------------------------------------------------------------------------- /nivel1/031-DiasSemana/src/dias/semana/DiasSemana.java: -------------------------------------------------------------------------------- 1 | package dias.semana; 2 | 3 | import java.util.Scanner; 4 | 5 | public class DiasSemana { 6 | 7 | public static void main(String[] args) { 8 | Scanner input = new Scanner(System.in); 9 | System.out.print("Digite o numero do dia da semana: "); 10 | int numero = input.nextInt(); 11 | System.out.println(obterDiaSemana(numero)); 12 | } 13 | 14 | 15 | public static String obterDiaSemana(int numero) { 16 | switch (numero) { 17 | case 1: 18 | return "Domingo"; 19 | case 2: 20 | return "Segunda-feira"; 21 | case 3: 22 | return "Terça-feira"; 23 | case 4: 24 | return "Quarta-feira"; 25 | case 5: 26 | return "Quinta-feira"; 27 | case 6: 28 | return "Sexta-feira"; 29 | case 7: 30 | return "Sábado"; 31 | default: 32 | return "Número inválido"; 33 | } 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /nivel1/023-ArrayTemONumero/src/encontrar/numero/ArrayTemONumero.java: -------------------------------------------------------------------------------- 1 | package encontrar.numero; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class ArrayTemONumero { 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | 10 | System.out.print("Verifique se um número foi sorteado (Escolha entre 1 a 50): "); 11 | int[] numerosaleatorios = new int[20]; 12 | 13 | for (int i = 0; i < numerosaleatorios.length; i++) { 14 | numerosaleatorios[i] = (int) (Math.random() * 50 ) + 1; 15 | } 16 | 17 | int palpite = scanner.nextInt(); 18 | boolean existe = Arrays.stream(numerosaleatorios).anyMatch(n -> n == palpite); 19 | 20 | if (existe) { 21 | System.out.println("O número " + palpite + " foi encontrado no array!"); 22 | } else { 23 | System.out.println("\nO número não foi encontrado!"); 24 | } 25 | 26 | System.out.println("Números sorteados: " + Arrays.toString(numerosaleatorios)); 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /nivel3/010-GeradorDePotencia/src/potencia/GeradorDePotencia.java: -------------------------------------------------------------------------------- 1 | package potencia; 2 | 3 | import java.util.Scanner; 4 | 5 | public class GeradorDePotencia { 6 | /** 7 | * 034. Gerador de sequência: potências de 2 8 | * Peça um número n e exiba as potências de 2 até 2^n. 9 | * → Ex: Entrada: 5 → Saída: 1, 2, 4, 8, 16, 32 10 | */ 11 | 12 | public static void main(String[] args) { 13 | Scanner scanner = new Scanner(System.in); 14 | int n = 1; 15 | 16 | System.out.println("==== POTÊNCIA DE 2 ===="); 17 | System.out.print("Informe um número inteiro que representará até onde a sequência vai: "); 18 | n = scanner.nextInt(); 19 | 20 | for (int i = 0; i <= n; i++) { 21 | int resultado = (int) Math.pow(2, i); // Calcula 2^i 22 | if (i == n) { 23 | System.out.print(resultado); // Exibe sem a vírgula final 24 | } else { 25 | System.out.print(resultado + ", "); // Exibe com vírgula 26 | } 27 | } 28 | scanner.close(); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /nivel1/037-VerificarVoto/src/verificacao/voto/VerificarVoto.java: -------------------------------------------------------------------------------- 1 | package verificacao.voto; 2 | 3 | import java.util.Scanner; 4 | 5 | public class VerificarVoto { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | 9 | System.out.println("===== Verificação de Voto ====="); 10 | 11 | System.out.print("Informe sua idade: "); 12 | int idade = scanner.nextInt(); 13 | scanner.nextLine(); // consumir quebra de linha 14 | 15 | System.out.print("Você possui título de eleitor? (sim/não): "); 16 | String resposta = scanner.nextLine().trim().toLowerCase(); 17 | 18 | if (resposta.equals("não")) { resposta = "nao"; } // Normaliza "não" (com ou sem acento) 19 | 20 | boolean temTitulo = resposta.equals("sim") || resposta.equals("s"); 21 | 22 | if (idade >= 16 && idade <= 65 && temTitulo) { 23 | System.out.println("Pode votar normalmente."); 24 | } else { 25 | System.out.println("Não pode votar."); 26 | } 27 | 28 | scanner.close(); 29 | } 30 | } 31 | 32 | -------------------------------------------------------------------------------- /nivel2/012-CaixaEletronico/src/model/Conta.java: -------------------------------------------------------------------------------- 1 | package model; 2 | 3 | public class Conta { 4 | private double saldo; 5 | 6 | public Conta () { 7 | this.saldo = 0.0; 8 | } 9 | 10 | public double getSaldo() { 11 | return saldo; 12 | } 13 | 14 | public void depositar(double valor) { 15 | if (valor > 0) { 16 | saldo += valor; 17 | System.out.println("Depósito de R$" + valor + " realizado com sucesso."); 18 | } else { 19 | System.out.println("Valor inválido para depósito."); 20 | } 21 | } 22 | 23 | public void sacar(double valor) { 24 | if (valor <= 0) { 25 | System.out.println("Valor inválido para saque."); 26 | } else if (valor > saldo) { 27 | System.out.println("[ERRO] Saldo insuficiente!"); 28 | } else { 29 | saldo -= valor; 30 | System.out.println("Saque de R$" + valor + " realizado com sucesso."); 31 | } 32 | } 33 | public void exibirSaldo() { 34 | System.out.printf("Saldo atual: R$ %.2f%n", saldo); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /nivel1/019-ArrayNumerosImpares/src/impares/ArrayNumerosImpares.java: -------------------------------------------------------------------------------- 1 | package impares; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | 6 | public class ArrayNumerosImpares { 7 | public static void main(String[] args) { 8 | 9 | //Array aleatório de números entre 1 a 100 10 | int tamanho = 10; 11 | int[] numeros = new int[tamanho]; 12 | for (int i = 0; i < tamanho; i++) { 13 | numeros[i] = (int) (Math.random() * 100) + 1; // Gera número de 1 a 100 14 | } 15 | 16 | System.out.println("======== NÚMEROS ÍMPARES ========"); 17 | 18 | ArrayList impares = new ArrayList<>(); 19 | 20 | int contadorImpares = 0; 21 | for (int numero : numeros) { 22 | if (numero % 2 != 0) { 23 | contadorImpares++; 24 | impares.add(numero); 25 | } 26 | } 27 | 28 | System.out.println("Array aleatório: " + Arrays.toString(numeros)); 29 | System.out.println("Quantidade: " + contadorImpares); 30 | System.out.println("Ímpares: " + impares); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2025 Piter Gomes 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /nivel1/020-ArrayNomes/src/nomes/ArrayNomes.java: -------------------------------------------------------------------------------- 1 | package nomes; 2 | 3 | import java.util.Scanner; 4 | 5 | public class ArrayNomes { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | String[] nomes = new String[5]; 9 | 10 | System.out.println("Informe 5 nomes. Apenas letras são aceitas!"); 11 | 12 | for (int i = 0; i < nomes.length; i++) { 13 | System.out.print((i + 1) + "° nome: "); 14 | String entrada = scanner.nextLine().trim(); 15 | 16 | if (entrada.isEmpty() || !entrada.matches("[\\p{L} ]+")) { //usar \\p{L} representa qualquer letra Unicode, incluindo acentos 17 | System.out.println("ERRO! Informe apenas letras."); 18 | i--; // repete esta posição 19 | continue; 20 | } 21 | 22 | nomes[i] = entrada; 23 | } 24 | 25 | scanner.close(); 26 | 27 | // Imprimindo nomes 28 | System.out.println("\nNomes informados:"); 29 | for (String nome : nomes) { 30 | System.out.println(nome); 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /nivel3/005-MenuComDoWhile/src/menu/MenuComDoWhile.java: -------------------------------------------------------------------------------- 1 | package menu; 2 | 3 | import java.util.Scanner; 4 | 5 | public class MenuComDoWhile { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | 9 | int opcao; 10 | 11 | do { 12 | System.out.println("\nEscolha uma opção do Menu:"); 13 | System.out.println("[1] Ver saldo"); 14 | System.out.println("[2] Depositar"); 15 | System.out.println("[3] Sair"); 16 | System.out.print("Opção: "); 17 | 18 | opcao = scanner.nextInt(); 19 | 20 | if (opcao == 1) { 21 | System.out.println("Saldo: 1.000,00R$"); 22 | } else if (opcao == 2) { 23 | System.out.println("Depósito efetuado com sucesso!"); 24 | } else if (opcao != 3) { 25 | System.out.println("Informe uma opção válida!"); 26 | } 27 | } while (opcao != 3); 28 | 29 | System.out.println("Finalizando menu..."); 30 | System.out.println("Volte sempre!"); 31 | scanner.close(); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /nivel1/006-NumeroPrimo/src/numeroprimo/Main.java: -------------------------------------------------------------------------------- 1 | package numeroprimo; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Main { 6 | public static boolean ehPrimo(int numero) { 7 | if (numero < 1) return false; 8 | for (int i = 2; i <= Math.sqrt(numero); i++) { 9 | if (numero % i == 0) return false; 10 | } 11 | return true; 12 | } 13 | 14 | public static void main(String[] args) { 15 | Scanner scanner = new Scanner(System.in); 16 | 17 | try { 18 | System.out.println("==== VERIFICADOR DE NÚMERO PRIMO ===="); 19 | System.out.printf("Digite um número: "); 20 | int numero = scanner.nextInt(); 21 | 22 | System.out.print("RESULTADO: "); 23 | if (ehPrimo(numero)) { 24 | System.out.print(numero + " é primo!"); 25 | } else { 26 | System.out.print(numero + " NÃO é primo!"); 27 | } 28 | } catch (Exception e) { 29 | System.out.println("Entrada inválida! Digite apenas números inteiros."); 30 | } finally { 31 | scanner.close(); 32 | } 33 | } 34 | } -------------------------------------------------------------------------------- /nivel2/009-ContadorDePalavras/src/contador/de/palavras/ContadorDePalavras.java: -------------------------------------------------------------------------------- 1 | package contador.de.palavras; 2 | 3 | import java.util.Scanner; 4 | 5 | public class ContadorDePalavras { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | 9 | try { 10 | System.out.print("Digite uma frase: "); 11 | String frase = scanner.nextLine(); 12 | 13 | String[] palavras = frase.trim().split("\\s+"); 14 | 15 | int contador = (frase.trim().isEmpty()) ? 0 : palavras.length; 16 | 17 | System.out.println("Quantidade de palavras: " + contador); 18 | } catch (Exception e) { 19 | System.out.println("[ERRO!] Digite palavras para formar uma frase!"); 20 | } finally { 21 | scanner.close(); 22 | } 23 | } 24 | } 25 | 26 | /* 27 | `trim()` remove espaços do começo e fim da string. 28 | `split("\\s+")` divide a frase em palavras usando um ou mais espaços como separador (\\s+ significa “um ou mais espaços”). 29 | A verificação `frase.trim().isEmpty()` evita contar uma palavra se o usuário só digitou espaços. 30 | */ -------------------------------------------------------------------------------- /nivel1/007-InverterString/src/inverterstring/Main.java: -------------------------------------------------------------------------------- 1 | package inverterstring; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Main { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | 9 | try { 10 | System.out.println(" ===== INVERTER UMA STRING ===== "); 11 | System.out.print("Digite uma palavra ou frase: "); 12 | String texto = scanner.nextLine(); 13 | 14 | String textoInvertido = new StringBuilder(texto).reverse().toString(); 15 | String textoMinusculo = texto.toLowerCase(); 16 | String textoMaiusculo = texto.toUpperCase(); 17 | 18 | System.out.println("\n*** RESULTADOS ***"); 19 | System.out.println("Original: " + texto); 20 | System.out.println("Invertido: " + textoInvertido); 21 | System.out.println("Minúsculas: " + textoMinusculo); 22 | System.out.println("Maiúsculas: " + textoMaiusculo); 23 | 24 | } catch (Exception e) { 25 | System.out.println("Erro ao ler o texto."); 26 | } finally { 27 | scanner.close(); 28 | } 29 | } 30 | } -------------------------------------------------------------------------------- /nivel1/021-ArrayMediaDoAluno/src/media/ArrayMediaDoAluno.java: -------------------------------------------------------------------------------- 1 | package media; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class ArrayMediaDoAluno { 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | double[] notas = new double[5]; 10 | 11 | System.out.println("Informe suas 5 notas e saiba sua média!"); 12 | 13 | for (int i = 0; i < notas.length; i++) { 14 | System.out.print("Informe a " + (i + 1) + "ª nota: "); 15 | 16 | while (!scanner.hasNextDouble()) { 17 | System.out.print("Entrada inválida! Digite a " + (i + 1) + "ª nota: "); 18 | scanner.next(); // descarta a entrada inválida 19 | } 20 | 21 | notas[i] = scanner.nextDouble(); 22 | } 23 | scanner.close(); 24 | 25 | System.out.println("Suas notas: " + Arrays.toString(notas)); 26 | 27 | double soma = 0; 28 | for (double nota : notas) { 29 | soma += nota; 30 | } 31 | double media = soma / notas.length; 32 | System.out.println("Sua média: " + media); 33 | 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /nivel3/009-NumeroPerfeito/src/numero/perfeito/NumeroPerfeito.java: -------------------------------------------------------------------------------- 1 | package numero.perfeito; 2 | 3 | import java.util.Scanner; 4 | 5 | public class NumeroPerfeito { 6 | public static void main(String[] args) { 7 | /** 8 | * 033. Verificar número perfeito 9 | * Um número é perfeito se a soma dos seus divisores próprios 10 | * (excluindo ele mesmo) for igual a ele. 11 | * → Ex: 6 → 1 + 2 + 3 = 6 12 | */ 13 | 14 | Scanner scanner = new Scanner(System.in); 15 | 16 | System.out.println("==== Número Perfeito ===="); 17 | System.out.print("Informe um número inteiro: "); 18 | int numeroDigitado = scanner.nextInt(); 19 | 20 | int soma = 0; 21 | 22 | for (int i = 1; i < numeroDigitado; i++) { 23 | if (numeroDigitado % i == 0) { 24 | soma += i; 25 | } 26 | } 27 | 28 | if (soma == numeroDigitado) { 29 | System.out.printf("O número %d é perfeito!", numeroDigitado); 30 | } else { 31 | System.out.printf("O número %d não é perfeito!", numeroDigitado); 32 | } 33 | scanner.close(); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /nivel3/022-Cronometro/src/cronometro/Cronometro.java: -------------------------------------------------------------------------------- 1 | package cronometro; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Cronometro { 6 | 7 | public static void main(String[] args) throws InterruptedException { 8 | Scanner input = new Scanner(System.in); 9 | System.out.println("Quer um contador de quantos segundos? "); 10 | int segundos = input.nextInt(); 11 | iniciarCronometro(segundos); 12 | } 13 | 14 | public static void iniciarCronometro(int segundos) throws InterruptedException { 15 | int segundosContador = 0; 16 | while(true){ 17 | System.out.println(formatarHorario(segundosContador)); 18 | segundosContador++; 19 | Thread.sleep(1000); 20 | if(segundosContador > segundos){ 21 | break; 22 | } 23 | } 24 | System.out.println("FIM!"); 25 | } 26 | 27 | private static String formatarHorario(int segundos) { 28 | int horas = segundos / 3600; 29 | int minutos = (segundos % 3600) / 60; 30 | int segs = segundos % 60; 31 | return String.format("%02d:%02d:%02d", horas, minutos, segs); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /nivel2/026-MediaPonderada/src/media/ponderada/MediaPonderada.java: -------------------------------------------------------------------------------- 1 | package media.ponderada; 2 | 3 | import java.util.Scanner; 4 | 5 | public class MediaPonderada { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | 9 | System.out.print("Informe a quantidade de notas: "); 10 | int qtdNotas = scanner.nextInt(); 11 | 12 | double somaNotasPesos = 0; 13 | double somaPesos = 0; 14 | 15 | for (int i = 1; i <= qtdNotas; i++) { 16 | System.out.print("Digite a nota " + i + ": "); 17 | double nota = scanner.nextDouble(); 18 | 19 | System.out.print("Digite o peso: "); 20 | double peso = scanner.nextDouble(); 21 | 22 | somaNotasPesos += nota * peso; 23 | somaPesos += peso; 24 | } 25 | 26 | if (somaPesos > 0) { 27 | double mediaPonderada = somaNotasPesos / somaPesos; 28 | System.out.printf("Média ponderada = %.2f%n", mediaPonderada); 29 | } else { 30 | System.out.println("Erro: a soma dos pesos não pode ser zero."); 31 | } 32 | 33 | scanner.close(); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /nivel3/007-TabuadaEmLoop/src/tabuada/TabuadaEmLoop.java: -------------------------------------------------------------------------------- 1 | package tabuada; 2 | 3 | import java.util.Scanner; 4 | 5 | public class TabuadaEmLoop { 6 | public static void main(String[] args) { 7 | /** 8 | * 031. Tabuada de vários números 9 | * O usuário digita um número. 10 | * Mostre sua tabuada. 11 | * Depois pergunte se ele quer ver a de outro número. 12 | * Repita até ele digitar "n". 13 | */ 14 | Scanner scanner = new Scanner(System.in); 15 | 16 | String continuar = ""; 17 | 18 | do { 19 | System.out.print("\nInforme um número para ver a tabuada: "); 20 | int numero = scanner.nextInt(); 21 | 22 | for (int i = 1; i <= 10 ; i++) { 23 | int resultado = numero * i; 24 | System.out.printf("%d x %d = %d\n", numero, i, resultado); 25 | } 26 | 27 | System.out.print("\nDeseja ver a tabuada de outro número? [S] ou [N]: "); 28 | continuar = scanner.next().trim().toUpperCase(); 29 | 30 | } while (!continuar.equals("N")); 31 | System.out.println("\nFinalizando Tabuada..."); 32 | scanner.close(); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /nivel3/011-MediaDeNotasComLaco/src/media/MediaDeNotasComLaco.java: -------------------------------------------------------------------------------- 1 | package media; 2 | 3 | import java.util.Scanner; 4 | 5 | public class MediaDeNotasComLaco { 6 | /** 7 | * 035. Média de notas com laço 8 | * O usuário digita as notas dos alunos (até digitar -1). 9 | * Ao final, calcule e exiba a média das notas. 10 | */ 11 | public static void main(String[] args) { 12 | Scanner scanner = new Scanner(System.in); 13 | 14 | int contadorDeNotas = 0; 15 | double somatorioDasNotas = 0; 16 | double nota; 17 | 18 | do { 19 | System.out.print("Nota do aluno (-1 para calcular média): "); 20 | nota = scanner.nextDouble(); 21 | 22 | if (nota != -1) { 23 | somatorioDasNotas += nota; 24 | contadorDeNotas++; 25 | } 26 | 27 | } while (nota != -1); 28 | 29 | if (contadorDeNotas > 0) { 30 | double media = somatorioDasNotas / contadorDeNotas; 31 | System.out.println("\nA média do aluno é: " + media); 32 | } else { 33 | System.out.println("\nNenhuma nota válida foi inserida."); 34 | } 35 | scanner.close(); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /nivel2/015-SomarPositivos/src/somar/positivos/SomarPositivos.java: -------------------------------------------------------------------------------- 1 | package somar.positivos; 2 | 3 | import java.util.Scanner; 4 | 5 | public class SomarPositivos { 6 | 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | 10 | System.out.print("Digite números separados por espaço: "); 11 | String entrada = scanner.nextLine(); 12 | 13 | String[] partes = entrada.split(" "); 14 | int soma = 0; 15 | 16 | for (String parte : partes) { 17 | try { 18 | int numero = Integer.parseInt(parte); 19 | if (numero > 0) { 20 | soma += numero; 21 | } 22 | } catch (NumberFormatException e) { 23 | System.out.println("Ignorado valor inválido: " + parte); 24 | } 25 | } 26 | System.out.println("Soma dos números positivos: " + soma); 27 | scanner.close(); 28 | } 29 | } 30 | 31 | /** 32 | * split(" ") → separa a entrada do usuário. 33 | * Integer.parseInt() → converte cada string para número. 34 | * if (numero > 0) → garante que só positivos sejam somados. 35 | * try-catch → protege contra valores inválidos (ex: letras). 36 | */ -------------------------------------------------------------------------------- /nivel1/013-MaiorNumeroEmTres/src/maior/numero/em/tres/MaiorNumeroEmTres.java: -------------------------------------------------------------------------------- 1 | package maior.numero.em.tres; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Scanner; 5 | 6 | public class MaiorNumeroEmTres { 7 | public static void main(String[] args) { 8 | ArrayList listaNumeros = new ArrayList<>(); 9 | Scanner input = new Scanner(System.in); 10 | System.out.println("Digite 3 números:"); 11 | 12 | for (int i = 0; i < 3; i++) { 13 | try { 14 | double num = input.nextDouble(); 15 | listaNumeros.add(num); 16 | } catch (java.util.InputMismatchException e) { 17 | System.out.println("Valor inválido! Digite um número."); 18 | input.next(); 19 | i--; 20 | } 21 | } 22 | 23 | double maior = calcularMaiorNumero(listaNumeros.get(0), listaNumeros.get(1), listaNumeros.get(2)); 24 | System.out.printf("Maior: %.2f\n", maior); 25 | } 26 | 27 | public static double calcularMaiorNumero(double n1, double n2, double n3) { 28 | double maior = n1; 29 | if (n2 > maior) maior = n2; 30 | if (n3 > maior) maior = n3; 31 | return maior; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /nivel1/015-ArrayImprimirCincoNumerosInteiros/src/imprimir/cinco/numeros/inteiros/ArrayImprimirCincoNumerosInteiros.java: -------------------------------------------------------------------------------- 1 | package imprimir.cinco.numeros.inteiros; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class ArrayImprimirCincoNumerosInteiros { 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | int[] elementos = new int[5]; // Criando array 10 | 11 | // Preenchendo o array com os números informados pelo usuário 12 | for (int i = 0; i < elementos.length; i++) { 13 | System.out.print("Informe o " + (i + 1) + "° número inteiro: "); 14 | 15 | // Enquanto não for um inteiro válido, continue pedindo 16 | while (!scanner.hasNextInt()) { 17 | System.out.print("Entrada inválida! Digite o " + (i + 1) + "° número inteiro: "); 18 | scanner.next(); // descarta a entrada inválida 19 | } 20 | elementos[i] = scanner.nextInt(); // Armazena se inteiro válido 21 | } 22 | scanner.close(); 23 | 24 | // Exibindo os números armazenados no array 25 | System.out.println("\nNúmeros informados: " + Arrays.toString(elementos)); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /nivel2/010-PrimeiroCaractereRepetido/src/primeiro/caractere/repetido/PrimeiroCaractereRepetido.java: -------------------------------------------------------------------------------- 1 | package primeiro.caractere.repetido; 2 | 3 | import java.util.HashSet; 4 | import java.util.Scanner; 5 | import java.util.Set; 6 | 7 | public class PrimeiroCaractereRepetido { 8 | public static void main(String[] args) { 9 | Scanner scanner = new Scanner(System.in); 10 | System.out.print("Digite uma frase: "); 11 | String texto = scanner.nextLine(); 12 | 13 | Character repetido = encontrarPrimeiroRepetido(texto); 14 | 15 | if (repetido != null) { 16 | System.out.println("O primeiro caractere repetido é: '" + repetido + "'"); 17 | } else { 18 | System.out.println("Nenhum caractere se repete."); 19 | } 20 | scanner.close(); 21 | } 22 | 23 | public static Character encontrarPrimeiroRepetido(String texto) { 24 | Set vistos = new HashSet<>(); 25 | 26 | for (char c : texto.toLowerCase().toCharArray()) { 27 | if (c == ' ') continue; 28 | 29 | if (vistos.contains(c)) { 30 | return c; 31 | } 32 | vistos.add(c); 33 | } 34 | return null; // nenhum repetido 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /nivel1/042-QuadradoDeUmNumero/src/calcular/quadrado/CalcularQuadrado.java: -------------------------------------------------------------------------------- 1 | package calcular.quadrado; 2 | 3 | import java.util.InputMismatchException; 4 | import java.util.Scanner; 5 | 6 | public class CalcularQuadrado { 7 | 8 | public static void main(String[] args) { 9 | 10 | // Ler valor 11 | double n = lerValor("Digite o valor que deseja elevar ao quadrado: "); 12 | 13 | // Calcular 14 | double resultado = calcularNumeroAoQuadrado(n); 15 | 16 | // Exibir resultado 17 | System.out.printf("Resultado: %.2f ao quadrado é %.2f%n", n, resultado); 18 | } 19 | 20 | // Método que lê o número 21 | public static double lerValor(String mensagem) { 22 | Scanner scanner = new Scanner(System.in); 23 | 24 | while (true) { 25 | try { 26 | System.out.print(mensagem); 27 | return scanner.nextDouble(); 28 | } catch (InputMismatchException e) { 29 | System.out.println("[ERRO!] Somente números são aceitos!"); 30 | scanner.nextLine(); // limpa o buffer 31 | } 32 | } 33 | } 34 | 35 | // Método que calcula o número ao quadrado 36 | public static double calcularNumeroAoQuadrado(double n) { 37 | return n * n; 38 | } 39 | } -------------------------------------------------------------------------------- /nivel1/009-OperacoesAritmeticas/src/operacoes/aritmeticas/OperacoesAritmeticas.java: -------------------------------------------------------------------------------- 1 | package operacoes.aritmeticas; 2 | 3 | import java.util.Scanner; 4 | 5 | public class OperacoesAritmeticas { 6 | 7 | // Método que recebe dois números e mostra os resultados das operações 8 | public static void calcularOperacoes(double a, double b) { 9 | System.out.println("Soma: " + (a + b)); 10 | System.out.println("Subtração: " + (a - b)); 11 | System.out.println("Multiplicação: " + (a * b)); 12 | 13 | if (b != 0) { 14 | System.out.println("Divisão: " + (a / b)); 15 | } else { 16 | System.out.println("Divisão: ERRO! não é possível dividir por zero."); 17 | } 18 | } 19 | 20 | public static void main(String[] args) { 21 | Scanner scanner = new Scanner(System.in); 22 | 23 | System.out.println("==== Calculadora ===="); 24 | System.out.print("Informe o primeiro número: "); 25 | double a = scanner.nextDouble(); 26 | System.out.print("Informe o segundo número: "); 27 | double b = scanner.nextDouble(); 28 | 29 | System.out.printf("\nResultados entre %.1f e %.1f:", a, b); 30 | System.out.println(); 31 | calcularOperacoes(a, b); 32 | 33 | scanner.close(); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /nivel1/032-CalculadoraIMC/src/calculadora/imc/CalculadoraIMC.java: -------------------------------------------------------------------------------- 1 | package calculadora.imc; 2 | 3 | import java.util.Locale; 4 | import java.util.Scanner; 5 | 6 | public class CalculadoraIMC { 7 | 8 | public static void main(String[] args) { 9 | Scanner input = new Scanner(System.in); 10 | input.useLocale(Locale.forLanguageTag("pt-BR")); 11 | System.out.print("Digite seu peso: (kg) "); 12 | double peso = input.nextDouble(); 13 | System.out.print("Digite sua altura: (m) "); 14 | double altura = input.nextDouble(); 15 | double imc = calcularIMC(peso, altura); 16 | System.out.printf("Seu IMC: %.3f%n", imc); 17 | System.out.println(classificarIMC(imc)); 18 | input.close(); 19 | } 20 | 21 | 22 | public static String classificarIMC(double imc) { 23 | if(imc < 18.5){ 24 | return "Magreza"; 25 | }else if(imc < 25 ){ 26 | return "Normal"; 27 | }else if(imc < 30){ 28 | return "Sobrepeso"; 29 | }else if(imc < 40){ 30 | return "Obesidade"; 31 | }else{ 32 | return "Obesidade Grave"; 33 | } 34 | } 35 | 36 | public static double calcularIMC(double peso, double altura) { 37 | return peso / (altura * altura); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /nivel2/013-ValidadorDeSenha/src/validador/de/senha/ValidadorDeSenha.java: -------------------------------------------------------------------------------- 1 | package validador.de.senha; 2 | 3 | import java.util.Scanner; 4 | 5 | public class ValidadorDeSenha { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | System.out.println("==== VALIDADOR DE SENHA ===="); 9 | System.out.print("Digite a senha: "); 10 | String senha = scanner.nextLine(); 11 | 12 | boolean tamanhoOk = senha.length() >= 8; 13 | boolean temMaiuscula = senha.matches(".*[A-Z].*"); 14 | boolean temNumero = senha.matches(".*[0-9].*"); 15 | boolean temEspecial = senha.matches(".*[!@#$%^&*()_+\\-={}:;\"',.<>?/].*"); 16 | 17 | if (tamanhoOk && temMaiuscula && temNumero && temEspecial) { 18 | System.out.println("Senha forte!"); 19 | } else { 20 | System.out.println("Senha fraca. Requisitos:"); 21 | if (!tamanhoOk) System.out.println("- Insira pelo menos 8 caracteres!"); 22 | if (!temMaiuscula) System.out.println("- Insira pelo 1 letra maiúscula!"); 23 | if (!temNumero) System.out.println("- Insira pelo menos 1 número!"); 24 | if (!temEspecial) System.out.println("- Insira pelo menos 1 caractere especial!"); 25 | } 26 | scanner.close(); 27 | } 28 | } 29 | 30 | -------------------------------------------------------------------------------- /nivel2/002-Fibonacci/src/fibonacci/Main.java: -------------------------------------------------------------------------------- 1 | package fibonacci; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Main { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | try{ 9 | System.out.println("=== Sequência de Fibonacci ===="); 10 | System.out.print("Digite o número de termos da sequência de Fibonacci: "); 11 | int n = scanner.nextInt(); 12 | 13 | if (n <= 0) { 14 | System.out.println("Por favor, digite um número positivo."); 15 | return; 16 | } 17 | 18 | System.out.println("***** RESULTADO *****"); 19 | System.out.println("Sequência de Fibonacci com " + n + " termos:"); 20 | 21 | int primeiro = 0; 22 | int segundo = 1; 23 | 24 | for (int i = 0; i < n; i++) { // Garante imprimir n termos da sequência 25 | System.out.print(primeiro + " "); 26 | int proximo = primeiro + segundo; // Soma dos dois anteriores 27 | primeiro = segundo; 28 | segundo = proximo; 29 | } 30 | } catch (Exception e) { 31 | System.out.println("Erro: digite um número inteiro válido."); 32 | } finally { 33 | scanner.close(); 34 | } 35 | } 36 | } -------------------------------------------------------------------------------- /nivel2/046-MinMaxNomesPorTamanho/src/minmaxnomes/MinMaxNomesPorTamanho.java: -------------------------------------------------------------------------------- 1 | package minmaxnomes; 2 | 3 | import java.util.Arrays; 4 | import java.util.Comparator; 5 | import java.util.List; 6 | import java.util.Optional; 7 | 8 | public class MinMaxNomesPorTamanho { 9 | public static void main(String[] args) { 10 | List nomes = Arrays.asList("Ana", "Beatriz", "Carlos", "João", "Felipe", "Z"); 11 | 12 | // Comparator: primeiro por tamanho, depois por ordem lexicográfica (para desempate) 13 | Comparator lengthThenLex = Comparator 14 | .comparingInt(String::length) 15 | .thenComparing(Comparator.naturalOrder()); 16 | 17 | Optional menor = nomes.stream().min(lengthThenLex); 18 | Optional maior = nomes.stream().max(lengthThenLex); 19 | 20 | System.out.println("Lista: " + nomes); 21 | 22 | menor.ifPresentOrElse( 23 | s -> System.out.println("Menor: " + s + " (tamanho= " + s.length() + ")"), 24 | () -> System.out.println("Lista vazia — nenhum menor.") 25 | ); 26 | 27 | maior.ifPresentOrElse( 28 | s -> System.out.println("Maior: " + s + " (tamanho= " + s.length() + ")"), 29 | () -> System.out.println("Lista vazia — nenhum maior.") 30 | ); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /nivel2/043-ReduceProdutoInteiros/src/reduceproduto/ReduceProdutoInteiros.java: -------------------------------------------------------------------------------- 1 | package reduceproduto; 2 | 3 | import java.util.Arrays; 4 | import java.util.Collections; 5 | import java.util.List; 6 | import java.util.Optional; 7 | 8 | public class ReduceProdutoInteiros { 9 | public static void main(String[] args) { 10 | List numeros = Arrays.asList(1,2,3,4,5); 11 | 12 | // 1) Usando reduce com identidade 13 | int produtoComIdentidade = numeros.stream() 14 | .reduce(1, (a,b) -> a * b); 15 | System.out.println("Produto (com identidade): " + produtoComIdentidade); 16 | 17 | // 2) Usando reduce sem identidade (retorna Optional) 18 | Optional produtoOpcional = numeros.stream() 19 | .reduce((a,b) -> a * b); 20 | produtoOpcional.ifPresentOrElse( 21 | p -> System.out.println("Produto (Optional): " + p), 22 | () -> System.out.println("Lista vazia — sem produto definido") 23 | ); 24 | 25 | // 3) Exemplo com lista vazia (mostra comportamento com identidade) 26 | List vazia = Collections.emptyList(); 27 | int produtoVazia = vazia.stream() 28 | .reduce(1, (a,b) -> a * b); 29 | System.out.println("Produto (lista vazia, com identidade): " + produtoVazia); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /nivel1/014-CalcularMediaLista/src/calcular/media/lista/CalcularMediaLista.java: -------------------------------------------------------------------------------- 1 | package calcular.media.lista; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Scanner; 5 | 6 | public class CalcularMediaLista { 7 | public static void main(String[] args) { 8 | ArrayList lista = new ArrayList<>(); 9 | Scanner input = new Scanner(System.in); 10 | System.out.println("Digite vários números para descobrir a média!"); 11 | System.out.println("Para parar de digitar, escreva um caractere não numérico!"); 12 | double num; 13 | while (true) { 14 | String linha = input.nextLine(); 15 | if (linha.isEmpty()) break; 16 | try { 17 | num = Double.parseDouble(linha); 18 | lista.add(num); 19 | } catch (NumberFormatException e) { 20 | System.out.println("Entrada inválida, digite um número!"); 21 | } 22 | } 23 | input.close(); 24 | double media = calcularMedia(lista); 25 | System.out.printf("Média: %.2f%n", media); 26 | } 27 | 28 | public static double calcularMedia(ArrayList lista) { 29 | if (lista.isEmpty()) return 0; 30 | double soma = lista.stream().mapToDouble(Double::doubleValue).sum(); 31 | double media = soma / lista.size(); 32 | return media; 33 | } 34 | } -------------------------------------------------------------------------------- /nivel3/004-NumeroSecreto/src/numero/secreto/NumeroSecreto.java: -------------------------------------------------------------------------------- 1 | package numero.secreto; 2 | 3 | import java.util.Random; 4 | import java.util.Scanner; 5 | 6 | public class NumeroSecreto { 7 | public static void main(String[] args) { 8 | 9 | /** 10 | * Armazene um número secreto e peça tentativas até o usuário acertar. 11 | * Diga se o número digitado é maior ou menor. 12 | */ 13 | 14 | Scanner scanner = new Scanner(System.in); 15 | 16 | Random random = new Random(); 17 | int numeroSorteado = random.nextInt(100 18 | ); 19 | 20 | int valor = 0; 21 | 22 | System.out.println("=== Jogo da Adivinhação! ==="); 23 | while (numeroSorteado != valor) { 24 | System.out.print("\nInforme um número de 1 a 100: "); 25 | valor = scanner.nextInt(); 26 | if (numeroSorteado > valor) { 27 | System.out.println("[ERROU!]" + valor + " é MENOR que o valor sorteado!"); 28 | } else if (numeroSorteado < valor) { 29 | System.out.println("[ERROU!]" + valor + " é MAIOR que o valor sorteado!"); 30 | } else { 31 | System.out.println("[ACERTOU!] PARABÉNS! o valor sorteado foi: " + numeroSorteado); 32 | } 33 | } 34 | System.out.println("Finalizando jogo..."); 35 | scanner.close(); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /nivel3/006-ContaNumeros/src/conta/numeros/ContaNumeros.java: -------------------------------------------------------------------------------- 1 | package conta.numeros; 2 | 3 | import java.util.Scanner; 4 | 5 | public class ContaNumeros { 6 | public static void main(String[] args) { 7 | /** 8 | * 030. Contar números negativos, positivos e zeros 9 | * O usuário digita 10 números. 10 | * Conte quantos são negativos, positivos ou zero. 11 | */ 12 | Scanner scanner = new Scanner(System.in); 13 | 14 | int contador = 0; 15 | int contadorNegativos = 0; 16 | int contadorPositivos = 0; 17 | int contadorZeros = 0; 18 | 19 | do { 20 | System.out.printf("Informe o %dº número: ", contador + 1); 21 | int valor = scanner.nextInt(); 22 | 23 | if (valor < 0) { 24 | contadorNegativos++; 25 | } else if (valor > 0) { 26 | contadorPositivos++; 27 | } else if (valor == 0) { 28 | contadorZeros++; 29 | } 30 | contador++; 31 | } while (contador != 10); 32 | 33 | System.out.printf("\nAo todo foram digitados: "); 34 | System.out.printf("\n%d números negativos.", contadorNegativos); 35 | System.out.printf("\n%d números positivos.", contadorPositivos); 36 | System.out.printf("\n%d números zeros.", contadorZeros); 37 | scanner.close(); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /nivel1/005-Fatorial/src/fatorial/Main.java: -------------------------------------------------------------------------------- 1 | package fatorial; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Main { 6 | 7 | public static long calcularFatorial(int n) { 8 | long fatorial = 1; 9 | System.out.print(n + "! = "); 10 | for (int i = n; i >= 1; i--) { 11 | fatorial *= i; 12 | System.out.print(i); 13 | if (i > 1) { 14 | System.out.print(" x "); 15 | } 16 | } 17 | System.out.print(" = "); // Parte final antes do resultado 18 | return fatorial; 19 | } 20 | 21 | public static void main(String[] args) { 22 | Scanner scanner = new Scanner(System.in); 23 | 24 | try { 25 | System.out.println("===== F A T O R I A L ====="); 26 | System.out.print("Digite um número inteiro positivo: "); 27 | int numero = scanner.nextInt(); 28 | 29 | if (numero < 0) { 30 | System.out.println("Não é possível calcular fatorial de número negativo."); 31 | } else { 32 | long resultado = calcularFatorial(numero); 33 | System.out.println(resultado); 34 | } 35 | 36 | } catch (Exception e) { 37 | System.out.println("Entrada inválida! Digite apenas números inteiros."); 38 | } finally { 39 | scanner.close(); 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /nivel2/008-VerificarAnagramas/src/verificar/anagramas/VerificarAnagramas.java: -------------------------------------------------------------------------------- 1 | package verificar.anagramas; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class VerificarAnagramas { 7 | public static boolean ehAnagrama (String str1, String str2) { 8 | if (str1 == null || str2 == null || str1.length() != str2.length()) { 9 | return false; 10 | } 11 | 12 | char[] charArray1 = str1.toLowerCase().toCharArray(); 13 | char[] charArray2 = str2.toLowerCase().toCharArray(); 14 | 15 | Arrays.sort(charArray1); 16 | Arrays.sort(charArray2); 17 | 18 | return Arrays.equals(charArray1, charArray2); 19 | } 20 | 21 | public static void main(String[] args) { 22 | Scanner scanner = new Scanner(System.in); 23 | try { 24 | System.out.println("==== ANAGRAMA? ==== "); 25 | System.out.print("Primeira palavra: "); 26 | String palavra1 = scanner.nextLine(); 27 | System.out.print("Segunda palavra: "); 28 | String palavra2 = scanner.nextLine(); 29 | 30 | System.out.println(palavra1 + " e " + palavra2 + " são anagramas? " + ehAnagrama(palavra1, palavra2)); 31 | } catch (Exception e) { 32 | System.out.println("[ERRO!] Informe uma palavra válida!"); 33 | } finally { 34 | scanner.close(); 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /nivel2/028-SimuladorDeEstoque/src/simulador/estoque/Produto.java: -------------------------------------------------------------------------------- 1 | package simulador.estoque; 2 | 3 | public class Produto { 4 | String nome; 5 | int quantidade; 6 | 7 | // Construtor 8 | public Produto(String nome, int quantidade) { 9 | this.nome = nome; 10 | this.quantidade = quantidade; 11 | } 12 | 13 | // Getters 14 | public String getNome() { 15 | return nome; 16 | } 17 | 18 | public int getQuantidade() { 19 | return quantidade; 20 | } 21 | 22 | // Adicionar quantidade 23 | public void adicionar(int qtd) { 24 | if (qtd > 0) { 25 | quantidade += qtd; 26 | System.out.println(qtd + " unidade(s) adicionada(s) ao estoque."); 27 | } else { 28 | System.out.println("[ERRO] Quantidade deve ser maior que 0!"); 29 | } 30 | } 31 | 32 | // Remover quantidade 33 | public void remover(int qtd){ 34 | if (qtd <= 0) { 35 | System.out.println("[ERRO] Quantidade deve ser maior que 0!"); 36 | } else if (qtd > quantidade) { 37 | System.out.println("[ERRO] Estoque insuficiente!"); 38 | } else { 39 | quantidade -= qtd; 40 | System.out.println(qtd + " unidade(s) removida(s) do estoque."); 41 | } 42 | } 43 | 44 | @Override 45 | public String toString() { 46 | return String.format("Produto: %-20s | Estoque: %d", nome, quantidade); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /nivel1/040-CondicoesBooleanas/src/condicoes/booleanas/CondicoesBooleanas.java: -------------------------------------------------------------------------------- 1 | package condicoes.booleanas; 2 | 3 | import java.util.Scanner; 4 | 5 | public class CondicoesBooleanas { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | 9 | System.out.print("Está chovendo? (sim/não): "); 10 | String chovendo = scanner.nextLine().trim().toLowerCase(); 11 | System.out.print("Vai passear com o cachorro? (sim/não): "); 12 | String passearComOCachorro = scanner.nextLine().trim().toLowerCase(); 13 | 14 | // Normaliza "não" com acento 15 | if (chovendo.equals("não")) { chovendo = "nao"; } 16 | if (passearComOCachorro.equals("não")) { passearComOCachorro = "nao"; } 17 | 18 | // Converte respostas em booleanos 19 | boolean estaChovendo = chovendo.equals("sim") || chovendo.equals("s"); 20 | boolean vaiPassearComCachorro = passearComOCachorro.equals("sim") || passearComOCachorro.equals("s"); 21 | 22 | // Resultado usando operador ternário (&& e || ) e operadores lógicos (? :) 23 | String resultado = (estaChovendo && vaiPassearComCachorro) ? "Ambas as condições são verdadeiras." 24 | : (estaChovendo || vaiPassearComCachorro) ? "Apenas uma condição é verdadeira." 25 | : "Nenhuma das condições é verdadeira."; 26 | 27 | System.out.println(resultado); 28 | 29 | scanner.close(); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /nivel1/004-ContadorDeVogais/src/contador/Main.java: -------------------------------------------------------------------------------- 1 | package contador; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Main { 6 | 7 | /* Converte tudo para minúsculas para facilitar a comparação 8 | Inicializa o contador 9 | Percorre todos os caracteres da string 10 | Verifica se o caractere é uma vogal 11 | Retorna o total de vogais encontradas */ 12 | 13 | public static int contarVogais(String texto) { 14 | texto = texto.toLowerCase(); 15 | int contador = 0; 16 | for (int i = 0; i < texto.length(); i++) { 17 | char c = texto.charAt(i); 18 | if (c == 'a' || c == 'e' || c == 'i' || c == 'o' 19 | || c == 'u' || c == 'á' || c == 'à' || c == 'é' 20 | || c == 'í' || c == 'ó' || c == 'ú') { 21 | contador ++; 22 | } 23 | } 24 | return contador; 25 | } 26 | 27 | /* Método principal para testar o código: 28 | Cria o scanner 29 | Lê a linha inteira com espaços 30 | Mostra o resultado 31 | Fecha o scanner */ 32 | 33 | public static void main(String[] args) { 34 | Scanner scanner = new Scanner(System.in); 35 | System.out.println("=== Contador de Vogais ==="); 36 | System.out.print("Digite uma palavra ou frase: "); 37 | String entrada = scanner.nextLine(); 38 | int resultado = contarVogais(entrada); 39 | System.out.println("Total de vogais: " + resultado); 40 | scanner.close(); 41 | } 42 | } -------------------------------------------------------------------------------- /nivel2/029-GeradorMegaSena/src/gerador/megasena/Gerador.java: -------------------------------------------------------------------------------- 1 | package gerador.megasena; 2 | 3 | import java.util.Random; 4 | import java.util.Set; 5 | import java.util.TreeSet; 6 | 7 | public class Gerador { 8 | 9 | public static void main(String[] args){ 10 | System.out.println("Simples: " + gerarSimples()); 11 | System.out.println("==="); 12 | System.out.println("Ordenado: " + gerarOrdenado()); 13 | } 14 | 15 | 16 | public static String gerarSimples(){ 17 | String numero = ""; 18 | int cont = 0; 19 | Random random = new Random(); 20 | while(cont < 6){ 21 | int numeroTemporario = random.nextInt(59) + 1; 22 | if(!numero.contains(Integer.toString(numeroTemporario))){ 23 | numero += numeroTemporario + ", "; 24 | cont++; 25 | } 26 | } 27 | numero = numero.substring(0, numero.length() - 2); 28 | return numero; 29 | } 30 | 31 | public static String gerarOrdenado(){ 32 | Random random = new Random(); 33 | Set numeros = new TreeSet<>(); 34 | 35 | while(numeros.size() < 6){ 36 | int numeroTemporario = random.nextInt(59) + 1; 37 | numeros.add(numeroTemporario); 38 | } 39 | 40 | StringBuilder sb = new StringBuilder(); 41 | 42 | for(int numero: numeros){ 43 | sb.append(numero).append(", "); 44 | } 45 | sb.setLength(sb.length()-2); 46 | return sb.toString(); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /nivel2/001-SomaDosDigitos/src/somadosdigitos/Main.java: -------------------------------------------------------------------------------- 1 | package somadosdigitos; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Main { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | try { 9 | System.out.println("==== Soma dos Dígitos ===="); 10 | System.out.print("Digite um número positivo: "); 11 | int numero = scanner.nextInt(); 12 | 13 | if (numero < 0) { 14 | System.out.println("Número negativo! Digite apenas positivos."); 15 | return; 16 | } 17 | 18 | int soma = 0; 19 | while (numero > 0) { 20 | soma += numero % 10; // pega o último dígito 21 | numero /= 10; // remove o último dígito (Atalho: numero = numero / 10;) 22 | } 23 | 24 | /* 2a Possibilidade: 25 | String numeroStr = String.valueOf(numero); //Converte o número para String 26 | for (int i = 0; i < numeroStr.length(); i++) { 27 | char c = numeroStr.charAt(i); // Pega cada caractere da string 28 | int digito = Character.getNumericValue(c); // Converte o caractere para número (ex: '3' → 3) 29 | soma += digito; // Vai somando cada dígito 30 | } */ 31 | 32 | System.out.println("Soma dos dígitos: " + soma); 33 | 34 | } catch (Exception e) { 35 | System.out.println("Erro: digite um número inteiro válido."); 36 | } finally { 37 | scanner.close(); 38 | } 39 | 40 | } 41 | } -------------------------------------------------------------------------------- /nivel2/018-ClassificacaoTriangulos/src/classificacao/triangulos/ClassificacaoTriangulos.java: -------------------------------------------------------------------------------- 1 | /* Crie uma função que recebe os comprimentos dos três lados de um triângulo 2 | /* e retorne sua classificação quanto ao tamanho de seus lados. 3 | */ 4 | 5 | package classificacao.triangulos; 6 | 7 | import java.util.Scanner; 8 | 9 | public class ClassificacaoTriangulos { 10 | 11 | public static void definirTipoDeTriangulo(double l1, double l2, double l3) { 12 | // Verificação de existência do triângulo 13 | if (l1 + l2 <= l3 || l1 + l3 <= l2 || l2 + l3 <= l1) { 14 | System.out.println("ERRO! Impossível formar um triângulo."); 15 | return; 16 | } 17 | 18 | // Classificação 19 | if (l1 == l2 && l2 == l3) { 20 | System.out.println("Triângulo Equilátero formado!"); 21 | } else if (l1 == l2 || l2 == l3 || l1 == l3) { 22 | System.out.println("Triângulo Isósceles formado!"); 23 | } else { 24 | System.out.println("Triângulo Escaleno formado!"); 25 | } 26 | } 27 | 28 | public static void main(String[] args) { 29 | Scanner scanner = new Scanner(System.in); 30 | 31 | System.out.print("Informe o primeiro lado: "); 32 | double l1 = scanner.nextDouble(); 33 | System.out.print("Informe o segundo lado: "); 34 | double l2 = scanner.nextDouble(); 35 | System.out.print("Informe o terceiro lado: "); 36 | double l3 = scanner.nextDouble(); 37 | 38 | definirTipoDeTriangulo(l1, l2, l3); 39 | 40 | scanner.close(); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /nivel2/023-BuscaBinaria/src/busca/binaria/BuscaBinaria.java: -------------------------------------------------------------------------------- 1 | package busca.binaria; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class BuscaBinaria { 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | 10 | int tamanhoArray = lerNumero(scanner, "Digite o número de elementos do array: "); 11 | 12 | int[] array = new int[tamanhoArray]; 13 | for (int i = 0; i < tamanhoArray; i++) { 14 | array[i] = lerNumero(scanner, "Digite o " + (i + 1) + "° elemento: "); 15 | } 16 | 17 | Arrays.sort(array); 18 | System.out.println("Array em ordem crescente: " + Arrays.toString(array)); 19 | 20 | int elementoAlvo = lerNumero(scanner, "\nDigite o elemento alvo: "); 21 | 22 | int indiceEncontrado = Arrays.binarySearch(array, elementoAlvo); 23 | 24 | if (indiceEncontrado >= 0) { 25 | System.out.println("Elemento encontrado na posição (índice): " + indiceEncontrado); 26 | } else { 27 | System.out.println("Elemento não encontrado no array."); 28 | } 29 | 30 | scanner.close(); 31 | } 32 | 33 | // 🔹 Método auxiliar para ler somente números inteiros 34 | public static int lerNumero(Scanner scanner, String mensagem) { 35 | System.out.print(mensagem); 36 | while (!scanner.hasNextInt()) { 37 | System.out.print("Entrada inválida! Digite apenas números: "); 38 | scanner.next(); // descarta a entrada inválida 39 | } 40 | return scanner.nextInt(); 41 | } 42 | } -------------------------------------------------------------------------------- /nivel1/078-ClassificacaoIdade/src/classificacao/ClassificacaoIdade.java: -------------------------------------------------------------------------------- 1 | package classificacao; 2 | 3 | import java.util.Scanner; 4 | 5 | public class ClassificacaoIdade { 6 | 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | 10 | int idade = lerIdadeValida(scanner); 11 | 12 | String classificacao; 13 | if (idade <= 12) { 14 | classificacao = "Criança"; 15 | } else if (idade <= 17) { 16 | classificacao = "Adolescente"; 17 | } else if (idade <= 64) { 18 | classificacao = "Adulto"; 19 | } else { 20 | classificacao = "Idoso"; 21 | } 22 | 23 | System.out.println("Classificação: " + classificacao); 24 | 25 | scanner.close(); 26 | } 27 | 28 | private static int lerIdadeValida(Scanner scanner) { 29 | int idade; 30 | 31 | System.out.println("==== Classificador de Idade ===="); 32 | 33 | while (true) { 34 | System.out.print("Digite a idade da pessoa (0 a 120): "); 35 | 36 | try { 37 | idade = scanner.nextInt(); 38 | if (idade < 0 || idade > 120) { 39 | System.out.println("[ERRO!] Idade fora do intervalo válido. Tente novamente."); 40 | } else { 41 | return idade; 42 | } 43 | } catch (Exception e) { 44 | System.out.println("[ERRO!] Entrada inválida. Informe um número inteiro."); 45 | scanner.nextLine(); 46 | } 47 | } 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /nivel2/031-GeradorSenha/src/gerador/senha/GeradorSenha.java: -------------------------------------------------------------------------------- 1 | package gerador.senha; 2 | 3 | import java.util.Random; 4 | import java.util.Scanner; 5 | 6 | public class GeradorSenha { 7 | 8 | private static final Random random = new Random(); 9 | 10 | private static final String LETRAS_MINUSCULAS = "abcdefghijklmnopqrstuvwxyz"; 11 | private static final String LETRAS_MAIUSCULAS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 12 | private static final String DIGITOS = "0123456789"; 13 | private static final String SIMBOLOS = "!@#$%^&*()-_=+[]{}\\\\|;:'\\\",.<>?/"; 14 | 15 | public static void main(String[] args) { 16 | Scanner input = new Scanner(System.in); 17 | System.out.print("Deseja uma senha de quantos dígitos? "); 18 | int tamanho = input.nextInt(); 19 | System.out.println("Sua senha: " + gerarSenha(tamanho)); 20 | input.close(); 21 | } 22 | 23 | public static String gerarSenha(int tamanho) { 24 | StringBuilder senha = new StringBuilder(); 25 | 26 | for (int i = 0; i < tamanho; i++) { 27 | int escolha = random.nextInt(4); // agora vai de case 0 até 3 28 | switch (escolha) { 29 | case 0 -> senha.append(LETRAS_MAIUSCULAS.charAt(random.nextInt(LETRAS_MAIUSCULAS.length()))); 30 | case 1 -> senha.append(LETRAS_MINUSCULAS.charAt(random.nextInt(LETRAS_MINUSCULAS.length()))); 31 | case 2 -> senha.append(SIMBOLOS.charAt(random.nextInt(SIMBOLOS.length()))); 32 | case 3 -> senha.append(DIGITOS.charAt(random.nextInt(DIGITOS.length()))); 33 | } 34 | } 35 | return senha.toString(); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /nivel1/041-AreaRetangulo/src/area/retangulo/CalcularAreaRetangulo.java: -------------------------------------------------------------------------------- 1 | package area.retangulo; 2 | 3 | import java.util.InputMismatchException; 4 | import java.util.Scanner; 5 | 6 | public class CalcularAreaRetangulo { 7 | 8 | public static void main(String[] args) { 9 | 10 | //Ler valores 11 | double base = lerValor("Digite a base do retângulo:"); 12 | double altura = lerValor("Digite a altura do retângulo:"); 13 | 14 | // Calcular área 15 | double area = calcularArea(base, altura); 16 | 17 | // Exibir resultado 18 | System.out.println("A área do retângulo é: " + area); 19 | } 20 | 21 | // Método para ler um valor double do usuário 22 | public static double lerValor(String mensagem) { 23 | Scanner scanner = new Scanner(System.in); 24 | double valor = -1; 25 | 26 | while (true) { 27 | try { 28 | System.out.println(mensagem); 29 | valor = scanner.nextDouble(); 30 | 31 | if (valor < 0) { 32 | System.out.println("Erro: o valor não pode ser negativo. Tente novamente.\n"); 33 | } else { 34 | return valor; // valor válido 35 | } 36 | } catch (InputMismatchException e) { 37 | System.out.println("Entrada inválida! Digite apenas números.\n"); 38 | scanner.nextLine(); // limpa o buffer 39 | } 40 | } 41 | } 42 | 43 | // Método que recebe base e altura e devolve a área 44 | public static double calcularArea(double base, double altura) { 45 | return base * altura; 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /nivel2/012-CaixaEletronico/src/app/Main.java: -------------------------------------------------------------------------------- 1 | package app; 2 | 3 | import model.Conta; 4 | 5 | import java.util.Scanner; 6 | 7 | public class Main { 8 | public static void main(String[] args) { 9 | Scanner scanner = new Scanner(System.in); 10 | Conta conta = new Conta(); 11 | 12 | int opcao; 13 | 14 | do { 15 | System.out.println("\n=== Caixa Eletrônico ==="); 16 | System.out.println("1 - Ver saldo"); 17 | System.out.println("2 - Depositar"); 18 | System.out.println("3 - Sacar"); 19 | System.out.println("0 - Sair"); 20 | System.out.print("Escolha uma opção: "); 21 | opcao = scanner.nextInt(); 22 | 23 | switch (opcao) { 24 | case 1: 25 | conta.exibirSaldo(); 26 | break; 27 | case 2: 28 | System.out.print("Digite o valor para depositar: "); 29 | double valorDepositado = scanner.nextDouble(); 30 | conta.depositar(valorDepositado); 31 | break; 32 | case 3: 33 | System.out.print("Digite o valor para sacar: "); 34 | double valorSaque = scanner.nextDouble(); 35 | conta.sacar(valorSaque); 36 | break; 37 | case 0: 38 | System.out.println("Saindo... Obrigado por usar o Caixa Eletrônico!"); 39 | break; 40 | default: 41 | System.out.println("Opção inválida!"); 42 | } 43 | } while (opcao !=0); 44 | scanner.close(); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /nivel1/029-SetRemoverNomesRepetidos/src/remover/repetidos/SetRemoverNomesRepetidos.java: -------------------------------------------------------------------------------- 1 | package remover.repetidos; 2 | 3 | import java.util.*; 4 | 5 | public class SetRemoverNomesRepetidos { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | Set nomes = new LinkedHashSet<>(); // LinkedHashSet<>() para manter a ordem 9 | Map normalizados = new HashMap<>(); // Map para controlar case-insensitive e manter a primeira forma digitada 10 | 11 | System.out.println("Informe os nomes (ENTER vazio para encerrar)."); 12 | 13 | int contador = 1; 14 | while (true) { 15 | System.out.print(contador + "° nome: "); 16 | String nome = scanner.nextLine().trim(); 17 | 18 | if (nome.isEmpty()) { 19 | System.out.println("Encerrando..."); 20 | break; 21 | } 22 | 23 | String chave = nome.toLowerCase(); // normaliza para comparar sem case 24 | if (!normalizados.containsKey(chave)) { 25 | normalizados.put(chave, nome); // mantém primeira forma digitada 26 | nomes.add(nome); // adiciona no Set 27 | contador++; // incrementa só se realmente adicionou 28 | } else { 29 | System.out.println("[Aviso] Nome duplicado ignorado: " + nome); 30 | } 31 | } 32 | scanner.close(); 33 | 34 | if (!nomes.isEmpty()) { 35 | System.out.println("\n==== Lista de Nomes Sem Repetições ===="); 36 | for (String nome: nomes) { 37 | System.out.println(nome); 38 | } 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /nivel2/014-ElementosRepetidos/src/elementos/repetidos/ElementosRepetidos.java: -------------------------------------------------------------------------------- 1 | package elementos.repetidos; 2 | 3 | import java.util.LinkedHashSet; 4 | import java.util.Scanner; 5 | import java.util.Set; 6 | 7 | public class ElementosRepetidos { 8 | public static void main(String[] args) { 9 | Scanner scanner = new Scanner(System.in); 10 | 11 | System.out.println("Digite os números separados por espaço:"); 12 | String entrada = scanner.nextLine(); 13 | 14 | // Quebra a entrada por espaços e converte para inteiros 15 | String[] partes = entrada.split(" "); 16 | Set unicos = new LinkedHashSet<>(); 17 | 18 | for (String parte : partes) { 19 | try{ 20 | int numero = Integer.parseInt(parte); 21 | unicos.add(numero); // adiciona ao LinkedHashSet (sem duplicados) 22 | } catch (NumberFormatException e) { 23 | System.out.println("Ignorado valor inválido: " + parte); 24 | } 25 | } 26 | System.out.println("Sem duplicados:"); 27 | for (int num : unicos) { 28 | System.out.print(num + " "); 29 | } 30 | scanner.close(); 31 | } 32 | } 33 | 34 | /** 35 | * | Componente | Função | 36 | * | --------------- | -------------------------------------------------------------------- | 37 | * | `LinkedHashSet` | Armazena elementos únicos mantendo a ordem original | 38 | * | `for-each` loop | Adiciona cada elemento do array no `Set` | 39 | * | `Set` | Usado no lugar de `List` para eliminar os duplicados automaticamente | 40 | */ -------------------------------------------------------------------------------- /nivel1/016-ArraySomarElementosInteiros/src/somar/ArraySomarElementosInteiros.java: -------------------------------------------------------------------------------- 1 | package somar; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Scanner; 5 | 6 | public class ArraySomarElementosInteiros { 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | ArrayList elementos = new ArrayList<>(); // ArrayList para tamanho dinâmico 10 | 11 | System.out.println("========= SOMANDO NÚMEROS INTEIROS ========="); 12 | System.out.println("Digite números inteiros. Pressione ENTER sem digitar nada para parar."); 13 | 14 | while (true) { 15 | System.out.print("Informe um número inteiro: "); 16 | String entrada = scanner.nextLine().trim(); // O método trim() remove todos os espaços em branco no início e no fim da String. 17 | 18 | if (entrada.isEmpty()) { // Condição para parar (Enter) 19 | break; 20 | } 21 | 22 | try { 23 | int numero = Integer.parseInt(entrada); // Converte a entrada para inteiro 24 | elementos.add(numero); // Adiciona ao ArrayList 25 | } catch (NumberFormatException e) { 26 | System.out.println("Entrada inválida! Digite apenas números inteiros."); 27 | } 28 | } 29 | scanner.close(); 30 | 31 | // Exibindo os números armazenados no ArrayList 32 | System.out.println("\nNúmeros informados: " + elementos); 33 | 34 | // Calculando a soma 35 | int soma = 0; 36 | for (int numero : elementos) { 37 | soma += numero; 38 | } 39 | 40 | System.out.println("Soma dos números informados: " + soma); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /nivel1/018-ArrayNumerosPares/src/pares/ArrayNumerosPares.java: -------------------------------------------------------------------------------- 1 | package pares; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | import java.util.Scanner; 6 | 7 | public class ArrayNumerosPares { 8 | public static void main(String[] args) { 9 | Scanner scanner = new Scanner(System.in); 10 | int[] elementos = new int[10]; 11 | 12 | System.out.println("========= NÚMEROS PARES ========="); 13 | System.out.println("Informe 10 valores inteiros."); 14 | 15 | // Preenchendo o array com os números informados pelo usuário 16 | for (int i = 0; i < elementos.length; i++) { 17 | System.out.print((i + 1) + "º valor: "); 18 | 19 | // Enquanto não for um inteiro válido, continue pedindo 20 | while (!scanner.hasNextInt()) { 21 | System.out.print("Entrada inválida! Digite o " + (i + 1) + "° valor: "); 22 | scanner.next(); // descarta a entrada inválida 23 | } 24 | elementos[i] = scanner.nextInt(); // Armazena se o valor for inteiro 25 | } 26 | scanner.close(); 27 | 28 | // Exibindo os números armazenados no array 29 | System.out.println("\nValores informados: " + Arrays.toString(elementos)); 30 | 31 | // Criando ArrayList de valores pares 32 | ArrayList pares = new ArrayList<>(); 33 | 34 | // Verificando números pares e adicionando no ArrayList 35 | for (int numero : elementos){ 36 | if (numero % 2 == 0) { 37 | pares.add(numero); 38 | } 39 | } 40 | 41 | // Exibindo somente os valores pares do array original 42 | System.out.println("Valores pares: " + pares); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /nivel2/016-OrdenarArrayDeInteiros/src/ordenar/inteiros/OrdenarArrayDeInteiros.java: -------------------------------------------------------------------------------- 1 | package ordenar.inteiros; 2 | 3 | import java.util.Scanner; 4 | 5 | public class OrdenarArrayDeInteiros { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | 9 | System.out.println("Digite números inteiros separados por espaço:"); 10 | String[] entrada = scanner.nextLine().split(" "); 11 | int[] numeros = new int[entrada.length]; 12 | 13 | // Convertendo os valores para inteiros 14 | for (int i = 0; i < entrada.length; i++) { 15 | numeros[i] = Integer.parseInt(entrada[i]); 16 | } 17 | 18 | // Algoritmo Bubble Sort 19 | for (int i = 0; i < numeros.length - 1; i++) { 20 | for (int j = 0; j < numeros.length - 1 - i; j++) { 21 | if (numeros[j] > numeros[j + 1]) { 22 | // Trocar os elementos 23 | int temp = numeros[j]; 24 | numeros[j] = numeros[j + 1]; 25 | numeros[j + 1] = temp; 26 | } 27 | } 28 | } 29 | 30 | /* 31 | // Resolução mais simples com Arrays.sort() ao invés do Algoritmo Bubble Sort 32 | Arrays.sort(numeros); 33 | */ 34 | 35 | // Exibindo o array ordenado 36 | System.out.println("Array ordenado:"); 37 | for (int num : numeros) { 38 | System.out.print(num + " "); 39 | } 40 | 41 | scanner.close(); 42 | } 43 | } 44 | 45 | /** 46 | * Leitura da entrada do usuário via Scanner. 47 | * Conversão para int[]. 48 | * Ordenação manual usando o algoritmo Bubble Sort. 49 | * Exibição dos números já ordenados. 50 | */ 51 | -------------------------------------------------------------------------------- /nivel2/019-Potencia/src/potencia/Potencia.java: -------------------------------------------------------------------------------- 1 | package potencia; 2 | 3 | import java.util.InputMismatchException; 4 | import java.util.Scanner; 5 | 6 | public class Potencia { 7 | 8 | public static double calcularPotencia(double base, double expoente) { 9 | if (expoente == 0) { 10 | return 1.0; 11 | } 12 | if (base == 0 && expoente < 0) { 13 | throw new IllegalArgumentException("Não é possível calcular 0 elevado a um expoente negativo (divisão por zero)."); 14 | } 15 | return Math.pow(base, expoente); 16 | } 17 | 18 | // Método auxiliar para ler números com validação 19 | public static double lerNumero(Scanner scanner, String mensagem) { 20 | while (true) { 21 | try { 22 | System.out.print(mensagem); 23 | return scanner.nextDouble(); 24 | } catch (InputMismatchException e) { 25 | System.out.println("Entrada inválida! Digite apenas números."); 26 | scanner.nextLine(); // descarta a entrada errada para evitar loop infinito 27 | } 28 | } 29 | } 30 | 31 | public static void main(String[] args) { 32 | try (Scanner scanner = new Scanner(System.in)) { 33 | 34 | double base = lerNumero(scanner, "Informe o número base: "); 35 | double expoente = lerNumero(scanner, "Informe o expoente: "); 36 | 37 | try { 38 | double resultado = calcularPotencia(base, expoente); 39 | System.out.printf("Resultado: %.4f%n", resultado); 40 | } catch (IllegalArgumentException e) { 41 | System.out.println("Erro: " + e.getMessage()); 42 | } 43 | } 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /nivel1/012-CelsiusFahrenheit/src/celsius/fahrenheit/CelsiusFahrenheit.java: -------------------------------------------------------------------------------- 1 | package celsius.fahrenheit; 2 | 3 | import java.util.Scanner; 4 | 5 | public class CelsiusFahrenheit { 6 | 7 | public static void main(String[] args) { 8 | Scanner input = new Scanner(System.in); 9 | System.out.println("| 01 Fahrenheit para Celsius"); 10 | System.out.println("| 02 Celsius para Fahrenheit"); 11 | try { 12 | int escolha = input.nextInt(); 13 | double fahrenheit = 0; 14 | double celsius = 0; 15 | switch (escolha) { 16 | case 1: 17 | System.out.println("Digite a temperatura em Fahrenheit:"); 18 | fahrenheit = input.nextDouble(); 19 | celsius = calcularCelsius(fahrenheit); 20 | System.out.printf("%.2f°F = %.2f°C%n", fahrenheit, celsius); 21 | break; 22 | case 2: 23 | System.out.println("Digite a temperatura em Celsius:"); 24 | celsius = input.nextDouble(); 25 | fahrenheit = calcularFahrenheit(celsius); 26 | System.out.printf("%.2f°C = %.2f°F%n", celsius, fahrenheit); 27 | break; 28 | default: 29 | System.out.println("Opção Inválida!"); 30 | } 31 | } catch (java.util.InputMismatchException e) { 32 | System.out.println("Use o sistema corretamente!"); 33 | } 34 | input.close(); 35 | } 36 | 37 | public static double calcularFahrenheit(double valor) { 38 | return (valor * 1.8) + 32; 39 | } 40 | 41 | public static double calcularCelsius(double valor) { 42 | return (valor - 32) * 5 / 9; 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /nivel1/035-JogoDeAdivinhacaoSimples/src/jogo/de/adivinhacao/JogoDeAdivinhacaoSimples.java: -------------------------------------------------------------------------------- 1 | package jogo.de.adivinhacao; 2 | 3 | import java.util.Random; 4 | import java.util.Scanner; 5 | 6 | public class JogoDeAdivinhacaoSimples { 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | Random random = new Random(); 10 | int numeroSecreto = random.nextInt(10) + 1; 11 | 12 | System.out.println("===== Jogo da Adivinhação ====="); 13 | System.out.println("Digite seu palpipe entre 1 e 10! Você tem 5 tentativas!"); 14 | 15 | int tentativas = 0; 16 | boolean acertou = false; 17 | 18 | while (tentativas < 5) { 19 | System.out.print((tentativas + 1) + "ª tentativa: "); 20 | int palpite = scanner.nextInt(); 21 | 22 | if (palpite < 1 || palpite > 10) { 23 | System.out.println("[ERRO!] Número inválido. Informe um número entre 1 e 10!"); 24 | continue; 25 | } 26 | 27 | tentativas++; 28 | 29 | if (palpite == numeroSecreto) { 30 | System.out.printf("\nParabéns!!! Você acertou com %d tentativa(s). O número secreto é %d.\n", tentativas, numeroSecreto); 31 | acertou = true; 32 | break; 33 | } else if (palpite < numeroSecreto) { 34 | System.out.println("Errado! O número secreto é maior."); 35 | } else { 36 | System.out.println("Errado! O número secreto é menor."); 37 | } 38 | } 39 | 40 | if (!acertou) { 41 | System.out.printf("\nFim das tentativas. Você perdeu! O número secreto era %d.\n", numeroSecreto); 42 | } 43 | 44 | scanner.close(); 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /nivel3/021-RelogioDigital/src/relogio/digital/RelogioDigital.java: -------------------------------------------------------------------------------- 1 | package relogio.digital; 2 | 3 | import java.util.Scanner; 4 | 5 | public class RelogioDigital { 6 | private int hora; 7 | private int minuto; 8 | private int segundo; 9 | 10 | public RelogioDigital(int hora, int minuto, int segundo) { 11 | this.hora = hora; 12 | this.minuto = minuto; 13 | this.segundo = segundo; 14 | } 15 | 16 | public void start() { 17 | System.out.println("=== Relogio Digital ==="); 18 | while (true) { 19 | segundo++; 20 | if(segundo == 60){ 21 | segundo = 0; 22 | minuto++; 23 | } 24 | if(minuto == 60){ 25 | minuto = 0; 26 | hora++; 27 | } 28 | if(hora == 24){ 29 | hora = 0; 30 | minuto = 0; 31 | segundo = 0; 32 | } 33 | 34 | System.out.printf("%02d:%02d:%02d%n", hora, minuto, segundo); 35 | try { 36 | Thread.sleep(1000); 37 | }catch (InterruptedException e){ 38 | break; 39 | } 40 | } 41 | } 42 | 43 | public static void main(String[] args){ 44 | Scanner input = new Scanner(System.in); 45 | System.out.println("Digite a hora:"); 46 | int hora = input.nextInt(); 47 | System.out.println("Digite a Minuto:"); 48 | int minuto = input.nextInt(); 49 | System.out.println("Digite a Segundo:"); 50 | int segundo = input.nextInt(); 51 | hora = hora > 23 ? 0 : hora; 52 | minuto = minuto > 59 ? 0 : minuto; 53 | segundo = segundo > 59 ? 0 : segundo; 54 | RelogioDigital relogio = new RelogioDigital(hora, minuto, segundo); 55 | relogio.start(); 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /nivel1/027-HashMapParesChaveValor/src/chave/valor/HashMapParesChaveValor.java: -------------------------------------------------------------------------------- 1 | package chave.valor; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | import java.util.Scanner; 6 | 7 | public class HashMapParesChaveValor { 8 | public static void main(String[] args) { 9 | Scanner scanner = new Scanner(System.in); 10 | Map produtos = new HashMap<>(); 11 | 12 | int contador = 0; 13 | while (contador < 5) { 14 | System.out.print("\nNome do produto " + (contador + 1) + ": "); 15 | String nome = scanner.nextLine().trim(); 16 | 17 | if (nome.isEmpty()){ 18 | System.out.println("[ERRO] O nome não pode estar vazio!"); 19 | continue; // Volta para pedir de novo 20 | } 21 | 22 | if (produtos.containsKey(nome)) { 23 | System.out.println("[ERRO] Produto já informado. Digite outro nome!"); 24 | continue; // evita duplicata 25 | } 26 | 27 | System.out.print("Preço do produto: "); 28 | String entradaPreco = scanner.nextLine().trim(); 29 | double preco; 30 | 31 | try { 32 | preco = Double.parseDouble(entradaPreco); 33 | } catch (NumberFormatException e) { 34 | System.out.println("[ERRO] Informe um número válido para o preço!"); 35 | continue; // volta e pede novamente 36 | } 37 | produtos.put(nome, preco); 38 | contador++; 39 | } 40 | scanner.close(); 41 | 42 | System.out.println("\n===== Produtos Cadastrados ====="); 43 | for (Map.Entry entrada : produtos.entrySet()) { 44 | System.out.printf("Produto: %-15s | Preço: R$ %.2f%n", entrada.getKey(), entrada.getValue()); 45 | } 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /nivel2/005-FrequenciaCaracteres/src/frequencia/caracteres/FrequenciaCaracteres.java: -------------------------------------------------------------------------------- 1 | package frequencia.caracteres; 2 | 3 | import java.util.*; 4 | 5 | public class FrequenciaCaracteres { 6 | 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | 10 | System.out.print("Digite uma palavra ou frase: "); 11 | String texto = scanner.nextLine().toLowerCase(); // tudo minúsculo 12 | 13 | Map frequencia = new HashMap<>(); 14 | 15 | for (char c : texto.toCharArray()) { 16 | if (c == ' ') continue; // ignora espaços 17 | 18 | // Se já existe no mapa, soma +1 19 | if (frequencia.containsKey(c)) { 20 | frequencia.put(c, frequencia.get(c) + 1); 21 | } else { 22 | frequencia.put(c, 1); // primeira vez 23 | } 24 | } 25 | 26 | System.out.println("\nFrequência de caracteres:"); 27 | for (Map.Entry entry : frequencia.entrySet()) { 28 | System.out.println(entry.getKey() + " = " + entry.getValue()); 29 | } 30 | 31 | scanner.close(); 32 | } 33 | } 34 | 35 | /* 36 | | Parte | Explicação | 37 | | ------------------------- | ---------------------------------------------------------- | 38 | | `.toCharArray()` | Transforma a `String` em um array de caracteres (`char[]`) | 39 | | `Map` | Associa cada caractere a um contador (frequência) | 40 | | `containsKey(c)` | Verifica se o caractere já está no mapa | 41 | | `put(c, valor)` | Insere ou atualiza o valor da chave (caractere) | 42 | | `toLowerCase()` | Evita contar ‘A’ e ‘a’ como diferentes | 43 | 44 | */ -------------------------------------------------------------------------------- /nivel2/011-CaracteresUnicos/src/caracteres/unicos/CaracteresUnicos.java: -------------------------------------------------------------------------------- 1 | package caracteres.unicos; 2 | 3 | import java.util.HashSet; 4 | import java.util.Scanner; 5 | 6 | public class CaracteresUnicos { 7 | 8 | public static void main(String[] args) { 9 | Scanner scanner = new Scanner(System.in); 10 | 11 | try { 12 | System.out.println("==== TESTANDO CARACTERES ===="); 13 | System.out.print("Informe uma palavra para o teste: "); 14 | String entrada = scanner.nextLine(); 15 | 16 | boolean resultado = todosCaracteresUnicos(entrada); 17 | System.out.println("Todos os caracteres de [" + entrada + "] são únicos? " + resultado); 18 | 19 | } catch (Exception e) { 20 | System.out.println("[ERRO!] Informe um caractere válido!"); 21 | } finally { 22 | scanner.close(); 23 | } 24 | } 25 | 26 | public static boolean todosCaracteresUnicos(String str) { 27 | HashSet caracteresVistos = new HashSet<>(); 28 | 29 | for (char c : str.toCharArray()) { 30 | if (caracteresVistos.contains(c)) { 31 | return false; 32 | } 33 | caracteresVistos.add(c); 34 | } 35 | return true; 36 | } 37 | } 38 | 39 | /* 40 | - Scanner: Lê a entrada do usuário. 41 | - HashSet: Armazena os caracteres já vistos (sem repetições). 42 | - for (char c : str.toCharArray()): Converte a string em um array de caracteres e percorre um por um. 43 | Verificação: 44 | - Se o caractere já estiver no HashSet, então já apareceu antes → retorna false. 45 | - Se não, adiciona o caractere ao HashSet. 46 | - Se nenhum caractere for repetido, retorna true. 47 | 48 | str.toCharArray() 49 | - A expressão str.toCharArray() em Java transforma uma String em um vetor de caracteres (char[]) 50 | - Facilita operações como: 51 | -> Percorrer cada caractere com um for 52 | -> Comparar caracteres individualmente 53 | -> Armazenar ou processar cada letra separadamente 54 | */ -------------------------------------------------------------------------------- /nivel2/045-VerificarMatchInteiros/src/verificarmatch/VerificarMatchInteiros.java: -------------------------------------------------------------------------------- 1 | package verificarmatch; 2 | 3 | import java.util.*; 4 | 5 | public class VerificarMatchInteiros { 6 | public static void main(String[] args) { 7 | List numeros = Arrays.asList(2, 3, 14, -5, 9); 8 | 9 | // 1) Todos positivos, algum par, nenhum múltiplo de 7 10 | boolean todosPositivos = numeros.stream().allMatch(n -> n > 0); 11 | boolean algumPar = numeros.stream().anyMatch(n -> n % 2 == 0); 12 | boolean nenhumMultiplo7 = numeros.stream().noneMatch(n -> n % 7 == 0); 13 | 14 | List positivos = new ArrayList<>(); 15 | List negativos = new ArrayList<>(); 16 | List pares = new ArrayList<>(); 17 | List impares = new ArrayList<>(); 18 | List multiplosDe7 = new ArrayList<>(); 19 | 20 | for (Integer n : numeros){ 21 | if (n == null) continue; 22 | 23 | // positivos e negativos 24 | if (n > 0) { positivos.add(n); } else { negativos.add(n); } 25 | 26 | // pares e ímpares 27 | if (n % 2 == 0) { pares.add(n); } else { impares.add(n); } 28 | 29 | // múltiplos de 7 30 | if (n % 7 == 0) { multiplosDe7.add(n); } 31 | } 32 | 33 | System.out.println("Lista: " + numeros); 34 | 35 | System.out.println("\n--- allMatch ---"); 36 | System.out.println("Todos positivos? " + todosPositivos); 37 | System.out.println("Positivos: " + positivos); 38 | System.out.println("Negativos: " + negativos); 39 | 40 | System.out.println("\n--- anyMatch ---"); 41 | System.out.println("Algum é par? " + algumPar); 42 | System.out.println("Pares: " + pares); 43 | System.out.println("Ímpares: " + impares); 44 | 45 | System.out.println("\n--- noneMatch ---"); 46 | System.out.println("Nenhum é múltiplo de 7? " + nenhumMultiplo7); 47 | System.out.println("Múltiplos de 7: " + multiplosDe7); 48 | } 49 | } -------------------------------------------------------------------------------- /nivel1/017-ArrayMediaElementosInteiros/src/media/ArrayMediaElementosInteiros.java: -------------------------------------------------------------------------------- 1 | package media; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Scanner; 5 | 6 | public class ArrayMediaElementosInteiros { 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | ArrayList elementos = new ArrayList<>(); // ArrayList para tamanho dinâmico 10 | 11 | System.out.println("========= CALCULANDO MÉDIA ========="); 12 | System.out.println("Digite números inteiros. Pressione ENTER sem digitar nada para parar."); 13 | 14 | while (true){ 15 | System.out.print("Informe um número inteiro: "); 16 | String entrada = scanner.nextLine().trim(); // O método trim() remove todos os espaços em branco no início e no fim da String. 17 | if (entrada.isEmpty()) { // Condição para parar (Enter) 18 | break; 19 | } 20 | 21 | try { 22 | int numero = Integer.parseInt(entrada); // Converte a entrada (String) para inteiro 23 | elementos.add(numero); 24 | } catch (NumberFormatException e) { 25 | System.out.println("Entrada inválida! Digite apenas números inteiros."); 26 | } 27 | } 28 | scanner.close(); 29 | 30 | // Exibindo os números armazenados no ArrayList 31 | System.out.println("\nNúmeros informados: " + elementos); 32 | 33 | // Calculando a soma 34 | int soma = 0; 35 | for (int numero : elementos) { 36 | soma += numero; 37 | } 38 | System.out.println("Soma: " + soma); 39 | 40 | // Calculando a média 41 | if (!elementos.isEmpty()) { // Ou seja, se o ArrayList (elementos) não estiver vazio, faça: 42 | double media = (double) soma / elementos.size(); 43 | System.out.println("Média: " + media); 44 | } else { // Se estiver vazio: 45 | System.out.println("Nenhum número foi informado, média não calculada."); 46 | } 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /nivel2/025-RotacionarArray/src/array/rotacao/RotacionarArray.java: -------------------------------------------------------------------------------- 1 | package array.rotacao; 2 | 3 | import java.util.Arrays; 4 | import java.util.Scanner; 5 | 6 | public class RotacionarArray { 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | 10 | int[] numeros = {1, 2, 3, 4, 5}; 11 | 12 | System.out.println("==== Rotacionador de Array ===="); 13 | System.out.println("Array inicial: " + Arrays.toString(numeros)); 14 | 15 | System.out.print("Quantas rotações deseja fazer? "); 16 | int k = scanner.nextInt(); 17 | 18 | System.out.print("Digite 'E' para esquerda ou 'D' para direita: "); 19 | String direcao = scanner.next().trim().toUpperCase(); 20 | 21 | k = k % numeros.length; // Otimização: não precisa rotacionar mais que o tamanho do array 22 | 23 | if (direcao.equals("E")) { 24 | rotacionarEsquerda(numeros, k); 25 | } else if (direcao.equals("D")) { 26 | rotacionarDireita(numeros, k); 27 | } else { 28 | System.out.println("Direção inválida!"); 29 | scanner.close(); 30 | return; 31 | } 32 | 33 | System.out.println("Array após rotação: " + Arrays.toString(numeros)); 34 | 35 | scanner.close(); 36 | } 37 | 38 | // Rotacionar para a esquerda k vezes 39 | private static void rotacionarEsquerda(int[] arr, int k) { 40 | for (int r = 0; r < k; r++) { 41 | int primeiro = arr[0]; 42 | for (int i = 0; i < arr.length - 1; i++) { 43 | arr[i] = arr[i + 1]; 44 | } 45 | arr[arr.length - 1] = primeiro; 46 | } 47 | } 48 | 49 | // Rotacionar para a direita k vezes 50 | private static void rotacionarDireita(int[] arr, int k) { 51 | for (int r = 0; r < k; r++) { 52 | int ultimo = arr[arr.length - 1]; 53 | for (int i = arr.length - 1; i > 0; i--) { 54 | arr[i] = arr[i - 1]; 55 | } 56 | arr[0] = ultimo; 57 | } 58 | } 59 | } -------------------------------------------------------------------------------- /nivel1/022-ArrayMaiorEMenorTextos/src/maior/menor/textos/ArrayMaiorEMenorTextos.java: -------------------------------------------------------------------------------- 1 | package maior.menor.textos; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Scanner; 5 | 6 | public class ArrayMaiorEMenorTextos { 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | ArrayList frases = new ArrayList<>(); 10 | 11 | System.out.println("========== Frases Menores e Maiores =========="); 12 | System.out.println("Critérios de desempate: Tamanho e Ordem Alfabética."); 13 | while (true) { 14 | System.out.print("Informe suas frases (ENTER sem digitar nada para sair.): "); 15 | String entrada = scanner.nextLine().trim(); 16 | if (entrada.isEmpty()) { 17 | break; 18 | } 19 | frases.add(entrada); 20 | } 21 | scanner.close(); 22 | 23 | if (frases.isEmpty()) { 24 | System.out.println("\n[ERRO!] Nenhuma frase foi informada!"); 25 | return; 26 | } 27 | 28 | System.out.println("\nSuas frases:"); 29 | for (String frase : frases) { 30 | System.out.println(frase); 31 | } 32 | 33 | String menorString = frases.get(0); 34 | String maiorString = frases.get(0); 35 | 36 | for (int i = 1; i < frases.size(); i++) { 37 | String fraseAtual = frases.get(i); 38 | if (fraseAtual.length() > maiorString.length() || 39 | (fraseAtual.length() == maiorString.length() && 40 | fraseAtual.compareToIgnoreCase(maiorString) > 0)) { 41 | maiorString = fraseAtual; 42 | } 43 | if (fraseAtual.length() < menorString.length() || 44 | (fraseAtual.length() == menorString.length() && 45 | fraseAtual.compareToIgnoreCase(menorString) < 0)) { 46 | menorString = fraseAtual; 47 | } 48 | } 49 | 50 | System.out.println("\nMaior frase: " + maiorString); 51 | System.out.println("Menor frase: " + menorString); 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /nivel2/030-IntercalarListas/src/intercalar/listas/Listas.java: -------------------------------------------------------------------------------- 1 | package intercalar.listas; 2 | 3 | import java.util.List; 4 | 5 | public class Listas { 6 | 7 | 8 | public static void main(String[] args) { 9 | List lista1 = List.of("A", "B", "C"); 10 | List lista2 = List.of("1", "2", "3", "4", "5"); 11 | 12 | System.out.println("Teste: lista 1 menor que lista 2"); 13 | Listas.intercalarListas(lista1, lista2); 14 | 15 | System.out.println("Teste: lista 1 igual lista 2"); 16 | lista2 = List.of("X", "Y", "Z"); 17 | Listas.intercalarListas(lista1, lista2); 18 | 19 | System.out.println("Teste: lista 1 maior que lista 2"); 20 | lista1 = List.of("A", "B", "C", "D"); 21 | lista2 = List.of("9", "8"); 22 | Listas.intercalarListas(lista1, lista2); 23 | } 24 | 25 | 26 | 27 | public static void intercalarListas(List lista1, List lista2){ 28 | int tamanhoLista1 = lista1.size(); 29 | int tamanhoLista2 = lista2.size(); 30 | 31 | System.out.println("====================="); 32 | 33 | if(tamanhoLista1 == tamanhoLista2){ 34 | for(int i = 0; i < tamanhoLista1; i++){ 35 | System.out.println("Lista 1: " + lista1.get(i) + " Lista 2: " + lista2.get(i)); 36 | } 37 | return; 38 | } else if(tamanhoLista1 < tamanhoLista2){ 39 | for(int i = 0; i < tamanhoLista1; i++){ 40 | System.out.println("Lista 1: " + lista1.get(i) + " Lista 2: " + lista2.get(i)); 41 | } 42 | for(int i = tamanhoLista1; i < tamanhoLista2; i++){ 43 | System.out.println("Lista 2: " + lista2.get(i)); 44 | } 45 | } else { 46 | for(int i = 0; i < tamanhoLista2; i++){ 47 | System.out.println("Lista 1: " + lista1.get(i) + " Lista 2: " + lista2.get(i)); 48 | } 49 | for(int i = tamanhoLista2; i < tamanhoLista1; i++){ 50 | System.out.println("Lista 1: " + lista1.get(i)); 51 | } 52 | } 53 | System.out.println("====================="); 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /nivel2/049-TakeWhileMenores50/src/takewhile/TakeWhileMenores50.java: -------------------------------------------------------------------------------- 1 | package takewhile; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.stream.Collectors; 6 | 7 | public class TakeWhileMenores50 { 8 | public static void main(String[] args) { 9 | // Exemplo 1: primeiros elementos menores que 50, depois aparecendo >=50 10 | List lista1 = Arrays.asList(10, 20, 30, 49, 50, 40, 25); 11 | 12 | // Exemplo 2: há um elemento >=50 no meio (takeWhile para antes dele) 13 | List lista2 = Arrays.asList(5, 15, 60, 10, 20, 30); 14 | 15 | // Exemplo 3: todos menores que 50 16 | List lista3 = Arrays.asList(1, 2, 3); 17 | 18 | // Usando takeWhile (em cada caso) 19 | List resultado1 = lista1.stream() 20 | .takeWhile(n -> n < 50) 21 | .collect(Collectors.toList()); 22 | 23 | List resultado2 = lista2.stream() 24 | .takeWhile(n -> n < 50) 25 | .collect(Collectors.toList()); 26 | 27 | List resultado3 = lista3.stream() 28 | .takeWhile(n -> n < 50) 29 | .collect(Collectors.toList()); 30 | 31 | System.out.println("Lista1: " + lista1); 32 | System.out.println("takeWhile (<50) -> " + resultado1); 33 | // Observação: 50 interrompe a sequência, então 40 e 25 depois não são incluídos 34 | 35 | System.out.println("\nLista2: " + lista2); 36 | System.out.println("takeWhile (<50) -> " + resultado2); 37 | // 60 interrompe; elementos após 60 (10,20,30) não são considerados 38 | 39 | System.out.println("\nLista3: " + lista3); 40 | System.out.println("takeWhile (<50) -> " + resultado3); 41 | 42 | // Nesse caso melhor opção é usar .filter() ou ordenar a lista (Collections.sort(lista1);) e depois usar o takeWhile() 43 | System.out.println("\nComparação (filter):"); 44 | System.out.println("lista1.filter(<50) -> " + lista1.stream().filter(n -> n < 50).collect(Collectors.toList())); 45 | System.out.println("lista2.filter(<50) -> " + lista2.stream().filter(n -> n < 50).collect(Collectors.toList())); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /nivel2/024-MatrizQuadradaSimetrica/src/matriz/quadrada/simetrica/MatrizQuadradaSimetrica.java: -------------------------------------------------------------------------------- 1 | package matriz.quadrada.simetrica; 2 | 3 | import java.util.Scanner; 4 | 5 | public class MatrizQuadradaSimetrica { 6 | 7 | /* Posição dos elementos em 3x3 8 | [00] [01] [02] 9 | [10] [11] [12] 10 | [20] [21] [22] 11 | */ 12 | 13 | public static void main(String[] args) { 14 | Scanner scanner = new Scanner(System.in); 15 | 16 | System.out.println("==== Verificador de Matriz Quadrada Simétrica ====\n"); 17 | 18 | // 1. Perguntar o tamanho da matriz 19 | System.out.print("Informe o tamanho da matriz (n x n): "); 20 | int n = scanner.nextInt(); 21 | 22 | int[][] matriz = new int[n][n]; 23 | 24 | // 2. Ler os elementos da matriz 25 | System.out.println("\nDigite os elementos da matriz: "); 26 | for (int i = 0; i < n; i++) { 27 | for (int j = 0; j < n; j++) { 28 | System.out.printf("Elemento [%d][%d]: ", i, j); 29 | matriz[i][j] = scanner.nextInt(); 30 | } 31 | } 32 | 33 | // 3. Mostra a matriz digitada 34 | System.out.println("\nMatriz informada:"); 35 | for (int i = 0; i < n; i++) { 36 | for (int j = 0; j < n; j++) { 37 | System.out.print(matriz[i][j] + "\t"); 38 | } 39 | System.out.println(); 40 | } 41 | 42 | // 4. Verificar se é simétrica 43 | boolean simetrica = true; 44 | for (int i = 0; i < n; i++) { 45 | for (int j = i + 1; j < n; j++) { // só compara acima da diagonal 46 | if (matriz[i][j] != matriz[j][i]) { 47 | simetrica = false; 48 | break; // para e sai do loop de comparação 49 | } 50 | } 51 | if (!simetrica) break; 52 | } 53 | 54 | // 5. Mostrar resultado 55 | System.out.println("\n==== Resultado ===="); 56 | if (simetrica) { 57 | System.out.println("A matriz é SIMÉTRICA!"); 58 | } else { 59 | System.out.println("A matriz NÃO é simétrica!"); 60 | } 61 | scanner.close(); 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /nivel2/006-ParOuImpar/src/par/ou/impar/ParOuImpar.java: -------------------------------------------------------------------------------- 1 | package par.ou.impar; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | import java.util.Scanner; 6 | 7 | public class ParOuImpar { 8 | public static void main(String[] args) { 9 | Scanner scanner = new Scanner(System.in); 10 | 11 | List pares = new ArrayList<>(); 12 | List impares = new ArrayList<>(); 13 | 14 | try { 15 | System.out.println("==== PAR OU ÍMPAR ===="); 16 | System.out.print("Quantos números deseja digitar? "); 17 | int quantidade = scanner.nextInt(); 18 | 19 | for (int i = 1; i <= quantidade; i++) { 20 | System.out.print("Digite o " + i + "º número: "); 21 | int n = scanner.nextInt(); 22 | 23 | if (n % 2 == 0) { 24 | pares.add(n); 25 | } else { 26 | impares.add(n); 27 | } 28 | } 29 | 30 | // Exibição dos resultados 31 | System.out.println("\nRESULTADO:"); 32 | System.out.println("Números pares: " + pares); 33 | System.out.println("Números ímpares: " + impares); 34 | 35 | } catch (Exception e) { 36 | System.out.println("[ERRO!] Informe um número inteiro válido!"); 37 | } finally { 38 | scanner.close(); 39 | } 40 | } 41 | } 42 | 43 | /* 44 | | Modificação | Função | 45 | | --------------------------------------- | -------------------------------------------- | 46 | | `List pares` | Guarda os números pares digitados | 47 | | `List impares` | Guarda os números ímpares digitados | 48 | | `for (int i = 1; i <= quantidade; i++)` | Permite o usuário digitar múltiplos números | 49 | | `for (int i = 1; ...)` | Cria a variável i e começa em 1. Contador | 50 | | `for (...; i <= quantidade; ...)` | Enquanto i <= quantidade, o loop continua. | 51 | | `for (...; ...; i++)` | Após cada repetição, incrementa i em 1. i = i + 1.| 52 | | `pares.add(...)` / `impares.add(...)` | Adiciona cada número na lista correspondente | 53 | */ -------------------------------------------------------------------------------- /nivel3/015-JogoNumeroSecreto/src/jogo/JogoNumeroSecreto.java: -------------------------------------------------------------------------------- 1 | package jogo; 2 | 3 | import java.util.Random; 4 | import java.util.Scanner; 5 | 6 | public class JogoNumeroSecreto { 7 | 8 | /** 9 | * 039. Jogo de adivinhação com tentativas limitadas 10 | * Com um número de tentativas definido pelo usuário. 11 | * Armazene um número secreto 12 | * Diga se o número digitado é maior ou menor. 13 | */ 14 | 15 | public static void main(String[] args) { 16 | Scanner scanner = new Scanner(System.in); 17 | Random random = new Random(); 18 | 19 | int numeroSorteado = random.nextInt(100); // Número entre 0 e 99 20 | int tentativasMaximas, tentativasUsadas = 0; 21 | boolean acertou = false; 22 | 23 | System.out.println("=== Jogo da Adivinhação! ==="); 24 | System.out.print("Quantas tentativas você quer? "); 25 | tentativasMaximas = scanner.nextInt(); 26 | 27 | System.out.printf("Você usará %d tentativa(s). Vamos começar!\n", tentativasMaximas); 28 | 29 | while (tentativasUsadas < tentativasMaximas) { 30 | System.out.printf("\nTentativa %d de %d\n", tentativasUsadas + 1, tentativasMaximas); 31 | System.out.print("Informe um número de 0 a 99: "); 32 | int palpite = scanner.nextInt(); 33 | 34 | if (palpite > numeroSorteado) { 35 | System.out.printf("[ERROU!] %d é MAIOR que o valor sorteado!\n", palpite); 36 | } else if (palpite < numeroSorteado) { 37 | System.out.printf("[ERROU!] %d é MENOR que o valor sorteado!\n", palpite); 38 | } else { 39 | System.out.printf("\n[ACERTOU!] PARABÉNS! O valor sorteado foi: %d\n", numeroSorteado); 40 | System.out.printf("Você utilizou %d tentativa(s).\n", tentativasUsadas + 1); 41 | acertou = true; 42 | break; 43 | } 44 | 45 | tentativasUsadas++; 46 | } 47 | 48 | if (!acertou) { 49 | System.out.printf("\n[GAME OVER!] Todas as %d tentativas foram usadas.\n", tentativasMaximas); 50 | System.out.printf("O número correto era: %d\n", numeroSorteado); 51 | } 52 | 53 | System.out.println("\nObrigado por jogar!"); 54 | System.out.println("Finalizando jogo..."); 55 | scanner.close(); 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /nivel2/020-RestoDaDivisao/src/divisao/ConsoleUI.java: -------------------------------------------------------------------------------- 1 | package divisao; 2 | 3 | import java.util.InputMismatchException; 4 | import java.util.Scanner; 5 | 6 | public class ConsoleUI { 7 | private final Scanner scanner; 8 | private final DivisaoService service; 9 | 10 | public ConsoleUI() { 11 | this.scanner = new Scanner(System.in); 12 | this.service = new DivisaoService(); 13 | } 14 | 15 | public void iniciar() { 16 | boolean continuar = true; 17 | 18 | while (continuar) { 19 | System.out.println("\n--- Calculadora de Divisão Empresarial ---"); 20 | 21 | int dividendo = lerNumero("Digite o dividendo: "); 22 | int divisor = lerNumero("Digite o divisor: "); 23 | 24 | try { 25 | Divisao divisao = new Divisao(dividendo, divisor); 26 | exibirResultado(divisao); 27 | } catch (IllegalArgumentException e) { 28 | System.out.println("Erro: " + e.getMessage()); 29 | } 30 | 31 | continuar = desejaContinuar(); 32 | } 33 | 34 | scanner.close(); 35 | System.out.println("Programa encerrado. Até mais!"); 36 | } 37 | 38 | private int lerNumero(String mensagem) { 39 | while (true) { 40 | try { 41 | System.out.print(mensagem); 42 | return scanner.nextInt(); 43 | } catch (InputMismatchException e) { 44 | System.out.println("Entrada inválida! Digite apenas números inteiros."); 45 | scanner.nextLine(); // limpa buffer inválido 46 | } 47 | } 48 | } 49 | 50 | private void exibirResultado(Divisao divisao) { 51 | int resultado = service.calcularResultado(divisao); 52 | int resto = service.calcularResto(divisao); 53 | 54 | System.out.println("\n--- Resultados ---"); 55 | System.out.println("Resultado da divisão: " + resultado); 56 | System.out.println("Resto da divisão: " + resto); 57 | } 58 | 59 | private boolean desejaContinuar() { 60 | while (true) { 61 | System.out.print("\nDeseja realizar outro cálculo? (S/N): "); 62 | String resposta = scanner.next().trim(); 63 | if (resposta.equalsIgnoreCase("S")) { 64 | return true; 65 | } else if (resposta.equalsIgnoreCase("N")) { 66 | return false; 67 | } else { 68 | System.out.println("Entrada inválida! Digite apenas 'S' para sim ou 'N' para não."); 69 | } 70 | } 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /nivel1/028-HashMapNomeIdade/src/nome/idade/HashMapNomeIdade.java: -------------------------------------------------------------------------------- 1 | package nome.idade; 2 | 3 | import java.util.*; 4 | 5 | public class HashMapNomeIdade { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | Map pessoas = new HashMap<>(); 9 | 10 | while (pessoas.size() < 5) { 11 | System.out.print("\nNome da " + (pessoas.size() + 1) + "ª pessoa: "); 12 | String nome = scanner.nextLine().trim(); 13 | 14 | if (nome.isEmpty()){ 15 | System.out.println("[ERRO] O nome não pode estar vazio!"); 16 | continue; // Se vazio pede novamente 17 | } 18 | 19 | if (pessoas.containsKey(nome)) { 20 | System.out.println("[ERRO] Essa pessoa já foi registrada! Digite outro nome!"); 21 | continue; // Evita duplicata 22 | } 23 | 24 | System.out.print("Informe a idade: "); 25 | String idadeEntrada = scanner.nextLine().trim(); 26 | 27 | if (idadeEntrada.isEmpty()) { 28 | System.out.println("[ERRO] Idade não pode estar vazia!"); 29 | continue; // Se vazio pede novamente 30 | } 31 | 32 | int idade; 33 | try { 34 | idade = Integer.parseInt(idadeEntrada); 35 | if (idade < 0 || idade > 120){ 36 | System.out.println("[ERRO] Idade não pode ser negativa ou maior que 120 anos!"); 37 | continue; 38 | } 39 | } catch (NumberFormatException e) { 40 | System.out.println("[ERRO] Informe uma idade válida!"); 41 | continue; 42 | } 43 | pessoas.put(nome, idade); 44 | } 45 | scanner.close(); 46 | 47 | // Encontrando o(s) mais velho(s) 48 | int idadeMaisAlta = Collections.max(pessoas.values()); 49 | List nomesMaisVelhos = new ArrayList<>(); 50 | 51 | for (Map.Entry entrada : pessoas.entrySet()) { 52 | if (entrada.getValue() == idadeMaisAlta) { 53 | nomesMaisVelhos.add(entrada.getKey()); 54 | } 55 | } 56 | 57 | // Todos Cadastrados 58 | System.out.println("\n===== Pessoas Cadastradas ====="); 59 | for (Map.Entry entrada : pessoas.entrySet()){ 60 | System.out.printf("Nome: %-15s | Idade: %d%n", entrada.getKey(), entrada.getValue()); 61 | } 62 | 63 | //Resultado Final 64 | if (nomesMaisVelhos.size() == 1) { 65 | System.out.println("\nA pessoa com mais idade é " + nomesMaisVelhos.get(0) + " com " + idadeMaisAlta + " anos."); 66 | } else { 67 | System.out.println("\nOs mais velhos são: " + String.join(", ", nomesMaisVelhos) + " com " + idadeMaisAlta + " anos."); 68 | } 69 | } 70 | } 71 | -------------------------------------------------------------------------------- /nivel2/044-CompararStreamParallel/src/compararstream/Comparar.java: -------------------------------------------------------------------------------- 1 | package compararstream; 2 | 3 | import java.util.List; 4 | import java.util.stream.Collectors; 5 | import java.util.stream.IntStream; 6 | import java.util.stream.LongStream; 7 | import java.util.function.Supplier; 8 | 9 | public class Comparar { 10 | 11 | private static long measureMillis(Supplier supplier) { 12 | long start = System.nanoTime(); 13 | long result = supplier.get(); // garante que o cálculo não seja removido 14 | long end = System.nanoTime(); 15 | System.out.println("Resultado (soma): " + result); 16 | return (end - start) / 1_000_000; // retorna em ms 17 | } 18 | 19 | public static void main(String[] args) { 20 | final int N = 1_000_000; 21 | System.out.println("Preparando dados: somar 1.." + N); 22 | 23 | // Lista com boxing (List) — simula uso comum de coleções 24 | List numerosBoxed = IntStream.rangeClosed(1, N) 25 | .boxed() 26 | .collect(Collectors.toList()); 27 | 28 | // Warm-up (ajuda o JIT a otimizar antes das medições) 29 | System.out.println("Warm-up..."); 30 | for (int i = 0; i < 3; i++) { 31 | LongStream.rangeClosed(1, N).sum(); 32 | LongStream.rangeClosed(1, N).parallel().sum(); 33 | numerosBoxed.stream().mapToLong(Integer::longValue).sum(); 34 | numerosBoxed.parallelStream().mapToLong(Integer::longValue).sum(); 35 | } 36 | 37 | final int runs = 5; 38 | long totalBoxedSeq = 0, totalBoxedPar = 0, totalPrimSeq = 0, totalPrimPar = 0; 39 | 40 | System.out.println("Executando medições (" + runs + " runs)..."); 41 | for (int i = 1; i <= runs; i++) { 42 | System.out.println("\n--- Run " + i + " ---"); 43 | 44 | long tBoxedSeq = measureMillis(() -> numerosBoxed.stream() 45 | .mapToLong(Integer::longValue).sum()); 46 | long tBoxedPar = measureMillis(() -> numerosBoxed.parallelStream() 47 | .mapToLong(Integer::longValue).sum()); 48 | long tPrimSeq = measureMillis(() -> LongStream.rangeClosed(1, N).sum()); 49 | long tPrimPar = measureMillis(() -> LongStream.rangeClosed(1, N).parallel().sum()); 50 | 51 | System.out.printf("Tempos (ms) -> Boxed seq: %d, Boxed par: %d, Prim seq: %d, Prim par: %d%n", 52 | tBoxedSeq, tBoxedPar, tPrimSeq, tPrimPar); 53 | 54 | totalBoxedSeq += tBoxedSeq; 55 | totalBoxedPar += tBoxedPar; 56 | totalPrimSeq += tPrimSeq; 57 | totalPrimPar += tPrimPar; 58 | } 59 | 60 | System.out.println("\n=== MÉDIAS (ms) ==="); 61 | System.out.printf("Boxed stream (List.stream()): %.2f ms%n", totalBoxedSeq / (double) runs); 62 | System.out.printf("Boxed parallelStream (List.parallelStream()): %.2f ms%n", totalBoxedPar / (double) runs); 63 | System.out.printf("Primitive LongStream (sequential): %.2f ms%n", totalPrimSeq / (double) runs); 64 | System.out.printf("Primitive LongStream (parallel): %.2f ms%n", totalPrimPar / (double) runs); 65 | 66 | System.out.println("\nObservações:"); 67 | System.out.println("- Resultados variam conforme número de núcleos, carga do sistema e JVM."); 68 | System.out.println("- Boxing (List) adiciona overhead; comparações com LongStream são mais justas."); 69 | System.out.println("- Para benchmarking sério, use JMH (Java Microbenchmark Harness)."); 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 🚀 Desafios Técnicos em Java 2 | 3 | Este repositório reúne uma coleção de **desafios práticos de lógica de programação, Programação Orientada a Objetos (POO) e estruturas de dados**, todos implementados em **Java**. 4 | 5 | O objetivo é **reforçar a base de programação** com exercícios progressivos, desde conceitos fundamentais até problemas mais estruturados, servindo como prática para entrevistas de estágio e vagas de desenvolvedor júnior. 6 | 7 | ## 📂 Estrutura 8 | 9 | - Cada desafio está em uma pasta própria, com nome padronizado. 10 | - Dentro de cada pasta há a implementação em Java e, quando necessário, comentários explicando a proposta. 11 | - Os desafios estão organizados por **nível de dificuldade**. 12 | - Desafios já completados: ✅ 13 | - Desafios para realizar: ⬜ 14 | 15 | ## 📚 Lista de Desafios 16 | 17 | A lista completa pode ser acessada diretamente [AQUI](https://github.com/pitercoding/desafios-tecnicos-java/blob/main/Lista%20de%20Desafios). 18 | 19 |
20 | ☕ Tipos de Desafios 21 | 22 | - 🗂️ Arrays e Collections 23 | - 🧩 Lógica e Condições 24 | - 🔢 Operações Matemáticas Básicas 25 | - 🤔 Operadores Lógicos 26 | - 🐒 Orientação a Objetos 27 | - 📝 Strings e Manipulação de Texto 28 |
29 | 30 |
31 | 👍 Nível 1 — Desafios Simples 32 | 33 | - ✅ 000. Olá, Mundo! 34 | - ✅ 001. Verificador de Palíndromo 35 | - ✅ 002. Soma de números únicos 36 | - ✅ 003. Orientação a Objetos: Zoológico 37 | - ✅ 004. Contador de Vogais 38 | - ✅ 005. Fatorial 39 | - ✅ 006. Números Primos 40 | - ✅ 007. Inverter String 41 | - ✅ 008. Saudação personalizada com ponto de exclamação 42 | - ✅ 009. Receber dois números e mostrar operações 43 | - ✅ 010. Verificar se uma string contém apenas dígitos 44 | - ... 45 |
46 | 47 |
48 | 🧠 Nível 2 — Lógica Intermediária 49 | 50 | - ✅ 001. Soma dos Dígitos 51 | - ✅ 002. Fibonacci até N termos 52 | - ✅ 003. Remover Duplicados de um Array 53 | - ✅ 004. Maior e menor número de uma lista 54 | - ✅ 005. Contar Frequência de Caracteres 55 | - ... 56 |
57 | 58 |
59 | 🔁 Nível 3 — Laços e Condicionais 60 | 61 | - ✅ 001. Contagem Regressiva 62 | - ✅ 002. Números Pares de 1 a 100 63 | - ✅ 003. Soma de 10 números digitados 64 | - ✅ 004. Número Secreto com Tentativas Infinitas 65 | - ... 66 |
67 | 68 |
69 | 📦 Outros Desafios 70 | 71 | - ⬜ 001. Conversor de decimal para binário 72 | - ⬜ 002. Conversor de binário para decimal 73 | - ... 74 |
75 | 76 |
77 | 🚀 Nível 4 — Desafios Avançados 78 | 79 | - ⬜ 001. Sistema de cadastro de alunos 80 | - ⬜ 002. Implementar fila e pilha com ArrayList 81 | - ... 82 |
83 | 84 | ## 🛠️ Tecnologias 85 | - Java 17+ 86 | - IntelliJ IDEA / Eclipse (recomendado) 87 | - Terminal / Console para entrada de dados 88 | 89 | ## 📌 Objetivos 90 | Este repositório serve como base para: 91 | - Treinamento de **lógica de programação** 92 | - Prática de **POO com exemplos aplicados** 93 | - Exercícios de **estruturas de dados e algoritmos básicos** 94 | - Preparação para **entrevistas e testes técnicos** 95 | 96 | ## 👨‍💻 Contribuindo 97 | Sinta-se à vontade para: 98 | - Sugerir melhorias ✨ 99 | - Adicionar novos desafios 💡 100 | - Corrigir ou refatorar soluções 🔧 101 | 102 | ## ⚠️ Status 103 | 📌 **Em constante desenvolvimento... novos desafios são adicionados regularmente!** 104 | 105 | ## 📄 Licença 106 | Este projeto está sob a licença [MIT](LICENSE). 107 | 108 | -------------------------------------------------------------------------------- /nivel2/004-MaiorEMenor/src/maior/e/menor/Main.java: -------------------------------------------------------------------------------- 1 | package maior.e.menor; 2 | 3 | import java.util.*; 4 | 5 | public class Main { 6 | 7 | public static void main(String[] args) { 8 | Scanner scanner = new Scanner(System.in); 9 | 10 | System.out.print("Digite os números separados por espaço: "); 11 | String entrada = scanner.nextLine(); //Lê tudo que foi digitado como uma String 12 | String[] partes = entrada.split(" "); 13 | 14 | if (partes.length == 0) { 15 | System.out.println("Nenhum número foi informado."); 16 | return; 17 | } 18 | 19 | try { 20 | int menor = Integer.MAX_VALUE; 21 | int maior = Integer.MIN_VALUE; 22 | int soma = 0; 23 | List pares = new ArrayList<>(); 24 | List impares = new ArrayList<>(); 25 | 26 | for (String parte : partes) { 27 | int numero = Integer.parseInt(parte); 28 | 29 | // Atualiza maior e menor 30 | if (numero < menor) menor = numero; 31 | if (numero > maior) maior = numero; 32 | 33 | // Soma para média 34 | soma += numero; 35 | 36 | // Separa pares e ímpares 37 | if (numero % 2 == 0) { 38 | pares.add(numero); 39 | } else { 40 | impares.add(numero); 41 | } 42 | } 43 | 44 | int quantidade = partes.length; 45 | double media = (double) soma / quantidade; 46 | String mediaFormatada = String.format("%.2f", media); 47 | 48 | // Saídas: 49 | System.out.println("\n📌 Resultados:"); 50 | System.out.println("Menor número: " + menor); 51 | System.out.println("Maior número: " + maior); 52 | System.out.println("Média: " + mediaFormatada); 53 | System.out.println("Pares: " + pares); 54 | System.out.println("Ímpares: " + impares); 55 | 56 | } catch (NumberFormatException e) { 57 | System.out.println("Erro: Digite apenas números inteiros válidos."); 58 | } finally { 59 | scanner.close(); 60 | } 61 | } 62 | } 63 | 64 | /* 65 | | Parte do código | O que faz | 66 | | ------------------------- | ---------------------------------------------------------------------- | 67 | | `Integer.MAX_VALUE` | Valor inicial enorme para garantir que qualquer número seja menor | 68 | | `Integer.MIN_VALUE` | Valor inicial muito baixo para garantir que qualquer número seja maior | 69 | | `entrada.split(" ")` | Divide os números digitados pelo usuário | 70 | | `Integer.parseInt(parte)` | Converte cada parte da String em inteiro | 71 | | `if (numero < menor)` | Atualiza o menor valor encontrado | 72 | | `if (numero > maior)` | Atualiza o maior valor encontrado | 73 | 74 | 75 | | Parte nova do código | O que faz | 76 | | -------------------------------------------- | ------------------------------------------------ | 77 | | `soma += numero;` | Acumula os valores para cálculo da média | 78 | | `double media = (double) soma / quantidade;` | Faz o cálculo da média usando cast para precisão | 79 | | `numero % 2 == 0` | Verifica se o número é par | 80 | | `pares.add(...)` / `impares.add(...)` | Separa os números em duas listas | 81 | 82 | */ -------------------------------------------------------------------------------- /nivel2/017-StringEmTitulo/src/string/em/titulo/StringEmTitulo.java: -------------------------------------------------------------------------------- 1 | package string.em.titulo; 2 | 3 | import java.util.Scanner; 4 | 5 | public class StringEmTitulo { 6 | public static void main(String[] args) { 7 | Scanner scanner = new Scanner(System.in); 8 | 9 | System.out.print("Digite um frase: "); 10 | String frase = scanner.nextLine(); 11 | 12 | String[] palavras = frase.trim().split("\\s+"); 13 | StringBuilder titulo = new StringBuilder(); 14 | 15 | for (String palavra : palavras) { 16 | if (!palavra.isEmpty()) { 17 | // Capitaliza a primeira letra e junta com o restante em minúsculo 18 | String capitalizada = palavra.substring(0, 1).toUpperCase() + palavra.substring(1).toLowerCase(); 19 | titulo.append(capitalizada).append(" "); 20 | } 21 | } 22 | 23 | // Imprime o resultado removendo o espaço extra no final 24 | System.out.println("Resultado: " + titulo.toString().trim()); 25 | 26 | scanner.close(); 27 | } 28 | } 29 | 30 | /** 31 | * | **Linha de Código** | **Explicação** | **Exemplo / Observação** | 32 | * | --------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ | 33 | * | `String[] palavras = frase.trim().split("\\s+");` | Remove espaços extras e divide a frase em palavras, mesmo com múltiplos espaços. | `" ola mundo "` → `["ola", "mundo"]` | 34 | * | `StringBuilder titulo = new StringBuilder();` | Cria um `StringBuilder` para montar a frase final de forma eficiente. | Evita uso excessivo de `+` com `String` | 35 | * | `for (String palavra : palavras) {` | Percorre cada palavra do array. | Loop `for-each` | 36 | * | `if (!palavra.isEmpty()) {` | Garante que a palavra não esteja vazia antes de capitalizar. | Evita erro com `substring` | 37 | * | `String capitalizada = palavra.substring(0, 1).toUpperCase() + palavra.substring(1).toLowerCase();` | Capitaliza a primeira letra da palavra e coloca o restante em minúsculo. | `"jAVa"` → `"Java"` | 38 | * | `titulo.append(capitalizada).append(" ");` | Adiciona a palavra capitalizada ao resultado final com um espaço. | Frase final sendo montada | 39 | * | — | **Resultado Final:** string com cada palavra capitalizada e separada por espaço. | `"ola MUNDO java"` → `"Ola Mundo Java "` (pode usar `.trim()` ao final se quiser remover o último espaço) | 40 | */ -------------------------------------------------------------------------------- /nivel2/028-SimuladorDeEstoque/src/simulador/estoque/ControleEsqtoque.java: -------------------------------------------------------------------------------- 1 | package simulador.estoque; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | import java.util.Scanner; 6 | 7 | public class ControleEsqtoque { 8 | public static void main(String[] args) { 9 | Scanner scanner = new Scanner(System.in); 10 | List produtos = new ArrayList<>(); 11 | 12 | int opcao; 13 | do { 14 | System.out.println("\n==== MENU ESTOQUE ===="); 15 | System.out.println("1 - Cadastrar produto"); 16 | System.out.println("2 - Adicionar ao estoque"); 17 | System.out.println("3 - Remover do estoque"); 18 | System.out.println("4 - Listar produtos"); 19 | System.out.println("5 - Sair"); 20 | System.out.print("Escolha uma opção: "); 21 | opcao = scanner.nextInt(); 22 | scanner.nextLine(); 23 | 24 | switch (opcao) { 25 | case 1: 26 | System.out.print("Nome do produto: "); 27 | String nome = scanner.nextLine(); 28 | System.out.print("Quantidade inicial: "); 29 | int qtdInicial = scanner.nextInt(); 30 | produtos.add(new Produto(nome, qtdInicial)); 31 | System.out.println("Produto cadastrado com sucesso!"); 32 | break; 33 | 34 | case 2: 35 | System.out.print("Nome do produto para adicionar: "); 36 | String nomeAdd = scanner.nextLine(); 37 | Produto produtoAdd = buscarProduto(produtos, nomeAdd); 38 | if (produtoAdd != null) { 39 | System.out.print("Quantidade a adicionar: "); 40 | int qtdAdd = scanner.nextInt(); 41 | produtoAdd.adicionar(qtdAdd); 42 | } else { 43 | System.out.println("[ERRO] Produto não encontrado!"); 44 | } 45 | break; 46 | 47 | case 3: 48 | System.out.print("Nome do produto para remover: "); 49 | String nomeRemover = scanner.nextLine(); 50 | Produto produtoRemover = buscarProduto(produtos, nomeRemover); 51 | if (produtoRemover != null) { 52 | System.out.print("Quantidade a remover: "); 53 | int qtdRemover = scanner.nextInt(); 54 | produtoRemover.remover(qtdRemover); 55 | } else { 56 | System.out.println("[ERRO] Produto não encontrado!"); 57 | } 58 | break; 59 | 60 | case 4: 61 | if (produtos.isEmpty()){ 62 | System.out.println("Nenhum produto cadastrado."); 63 | } else { 64 | System.out.println("\n==== ESTOQUE ATUAL ===="); 65 | produtos.forEach(System.out::println); 66 | } 67 | break; 68 | 69 | case 5: 70 | System.out.println("Encerrando o sistema..."); 71 | break; 72 | 73 | default: 74 | System.out.println("[ERRO] Opção inválida!"); 75 | } 76 | } while (opcao != 5); 77 | 78 | scanner.close(); 79 | } 80 | 81 | // Método auxiliar para buscar produto pelo nome 82 | private static Produto buscarProduto(List produtos, String nome) { 83 | for (Produto p : produtos) { 84 | if (p.getNome().equalsIgnoreCase(nome)) { 85 | return p; 86 | } 87 | } 88 | return null; 89 | } 90 | } 91 | 92 | 93 | -------------------------------------------------------------------------------- /Lista de Desafios: -------------------------------------------------------------------------------- 1 | ============================================== 2 | Emoticons e Tipos de Desafios 3 | ============================================== 4 | 🗂️ Arrays e Collections 5 | 🧩 Lógica e Condições 6 | 🔢 Operações Matemáticas Básicas 7 | 🤔 Operadores Lógicos 8 | 🐒 Orientação a Objetos 9 | 📝 Strings e Manipulação de Texto 10 | 11 | ============================================== 12 | 👍 Desafios Simples (nível 1) 13 | ============================================== 14 | ✅ 000. Olá, Mundo! 15 | ✅ 001. Verificador de Palíndromo 📝 16 | ✅ 002. Soma de números únicos 🗂️ 17 | ✅ 003. Orientação a Objetos: Zoológico 🐒 18 | ✅ 004. Contador de Vogais 📝 19 | ✅ 005. Fatorial 🔢 20 | ✅ 006. Números Primos 🔢 21 | ✅ 007. Inverter String 📝 22 | ✅ 008. Saudação personalizada com ponto de exclamação 🧩 23 | ✅ 009. Receber dois números e mostrar operações 🧩 24 | ✅ 010. Verificar se todos os caracteres de uma string são dígitos (0 a 9) 📝 25 | ✅ 011. Calcular a área de um círculo (usuário informa o raio) 🔢 26 | ✅ 012. Converter Celsius ↔ Fahrenheit 🔢 27 | ✅ 013. Encontrar o maior de 3 números dados 🔢 28 | ✅ 014. Calcular média aritmética de uma lista de números 🔢 29 | ✅ 015. Criar um array de 5 números inteiros e imprimir cada número 🗂️ 30 | ✅ 016. Somar todos os elementos de um array de inteiros 🗂️ 31 | ✅ 017. Calcular a média dos valores de um array de inteiros 🗂️ 32 | ✅ 018. Contar quantos números pares existem em um array 🗂️ 33 | ✅ 019. Contar quantos números ímpares existem em um array 🗂️ 34 | ✅ 020. Criar um programa que armazene 5 nomes em um array e os imprima um por linha 🗂️ 35 | ✅ 021. Criar um programa que leia 5 notas de alunos, guarde em um array e informe a média 🗂️ 36 | ✅ 022. Criar um array de Strings e imprimir o maior e o menor texto armazenado 📝 37 | ✅ 023. Verificar se um número existe dentro de um array 🗂️ 38 | ✅ 024. Criar um array de 10 números e inverter a ordem dos elementos 🗂️ 39 | ✅ 025. Criar um programa que leia 10 números e armazene apenas os positivos em um array 🗂️ 40 | ✅ 026. Criar um programa que leia 10 números e armazene apenas os negativos em um array 🗂️ 41 | ✅ 027. Criar um programa que armazene 5 pares (chave, valor) em um HashMap (ex: produto e preço) e depois imprima todos 🗂️ 42 | ✅ 028. Criar um programa que receba nomes e idades de 5 pessoas e armazene em um Map. Depois, exibir quem é o mais velho 🗂️ 43 | ✅ 029. Criar um programa que leia uma lista de nomes e remova os repetidos usando um Set 🗂️ 44 | ✅ 030. Conversor de minutos para horas e minutos 🔢 45 | ✅ 031. Mostrar o dia da semana a partir de um número (1–7) 🧩 46 | ✅ 032. Calculadora de IMC 🔢 47 | ✅ 033. Trocar valores de duas variáveis sem usar variável auxiliar 🔢 48 | ✅ 034. Simulador de dado (1 a 6) 🧩 49 | ✅ 035. Jogo de adivinhação simples (1 a 10) 🧩 50 | ✅ 036. Verificar se um número está entre 10 e 20 (inclusive) 🤔 51 | ✅ 037. Verificar se uma pessoa pode votar (idade ≥ 16) e se tem título de eleitor (booleano) 🤔 52 | ✅ 038. Verificar se um número é múltiplo de 3 ou de 5 🤔 53 | ✅ 039. Verificar se uma letra digitada não é uma vogal 🤔 54 | ✅ 040. Receber duas condições booleanas e imprimir se ambas são verdadeiras, apenas uma é verdadeira, ou nenhuma 🤔 55 | ✅ 041. Calcular área de um retângulo 🔢 56 | ✅ 042. Calcular o quadrado de um número 🔢 57 | ⬜ 043. Verificar se um número é positivo, negativo ou zero 🧩 58 | ⬜ 044. Juntar (concatenar) duas strings 📝 59 | ⬜ 045. Obter o último caractere de uma string 📝 60 | ⬜ 046. Converter uma string para maiúsculas 📝 61 | ⬜ 047. Converter uma string para minúsculas 📝 62 | ⬜ 048. Criar uma classe `Pessoa` com atributos `nome` e `idade` 🐒 63 | ⬜ 049. Criar um método na classe `Pessoa` que exiba uma saudação 🐒 64 | ⬜ 050. Encontrar o menor de três números 🔢 65 | ⬜ 051. Calcular o resto da divisão de dois números 🔢 66 | ⬜ 052. Verificar se um nome de usuário tem mais de 5 caracteres 🤔 67 | ⬜ 053. Criar uma lista de frutas (strings) e imprimir a primeira e a última 🗂️ 68 | ⬜ 054. Verificar se uma lista de inteiros está vazia 🗂️ 69 | ⬜ 055. Receber o ano de nascimento e calcular a idade atual 🔢 70 | ⬜ 056. Simular um semáforo (imprimir "Verde", "Amarelo", "Vermelho" com base em um número) 🧩 71 | ⬜ 057. Verificar se uma string contém a letra 'a' 🤔 72 | ⬜ 058. Substituir todas as ocorrências de uma letra por outra em uma string 📝 73 | ⬜ 059. Encontrar o índice da primeira ocorrência de um elemento em um array 🗂️ 74 | ⬜ 060. Criar uma cópia de um ArrayList 🗂️ 75 | ⬜ 061. Adicionar um elemento no início de um ArrayList 🗂️ 76 | ⬜ 062. Remover um elemento de uma posição específica em um ArrayList 🗂️ 77 | ⬜ 063. Calcular o valor de uma compra com desconto (ex: 10%) 🔢 78 | ⬜ 064. Verificar se a soma de dois números é maior que 100 🤔 79 | ⬜ 065. Criar uma classe `Produto` com `nome` e `preco` e um método para aplicar desconto 🐒 80 | ⬜ 066. Ler um caractere e verificar se é uma letra ou um número 🧩 81 | ⬜ 067. Simples conversor de Real para Dólar (taxa fixa) 🔢 82 | ⬜ 068. Imprimir os números de 1 a 10 usando um laço `for` 🧩 83 | ⬜ 069. Imprimir os números pares de 1 a 20 🧩 84 | ⬜ 070. Somar os números de 1 a 100 🔢 85 | ✅ 071. Obter o tamanho (length) de um array 🗂️ 86 | ⬜ 072. Criar um Map e verificar se uma chave específica existe 🗂️ 87 | ⬜ 073. A partir de um Map, obter o valor associado a uma chave 🗂️ 88 | ⬜ 074. Repetir uma string N vezes 📝 89 | ⬜ 075. Verificar se duas strings são idênticas, ignorando maiúsculas/minúsculas 📝 90 | ⬜ 076. Ler um número e imprimir seu antecessor e sucessor 🔢 91 | ⬜ 077. Calcular a hipotenusa de um triângulo retângulo 🔢 92 | ✅ 078. Verificar se a idade de uma pessoa a classifica como criança, adolescente, adulto ou idoso 🧩 93 | ⬜ 079. Criar um array com 3 notas, calcular a média e dizer se o aluno foi aprovado (média >= 7.0) 🗂️ 94 | ⬜ 080. Criar uma classe `Retangulo` com `base` e `altura` e um método para calcular a área 🐒 95 | 96 | ============================================== 97 | 🧠 Desafios de Lógica Intermediária (nível 2) 98 | ============================================== 99 | ✅ 001. Soma dos Dígitos 🔢 100 | ✅ 002. Fibonacci até N termos 🔢 101 | ✅ 003. Remover Duplicados de um Array 🗂️ 102 | ✅ 004. Maior e menor número de uma lista 🗂️ 103 | ✅ 005. Contar Frequência de Caracteres 📝 104 | ✅ 006. Par ou Ímpar 🤔 105 | ✅ 007. Tabuada de um número 🔢 106 | ✅ 008. Verificar Anagramas 📝 107 | ✅ 009. Contar Palavras em uma Frase 📝 108 | ✅ 010. Primeiro Caractere Repetido 📝 109 | ✅ 011. Verificar se todos os caracteres são únicos 📝 110 | ✅ 012. Caixa Eletrônico Simples (POO) 🐒 111 | ✅ 013. Validador de Senha 📝 112 | ✅ 014. Remover elementos repetidos mantendo a ordem 🗂️ 113 | ✅ 015. Somar apenas números positivos de uma lista 🗂️ 114 | ✅ 016. Ordenar um array de inteiros (sem usar sort) 🗂️ 115 | ✅ 017. Transformar String em Título 📝 116 | ✅ 018. Classificação de triângulo pelos lados 🧩 117 | ✅ 019. Potência 🔢 118 | ✅ 020. Resto da Divisão 🔢 119 | ✅ 021. Calcular o MDC (Máximo Divisor Comum) de dois números 🔢 120 | ✅ 022. Calcular o MMC (Mínimo Múltiplo Comum) de dois números 🔢 121 | ✅ 023. Implementar busca binária em um array ordenado 🗂️ 122 | ✅ 024. Verificar se uma matriz quadrada é simétrica 🗂️ 123 | ✅ 025. Rotacionar um array para a esquerda/direita 🗂️ 124 | ✅ 026. Calcular média ponderada 🔢 125 | ✅ 027. Normalizar texto (remover acentos e deixar minúsculo) 📝 126 | ✅ 028. Simulador de estoque (POO: classe Produto, adicionar/remover) 🐒 127 | ✅ 029. Gerador de números da Mega-Sena (6 números não repetidos) 🗂️ 128 | ✅ 030. Intercalar duas listas alternadamente 🗂️ 129 | ✅ 031. Gerador de senha forte (letras, números, símbolos) 📝 130 | ✅ 032. Crie uma lista de inteiros e use forEach com lambda para imprimir cada elemento. 🗂️ 131 | ✅ 033. Dada uma lista de inteiros, use stream() + filter com lambda para retornar apenas os pares. 🗂️ 132 | ✅ 034. Usando map e lambda, transforme uma lista de nomes em maiúsculas. 📝 133 | ✅ 035. Use reduce com lambda para somar os valores de uma lista de inteiros. 🔢 134 | ✅ 036. Usando stream() + max com lambda, encontre o maior elemento em uma lista. 🔢 135 | ✅ 037. Use Collections.sort ou list.sort com uma expressão lambda como comparador. Objetivo é ordenar uma lista de Strings. 📝 136 | ✅ 038. Contar quantas strings começam com determinada letra. Dada uma lista de palavras, conte com filter quantas começam com a letra "A". 📝 137 | ✅ 039. Criar uma thread com lambda. Use Runnable implementado com expressão lambda para imprimir uma mensagem em uma nova thread. 🧩 138 | ✅ 040. Criar um Iterator manualmente para percorrer uma lista de inteiros e, em seguida, resolver o mesmo problema usando stream(). 🗂️ 139 | ✅ 041. Usando map, transforme uma lista de números inteiros em seus quadrados. 🗂️ 140 | ✅ 042. Usando filter, a partir de uma lista de Strings, retorne apenas aquelas que tenham mais de 5 caracteres. 📝 141 | ✅ 043. Usando reduce, calcule o produto (multiplicação) de todos os elementos de uma lista de inteiros. 🔢 142 | ✅ 044. Comparar desempenho entre stream() e parallelStream() somando 1 milhão de números. 🗂️ 143 | ✅ 045. Usando allMatch, anyMatch e noneMatch, verifique em uma lista de inteiros: Se todos são positivos, se algum é par, se nenhum é múltiplo de 7. 🗂️ 144 | ✅ 046. Usando min e max, encontre o menor e o maior nome em uma lista de Strings, com base no tamanho. 📝 145 | ✅ 047. Usando distinct, filtre elementos repetidos de uma lista de inteiros. 🗂️ 146 | ✅ 048. Usando skip e limit, pule os 5 primeiros elementos de uma lista de inteiros e exiba apenas os 10 seguintes. 🗂️ 147 | ✅ 049. Usando takeWhile, exiba os elementos de uma lista enquanto forem números menores que 50. 🗂️ 148 | ⬜ 050. Encontrar o segundo maior elemento de um array 🗂️ 149 | ⬜ 051. Encontrar os elementos comuns entre dois arrays 🗂️ 150 | ⬜ 052. Inverter as palavras de uma frase ("Olá Mundo" -> "Mundo Olá") 📝 151 | ⬜ 053. Verificar se parênteses, chaves e colchetes estão balanceados em uma expressão 📝 152 | ⬜ 054. Implementar o algoritmo de Bubble Sort 🗂️ 153 | ⬜ 055. Implementar o algoritmo de Selection Sort 🗂️ 154 | ⬜ 056. Transpor uma matriz (linhas viram colunas e vice-versa) 🗂️ 155 | ⬜ 057. Somar duas matrizes de mesma dimensão 🗂️ 156 | ⬜ 058. Encontrar o par de elementos em um array cuja soma é igual a um valor X 🗂️ 157 | ⬜ 059. Converter um número Romano para Inteiro 🔢 158 | ⬜ 060. Converter um número Inteiro para Romano 🔢 159 | ⬜ 061. Encontrar a subsequência contígua de soma máxima em um array (Algoritmo de Kadane) 🗂️ 160 | ⬜ 062. Classe `ContaBancaria` com herança (ContaCorrente e ContaPoupanca) 🐒 161 | ⬜ 063. Classe `Veiculo` com polimorfismo (método `mover()` em Carro e Moto) 🐒 162 | ⬜ 064. Compressão de string simples (ex: "aaabbc" se torna "a3b2c1") 📝 163 | ⬜ 065. Encontrar a palavra mais longa em uma frase 📝 164 | ⬜ 066. Verificar se um número é um "número feliz" 🔢 165 | ⬜ 067. Calcular a raiz quadrada de um número sem usar `Math.sqrt()` (ex: método babilônico) 🔢 166 | ⬜ 068. Mesclar dois arrays ordenados em um único array ordenado 🗂️ 167 | ⬜ 069. Validar um endereço de e-mail simples usando regex 📝 168 | ⬜ 070. Contar a frequência de cada palavra em um texto usando um Map 📝 169 | ⬜ 071. POO: Criar um sistema de Biblioteca com as classes Livro e Biblioteca 🐒 170 | ⬜ 072. Encontrar o elemento que aparece um número ímpar de vezes em um array 🗂️ 171 | ⬜ 073. Usando `Stream` e `groupingBy`, agrupe uma lista de `Pessoa` por cidade 🗂️ 172 | ⬜ 074. Usando `Stream`, encontre a pessoa mais velha em uma lista de objetos `Pessoa` 🗂️ 173 | ⬜ 075. Use `flatMap` para transformar uma lista de listas de inteiros em uma única lista 🗂️ 174 | ⬜ 076. Dada uma lista de produtos, use `filter` e `map` para obter o nome dos produtos com preço > 100 📝 175 | ⬜ 077. Use `Collectors.joining` para criar uma string CSV a partir de uma lista de strings 📝 176 | ⬜ 078. Criar um comparador customizado com Lambda para ordenar objetos `Pessoa` por idade 🐒 177 | ⬜ 079. Usando `dropWhile`, remova os elementos de uma lista de inteiros até encontrar o primeiro número negativo 🗂️ 178 | ⬜ 080. Calcular a união de dois `Set` de inteiros 🗂️ 179 | ⬜ 081. Calcular a interseção de dois `Set` de strings 🗂️ 180 | ⬜ 082. Implementar um método `toString()` customizado em uma classe POO 🐒 181 | ⬜ 083. Sobrescrever os métodos `equals()` e `hashCode()` em uma classe POO 🐒 182 | ⬜ 084. Gerar todas as permutações de uma string 📝 183 | ⬜ 085. Encontrar o "pico" em um array (elemento maior que seus vizinhos) 🗂️ 184 | ⬜ 086. Calcular a moda de um array (o elemento que mais se repete) 🗂️ 185 | ⬜ 087. POO: Sistema de Figuras Geométricas com interface (ex: `Calculavel` com `calcularArea()`) 🐒 186 | ⬜ 088. Verificar se um `ArrayList` é um subconjunto de outro 🗂️ 187 | ⬜ 089. Usando `Stream`, calcular a média de idade de uma lista de pessoas 🗂️ 188 | ⬜ 090. Dividir uma lista em N sublistas de tamanho aproximadamente igual 🗂️ 189 | ⬜ 091. Implementar um cache LRU (Least Recently Used) simples usando `LinkedHashMap` 🗂️ 190 | ⬜ 092. Encontrar o caractere não repetido mais próximo do início de uma string 📝 191 | ⬜ 093. Desafio do elevador (POO: simular subidas e descidas) 🐒 192 | ⬜ 094. Calcular o fatorial de um número grande usando `BigInteger` 🔢 193 | ⬜ 095. Usando `Stream`, converter uma lista de `String` em uma lista de `Integer` 🗂️ 194 | ⬜ 096. Particionar uma lista de números em pares e ímpares usando `Collectors.partitioningBy` 🗂️ 195 | ⬜ 097. Criar uma classe `Fracao` e implementar operações de soma e multiplicação 🐒 196 | ⬜ 098. Simular a propagação de um boato em uma rede de pessoas (usando matriz de adjacência) 🗂️ 197 | 198 | ============================================== 199 | 🔁 Desafios com Laços e Condicionais (nível 3) 200 | ============================================== 201 | ✅ 001. Contagem Regressiva 🧩 202 | ✅ 002. Números Pares de 1 a 100 🧩 203 | ✅ 003. Soma de 10 números digitados 🧩 204 | ✅ 004. Número Secreto com Tentativas Infinitas 🧩 205 | ✅ 005. Menu com do-while 🧩 206 | ✅ 006. Contar números negativos, positivos e zeros 🧩 207 | ✅ 007. Tabuada de vários números 🔢 208 | ✅ 008. Soma até número negativo 🧩 209 | ✅ 009. Verificar número perfeito 🔢 210 | ✅ 010. Gerador de sequência: potências de 2 🔢 211 | ✅ 011. Média de notas com laço 🔢 212 | ✅ 012. Número Primo com break 🔢 213 | ✅ 013. Contar dígitos de um número 🔢 214 | ✅ 014. Inverter número inteiro 🔢 215 | ✅ 015. Jogo de adivinhação com tentativas limitadas 🧩 216 | ✅ 016. Imprimir um triângulo de asteriscos alinhado à esquerda 🧩 217 | ✅ 017. Imprimir um triângulo de asteriscos alinhado ao centro 🧩 218 | ✅ 018. Imprimir no console um triângulo simétrico de asteriscos 🧩 219 | ✅ 019. Verificar se um número é Armstrong 🔢 220 | ✅ 020. Gerar a tabuada de todos os números de 1 a 10 🔢 221 | ✅ 021. Simular um relógio digital (00:00 até 23:59) 🧩 222 | ✅ 022. Cronômetro simples (contar até N segundos) 🧩 223 | ⬜ 023. Somatório de série (1/1 + 1/2 + ... + 1/N) 🔢 224 | ⬜ 024. Fibonacci em formato de pirâmide 🔢 225 | ⬜ 025. Simulador de corrida (mostrar carros avançando a cada iteração) 🧩 226 | ⬜ 026. Jogo de Craps (dados com regras simples) 🧩 227 | ⬜ 027. Histograma no console (gráfico de barras com *) 🧩 228 | ⬜ 028. Verificar se um número é perfeito e listar divisores 🔢 229 | ⬜ 029. Pirâmide de Fibonacci 🔢 230 | ⬜ 030. Imprimir um quadrado oco de asteriscos 🧩 231 | ⬜ 031. Imprimir um losango de asteriscos 🧩 232 | ⬜ 032. Calcular a soma dos dígitos de um número usando laço 🔢 233 | ⬜ 033. Listar todos os divisores de um número informado 🔢 234 | ⬜ 034. Encontrar o primeiro múltiplo de 7 maior que 100 🧩 235 | ⬜ 035. Ler notas de alunos até que uma nota negativa seja inserida, e então calcular a média 🧩 236 | ⬜ 036. Pirâmide de números (ex: 1, 22, 333, ...) 🧩 237 | ⬜ 037. Triângulo de Floyd (1, 2 3, 4 5 6, ...) 🧩 238 | ⬜ 038. Simulação de caixa de supermercado (ler preço de produtos até o usuário digitar 0) 🧩 239 | ⬜ 039. Encontrar todos os números primos entre 1 e N 🔢 240 | ⬜ 040. Calcular `x` elevado a `y` usando um laço `for` 🔢 241 | ⬜ 041. Ler 5 números e, para cada um, dizer se é par ou ímpar 🧩 242 | ⬜ 042. Imprimir os 20 primeiros termos da sequência de Fibonacci 🔢 243 | ⬜ 043. Simular uma eleição com 3 candidatos, lendo votos até que o voto seja 0 🧩 244 | ⬜ 044. Triângulo de Pascal (imprimir as N primeiras linhas) 🔢 245 | ⬜ 045. Encontrar todos os pares de números amigos até N (ex: 220 e 284) 🔢 246 | ⬜ 046. Imprimir um tabuleiro de xadrez (8x8) usando 'X' e 'O' 🧩 247 | ⬜ 047. Validar entrada de usuário: pedir uma senha e só continuar quando a senha correta for digitada 🧩 248 | ⬜ 048. Calcular a soma dos elementos de uma diagonal principal de uma matriz quadrada 🗂️ 249 | ⬜ 049. Imprimir a sequência: 1, -2, 3, -4, 5, -6... até N 🧩 250 | ⬜ 050. Jogo do "Maior ou Menor": o programa sorteia um número e o usuário tenta adivinhar, recebendo dicas 🧩 251 | ⬜ 051. Ler uma frase e imprimir letra por letra com um pequeno delay entre elas 📝 252 | ⬜ 052. Simular um menu de banco (saque, depósito, saldo, sair) dentro de um `while(true)` 🧩 253 | ⬜ 053. Encontrar o produto dos números ímpares de 1 a 15 🔢 254 | ⬜ 054. Desenhar uma moldura retangular no console com asteriscos 🧩 255 | ⬜ 055. Ler um número e verificar se ele é um "número capicua" (palíndromo numérico) 🔢 256 | ⬜ 056. Simular o crescimento populacional de duas cidades A e B, com taxas de crescimento diferentes, até que A ultrapasse B 🧩 257 | ⬜ 057. Exibir todos os anos bissextos entre o ano 2000 e 2050 🔢 258 | ⬜ 058. Ler um conjunto de números e exibir o maior e o menor valor digitado 🧩 259 | 260 | ============================================== 261 | 📦 Outros Desafios 262 | ============================================== 263 | ✅ 001. Conversor de decimal para binário 🔢 264 | ✅ 002. Conversor de binário para decimal 🔢 265 | ⬜ 003. Verificar se um ano é bissexto 🔢 266 | ⬜ 004. Contar quantas vezes uma palavra aparece em um texto 📝 267 | ⬜ 005. Gerar senhas aleatórias de tamanho definido pelo usuário 📝 268 | ⬜ 006. Conversor de Decimal para Hexadecimal 🔢 269 | ⬜ 007. Conversor de Hexadecimal para Decimal 🔢 270 | ⬜ 008. Validar um formato de data simples (DD/MM/AAAA) 📝 271 | ⬜ 009. Calcular o número de dias entre duas datas 🧩 272 | ⬜ 010. Gerar um "slug" para URL a partir de um título (ex: "Meu Post" -> "meu-post") 📝 273 | 274 | ============================================== 275 | 🚀 Desafios Avançados (nível 4) 276 | ============================================== 277 | ⬜ 001. Sistema de cadastro de alunos (usar classes, lista e métodos CRUD) 🐒 278 | ⬜ 002. Implementar uma fila e uma pilha com ArrayList (simulando estrutura de dados) 🗂️ 279 | ⬜ 003. Criar um sistema de agenda de contatos com busca por nome ou telefone 🐒 280 | ⬜ 004. Implementar um mini-sistema bancário com transferências entre contas 🐒 281 | ⬜ 005. Criar um programa que leia um arquivo de texto e conte as palavras mais frequentes 📝 282 | ⬜ 006. Simular um jogo da velha para 2 jogadores no console 🐒 283 | ⬜ 007. Criar um programa que serialize e desserialize objetos em arquivos 🐒 284 | ⬜ 008. Implementar um sistema de notas de alunos usando HashMap (chave: nome, valor: lista de notas) 🗂️ 285 | ⬜ 009. Criar um simulador de carrinho de compras (POO + coleções) 🐒 286 | ⬜ 010. Desenvolver um mini-sistema de autenticação (login/senha) com persistência em arquivo 🐒 287 | ⬜ 011. Implementar uma Lista Ligada (LinkedList) do zero, com métodos `add`, `remove` e `find` 🗂️ 288 | ⬜ 012. Implementar uma Árvore Binária de Busca (BST) simples, com métodos `insert` e `search` 🗂️ 289 | ⬜ 013. Criar um leitor de arquivos CSV que parseia os dados e os armazena em uma lista de objetos 📝 290 | ⬜ 014. Desenvolver um sistema de gerenciamento de tarefas (To-Do List) no console com persistência em arquivo JSON 🐒 291 | ⬜ 015. Simular um sistema de votação eletrônica com candidatos e apuração de votos 🐒 292 | ⬜ 016. Criar um programa que resolva labirintos representados por matrizes 🧩 293 | ⬜ 017. Desenvolver um web scraper simples para extrair títulos de notícias de um site (usando bibliotecas como Jsoup) 📝 294 | ⬜ 018. Simulação do problema Produtor-Consumidor usando `wait()` e `notify()` para concorrência 🧩 295 | ⬜ 019. Criar um mini interpretador de uma linguagem simples (ex: calculadora com variáveis) 📝 296 | ⬜ 020. Jogo de Batalha Naval no console, com posicionamento de navios e lógica de ataque 🐒 --------------------------------------------------------------------------------