├── Desafios Aritméticos em Java ├── 1 - Divisores │ ├── Divisores.java │ └── README.md ├── 2 - Análise de Números │ ├── AnaliseNumeros.java │ └── README.md └── 3 - Contagem Repetida de Números │ ├── ContagemRepetida.java │ └── README.md ├── Extras └── Decompondo Números │ ├── DecompondoNumeros - Map.java │ ├── DecompondoNumeros - Percorrer Intervalo.java │ ├── DecompondoNumeros - Recursão.java │ └── README.md ├── Fundamentos Aritméticos em Java ├── 1 - Quantidade de números positivos │ ├── QuantidadePositivos.java │ └── README.md ├── 2 - Exibindo Números Pares │ ├── ExibicaoPares.java │ └── README.md ├── 3 - Análise de Números │ ├── AnaliseNumeros.java │ └── README.md ├── 4 - Contagem de Cédulas │ ├── ContagemCedulas.java │ └── README.md └── 5 - Consumo Médio do Automóvel │ ├── ConsumoMedio.java │ └── README.md ├── Introdução à Busca e Substituição em Java ├── 1 - Ordenação de Palavras por Tamanho │ ├── OrdenacaoPalavrasTamanho.java │ └── README.md ├── 2 - Encontre a maior substring │ ├── MaiorSubstring.java │ └── README.md ├── 3 - Validador de Senhas com requisitos │ ├── README.md │ └── ValidadorSenhas.java ├── 4 - Pedra, Papel, Tesoura, Lagarto e Spock │ ├── PedraPapelTesouraLagartoSpock.java │ └── README.md └── 5 - Atalhos para o Weblogger Brasil │ ├── AtalhosWebloggerBrasil.java │ └── README.md ├── Ordenação e Filtros em Java ├── 1 - Ordenando Números Pares e Ímpares │ ├── OrdenacaoParImpar.java │ └── README.md ├── 2 - Compras no Supermercado │ ├── ComprasSupermercado.java │ └── README.md ├── 3 - Uniformes de final de ano │ ├── README.md │ └── UniformesFinalAno.java ├── 4 - Fila do banco │ ├── FilaBanco.java │ └── README.md └── 5 - Gincana no Acampamento │ ├── GincanaAcampamento.java │ └── README.md ├── Praticando programação em Java ├── 1 - Abreviando posts do Blog │ ├── AbreviandoBlogPost.java │ ├── Explicações e Dicas.md │ └── README.md ├── 2 - Conjuntos Bons ou Ruins │ ├── ConjuntoBomRuim.java │ ├── Explicações e Dicas.md │ └── README.md ├── 3 - Encontre a maior substring │ ├── MaiorSubstring.java │ └── README.md ├── 4 - Entrevista Embaraçosa │ ├── EntrevistaEmbaracosa.java │ ├── Explicações e Dicas.md │ └── README.md └── 5 - Validador Senhas │ ├── README.md │ └── ValidadorSenhas.java ├── Resolvendo Algoritmos com Java ├── 1 - Coração das Cartas │ ├── CoracaoCartas.java │ └── README.md ├── 2- Abreviando posts do Blog │ ├── AbreviandoBlogPost.java │ ├── Explicações e Dicas.md │ └── README.md ├── 3 - Combinação de strings │ ├── CombinacaoStrings.java │ └── README.md ├── 4 - Hash Mágico │ ├── HashMagico.java │ └── README.md └── 5 - O Tabuleiro Secreto │ ├── README.md │ └── TabuleiroSecreto.java ├── Solucionando problemas básicos em Java ├── 1 - Multiplicação Simples │ └── MultiplicacaoSimples.java ├── 2 - Menor e Posição │ ├── MenorEPosicaoMelhorado.java │ └── MenorEPosicaoSugestaoDIO.java └── 3 - Números Ímpares │ └── NumerosImpares.java └── Solução de Problemas com Java ├── 1 - Contagem Repetida de números ├── ContagemRepetida.java └── README.md ├── 2 - Vogais Extraterrestres ├── README.md └── VogaisExtraterrestres.java ├── 3 - Melhor amigo do Pablo ├── MelhorAmigoPablo.java └── README.md ├── 4 - Entrevista Embaraçosa ├── EntrevistaEmbaracosa.java ├── Explicações e Dicas.md └── README.md ├── 5 - Conjuntos Bons ou Ruins ├── ConjuntoBomRuim.java ├── Explicações e Dicas.md └── README.md └── 6 - Produto e divisão ├── ProdutoDivisao.java └── README.md /Desafios Aritméticos em Java/1 - Divisores/Divisores.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.IOException; 3 | import java.io.InputStreamReader; 4 | import java.util.StringTokenizer; 5 | 6 | public class minhaClasse { 7 | public static void main(String[] args) throws IOException { 8 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 9 | StringTokenizer st = new StringTokenizer(br.readLine()); 10 | 11 | int A = Integer.parseInt(st.nextToken()); 12 | int B = Integer.parseInt(st.nextToken()); 13 | int C = Integer.parseInt(st.nextToken()); 14 | int D = Integer.parseInt(st.nextToken()); 15 | br.close(); 16 | 17 | int menorValor = -1; 18 | 19 | if (C % A == 0) { 20 | for(int i = 1; i <= C/A; i++){ 21 | int n = A*i; 22 | if (n % B != 0 && D % n != 0 && C % n ==0) { 23 | menorValor = n; 24 | break; 25 | } 26 | } 27 | } 28 | System.out.println(menorValor); 29 | } 30 | } -------------------------------------------------------------------------------- /Desafios Aritméticos em Java/1 - Divisores/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Pense um número positivo n. Agora me diga um divisor A de n. Agora me dê um outro número B que não seja divisor de n. Agora um múltiplo C. E um não múltiplo D. O número que você pensou é... 3 | 4 | Parece um truque de mágica, mas é matemática! Será que, conhecendo os números A, B, C e D, você consegue descobrir qual era o número original n? Note que pode existir mais de uma solução! 5 | 6 | Neste problema, dados os valores de A, B, C e D, você deve escrever um programa que determine qual o menor número n que pode ter sido pensado ou concluir que não existe um valor possível. 7 | 8 | # Entrada 9 | A entrada consiste de uma única linha que contém quatro números inteiros A, B, C, e D, como descrito acima (1 ≤ A, B, C, D ≤ 109). 10 | 11 | # Saída 12 | Seu programa deve produzir uma única linha. Caso exista pelo menos um número n para os quais A, B, C e D façam sentido, a linha deve conter o menor n possível. Caso contrário, a linha deve conter -1. 13 | 14 | | Exemplo de Entrada | Exemplo de Saída| 15 | | ---|--- | 16 | |2 12 8 2
3 4 60 105|4
6| -------------------------------------------------------------------------------- /Desafios Aritméticos em Java/2 - Análise de Números/AnaliseNumeros.java: -------------------------------------------------------------------------------- 1 | import java.io.IOException; 2 | import java.util.Scanner; 3 | import java.lang.Math; 4 | 5 | public class AnaliseNumeros { 6 | 7 | public static void main(String[] args) throws IOException { 8 | Scanner leitor = new Scanner(System.in); 9 | 10 | int par = 0; 11 | int impar = 0; 12 | int positivo = 0; 13 | int negativo = 0; 14 | int entrada; 15 | 16 | while (leitor.hasNextInt()) { 17 | entrada = leitor.nextInt(); 18 | if (entrada % 2 == 0) par++; 19 | if (Math.abs(entrada % 2) == 1) impar++; 20 | if (entrada > 0) positivo++; 21 | if (entrada < 0) negativo++; 22 | } 23 | 24 | System.out.println(par + " valor(es) par(es)"); 25 | System.out.println(impar + " valor(es) impar(es)"); 26 | System.out.println(positivo + " valor(es) positivo(s)"); 27 | System.out.println(negativo + " valor(es) negativo(s)"); 28 | } 29 | } -------------------------------------------------------------------------------- /Desafios Aritméticos em Java/2 - Análise de Números/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Você deve fazer a leitura de 5 valores inteiros. Em seguida mostre quantos valores informados são pares, quantos valores informados são ímpares, quantos valores informados são positivos e quantos valores informados são negativos. 3 | 4 | # Entrada 5 | Você receberá 5 valores inteiros. 6 | 7 | # Saída 8 | Exiba a mensagem conforme o exemplo de saída abaixo, sendo uma mensagem por linha e não esquecendo o final de linha após cada uma. 9 | 10 | | Exemplo de Entrada | Exemplo de Saída| 11 | | ---|--- | 12 | |-5
0
-3
-4
12|3 valor(es) par(es)
2 valor(es) impar(es)
1 valor(es) positivo(s)
3 valor(es) negativo(s)| -------------------------------------------------------------------------------- /Desafios Aritméticos em Java/3 - Contagem Repetida de Números/ContagemRepetida.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Locale; 3 | import java.util.Scanner; 4 | import java.util.SortedMap; 5 | import java.util.TreeMap; 6 | 7 | public class ContagemRepetida { 8 | 9 | public static void main(String[] args) { 10 | Scanner sc = new Scanner(System.in); 11 | ArrayList lista = new ArrayList(); 12 | 13 | int entrada =sc.nextInt(); 14 | while(entrada --> 0) 15 | lista.add(sc.nextInt()); 16 | 17 | SortedMap contaQuant = new TreeMap<>(); 18 | lista.forEach(id -> contaQuant.compute(id, (key , val) -> (val == null ? 1 : val + 1))); 19 | 20 | contaQuant.entrySet().forEach(entry->{ 21 | System.out.printf("%d aparece %d vez(es)\n", entry.getKey(), entry.getValue()); 22 | }); 23 | 24 | sc.close(); 25 | } 26 | } -------------------------------------------------------------------------------- /Desafios Aritméticos em Java/3 - Contagem Repetida de Números/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Neste desafio sua tarefa será ler vários números e em seguida dizer quantas vezes cada número aparece, ou seja, deve-se escrever cada um dos valores distintos que aparecem na entrada por ordem crescente de valor. 3 | 4 | # Entrada 5 | A primeira linha de entrada contem um único inteiro N, que indica a quantidade de valores que serão lidos para X (1 ≤ N ≤ 2000) logo em seguida. Com certeza cada número não aparecerá mais do que 20 vezes na entrada de dados. 6 | 7 | # Saída 8 | Imprima a saída de acordo com o exemplo fornecido abaixo, indicando quantas vezes cada um deles aparece na entrada por ordem crescente de valor. 9 | 10 | | Exemplo de Entrada | Exemplo de Saída| 11 | | ---|--- | 12 | |7
8
10
8
260
4
10
10|4 aparece 1 vez(es)
8 aparece 2 vez(es)
10 aparece 3 vez(es)
260 aparece 1 vez(es)| -------------------------------------------------------------------------------- /Extras/Decompondo Números/DecompondoNumeros - Map.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.HashMap; 3 | import java.util.List; 4 | import java.util.Map; 5 | 6 | public class Main { 7 | public static void main(String[] args) { 8 | 9 | int maxDigit = 9; 10 | int fourDigitSum = 21; 11 | 12 | Map> twoDigitSumsToTwoDigitNumbers = createMapWithTwoDigitSums(maxDigit, fourDigitSum); 13 | printAllCombinations(fourDigitSum, twoDigitSumsToTwoDigitNumbers); 14 | } 15 | 16 | private static Map> createMapWithTwoDigitSums(int maxDigit, int fourDigitSum) { 17 | Map> twoDigitSumsToTwoDigitNumbers = new HashMap<>(); 18 | 19 | int maxTwoDigitSum = 2 * maxDigit; 20 | int minTwoDigitSum = fourDigitSum - 2 * maxDigit; 21 | for (int twoDigitSum = maxTwoDigitSum; twoDigitSum >= minTwoDigitSum; twoDigitSum--) { 22 | List twoDigitsList = new ArrayList<>(); 23 | int firstDigit = maxDigit <= twoDigitSum ? maxDigit : twoDigitSum; 24 | for (int j = firstDigit; j >= twoDigitSum - firstDigit; j--) { 25 | Integer twoDigitsInteger = 10 * j + twoDigitSum - j; 26 | twoDigitsList.add(twoDigitsInteger >= 10 ? String.valueOf(twoDigitsInteger) 27 | : String.valueOf("0" + twoDigitsInteger)); 28 | } 29 | twoDigitSumsToTwoDigitNumbers.put(twoDigitSum, twoDigitsList); 30 | } 31 | return twoDigitSumsToTwoDigitNumbers; 32 | } 33 | 34 | private static void printAllCombinations(int fourDigitSum, Map> twoDigitSumsToTwoDigitNumbers) { 35 | for (Integer key : twoDigitSumsToTwoDigitNumbers.keySet()) { 36 | List twoFirstDigitsList = twoDigitSumsToTwoDigitNumbers.get(key); 37 | List twoLastDigitsList = twoDigitSumsToTwoDigitNumbers.get(fourDigitSum - key); 38 | 39 | for (String twoFirstDigits : twoFirstDigitsList) { 40 | if(!twoFirstDigits.startsWith("0")) { 41 | for (String twoLastDigits : twoLastDigitsList) { 42 | System.out.println(twoFirstDigits + twoLastDigits); 43 | } 44 | } 45 | } 46 | } 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /Extras/Decompondo Números/DecompondoNumeros - Percorrer Intervalo.java: -------------------------------------------------------------------------------- 1 | public class Main { 2 | public static void main(String[] args) { 3 | 4 | int maxDigit = 9; 5 | int fourDigitSum = 21; 6 | int maxNumber = maxDigit * 1000 + maxDigit * 100 + maxDigit * 10 + maxDigit; 7 | 8 | for (int i = 1000; i <= maxNumber; i++) { 9 | if (sumDigitsLessThanMaxDigit(i, maxDigit) == fourDigitSum) 10 | System.out.println(i); 11 | } 12 | } 13 | 14 | public static Integer sumDigitsLessThanMaxDigit(int n, int maxDigit) { 15 | Integer sum = 0; 16 | while (n > 0) { 17 | int lastDigit = n % 10; 18 | if (lastDigit > maxDigit) 19 | return -1; 20 | sum += n % 10; 21 | n /= 10; 22 | } 23 | return sum; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /Extras/Decompondo Números/DecompondoNumeros - Recursão.java: -------------------------------------------------------------------------------- 1 | public class Main { 2 | 3 | private static final int MAX_DIGIT = 9; 4 | private static final int FOUR_DIGIT_SUM = 21; 5 | private static final int QUANTITY_DIGITS = 4; 6 | 7 | public static void main(String[] args) { 8 | printDigits("", QUANTITY_DIGITS, FOUR_DIGIT_SUM); 9 | } 10 | 11 | public static void printDigits(String prefix, int digitsLeft, int sum) { 12 | if (digitsLeft == 1) { 13 | System.out.println(prefix + String.valueOf(sum)); 14 | return; 15 | } 16 | 17 | int maxLimit = MAX_DIGIT > sum ? sum : MAX_DIGIT; 18 | int minLimit = sum - (digitsLeft - 1) * MAX_DIGIT; 19 | for (int j = maxLimit; j >= minLimit && (j > 0 || (j == 0 && digitsLeft != QUANTITY_DIGITS)); j--) { 20 | printDigits(prefix + String.valueOf(j), digitsLeft - 1, sum - j); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Extras/Decompondo Números/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Complete a seguinte função para que a mesma devolva todos os possíveis números de 4 dígitos, onde cada um seja menor ou igual a um valor maxDigit, e a soma dos dígitos de cada número gerado seja 21. 3 | 4 | # Entrada 5 | Você receberá o valor de maxDigit. 6 | 7 | # Saída 8 | Exiba todas as combinações de números de quatro dígitos satisfazendo as condições informadas. 9 | 10 | | Exemplo de Entrada | Exemplo de Saída| 11 | | ---|--- | 12 | |6|6366
5466
4566
3666
6465
6456
5565
5556
4665
4656
6564
6555
6546
5664
5655
5646
6663
6654
6645
6636| -------------------------------------------------------------------------------- /Fundamentos Aritméticos em Java/1 - Quantidade de números positivos/QuantidadePositivos.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class QuantidadePositivos { 4 | public static void main(String[] args) { 5 | Scanner sc = new Scanner(System.in); 6 | 7 | int contador = 0; 8 | while (sc.hasNextDouble()) 9 | if (sc.nextDouble() > 0) 10 | contador++; 11 | 12 | System.out.println(contador + " valores positivos"); 13 | } 14 | } -------------------------------------------------------------------------------- /Fundamentos Aritméticos em Java/1 - Quantidade de números positivos/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Crie um programa que leia 6 valores. Você poderá receber valores negativos e/ou positivos como entrada, devendo desconsiderar os valores nulos. Em seguida, apresente a quantidade de valores positivos digitados. 3 | 4 | # Entrada 5 | Você receberá seis valores, negativos e/ou positivos. 6 | 7 | # Saída 8 | Exiba uma mensagem dizendo quantos valores positivos foram lidos assim como é exibido abaixo no exemplo de saída. Não esqueça da mensagem "valores positivos" ao final. 9 | 10 | | Exemplo de Entrada | Exemplo de Saída| 11 | | ---|--- | 12 | |7
-5
6
-3.4
4.6
12|4 valores positivos| -------------------------------------------------------------------------------- /Fundamentos Aritméticos em Java/2 - Exibindo Números Pares/ExibicaoPares.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class ExibicaoPares { 4 | 5 | public static void main(String[] args) { 6 | Scanner sc = new Scanner(System.in); 7 | int entrada = sc.nextInt(); 8 | for (int i = 2; i <= entrada; i = i + 2) 9 | System.out.println(i); 10 | } 11 | 12 | } -------------------------------------------------------------------------------- /Fundamentos Aritméticos em Java/2 - Exibindo Números Pares/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Crie um programa que leia um número e mostre os números pares até esse número, inclusive ele mesmo. 3 | 4 | # Entrada 5 | Você receberá 1 valor inteiro N, onde N > 0. 6 | 7 | # Saída 8 | Exiba todos os números pares até o valor de entrada, sendo um em cada linha. 9 | 10 | | Exemplo de Entrada | Exemplo de Saída| 11 | | ---|--- | 12 | |6|2
4
6| -------------------------------------------------------------------------------- /Fundamentos Aritméticos em Java/3 - Análise de Números/AnaliseNumeros.java: -------------------------------------------------------------------------------- 1 | import java.io.IOException; 2 | import java.util.Scanner; 3 | import java.lang.Math; 4 | 5 | public class AnaliseNumeros { 6 | 7 | public static void main(String[] args) throws IOException { 8 | Scanner leitor = new Scanner(System.in); 9 | 10 | int par = 0; 11 | int impar = 0; 12 | int positivo = 0; 13 | int negativo = 0; 14 | int entrada; 15 | 16 | while (leitor.hasNextInt()) { 17 | entrada = leitor.nextInt(); 18 | if (entrada % 2 == 0) par++; 19 | if (Math.abs(entrada % 2) == 1) impar++; 20 | if (entrada > 0) positivo++; 21 | if (entrada < 0) negativo++; 22 | } 23 | 24 | System.out.println(par + " valor(es) par(es)"); 25 | System.out.println(impar + " valor(es) impar(es)"); 26 | System.out.println(positivo + " valor(es) positivo(s)"); 27 | System.out.println(negativo + " valor(es) negativo(s)"); 28 | } 29 | } -------------------------------------------------------------------------------- /Fundamentos Aritméticos em Java/3 - Análise de Números/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Você deve fazer a leitura de 5 valores inteiros. Em seguida mostre quantos valores informados são pares, quantos valores informados são ímpares, quantos valores informados são positivos e quantos valores informados são negativos. 3 | 4 | # Entrada 5 | Você receberá 5 valores inteiros. 6 | 7 | # Saída 8 | Exiba a mensagem conforme o exemplo de saída abaixo, sendo uma mensagem por linha e não esquecendo o final de linha após cada uma. 9 | 10 | | Exemplo de Entrada | Exemplo de Saída| 11 | | ---|--- | 12 | |-5
0
-3
-4
12|3 valor(es) par(es)
2 valor(es) impar(es)
1 valor(es) positivo(s)
3 valor(es) negativo(s)| -------------------------------------------------------------------------------- /Fundamentos Aritméticos em Java/4 - Contagem de Cédulas/ContagemCedulas.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class ContagemCedulas { 4 | 5 | public static void main(String[] args) { 6 | int entrada = (new Scanner(System.in)).nextInt(); 7 | System.out.println(entrada); 8 | int[] notas = { 100, 50, 20, 10, 5, 2, 1 }; 9 | 10 | for (int i = 0; i < notas.length; i++) { 11 | int quantidadeNotas = entrada / notas[i]; 12 | System.out.println(quantidadeNotas + " nota(s) de R$ " + notas[i] + ",00"); 13 | entrada -= quantidadeNotas * notas[i]; 14 | } 15 | } 16 | 17 | } -------------------------------------------------------------------------------- /Fundamentos Aritméticos em Java/4 - Contagem de Cédulas/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Faça a leitura de um valor inteiro. Em seguida, calcule o menor número de notas possíveis (cédulas) onde o valor pode ser decomposto. As notas que você deve considerar são de 100, 50, 20, 10, 5, 2 e 1. Na sequência mostre o valor lido e a relação de notas necessárias. 3 | 4 | # Entrada 5 | Você receberá um valor inteiro N (0 < N < 1000000). 6 | 7 | # Saída 8 | Exiba o valor lido e a quantidade mínima de notas de cada tipo necessárias, seguindo o exemplo de saída abaixo. Após cada linha deve ser imprimido o fim de linha. 9 | 10 | | Exemplo de Entrada | Exemplo de Saída| 11 | | ---|--- | 12 | |576|576
5 nota(s) de R$ 100,00
1 nota(s) de R$ 50,00
1 nota(s) de R$ 20,00
0 nota(s) de R$ 10,00
1 nota(s) de R$ 5,00
0 nota(s) de R$ 2,00
1 nota(s) de R$ 1,00| 13 | |11257|11257
112 nota(s) de R$ 100,00
1 nota(s) de R$ 50,00
0 nota(s) de R$ 20,00
0 nota(s) de R$ 10,00
1 nota(s) de R$ 5,00
1 nota(s) de R$ 2,00
0 nota(s) de R$ 1,00| 14 | |503|503
5 nota(s) de R$ 100,00
0 nota(s) de R$ 50,00
0 nota(s) de R$ 20,00
0 nota(s) de R$ 10,00
0 nota(s) de R$ 5,00
1 nota(s) de R$ 2,00
1 nota(s) de R$ 1,00| -------------------------------------------------------------------------------- /Fundamentos Aritméticos em Java/5 - Consumo Médio do Automóvel/ConsumoMedio.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class ConsumoMedio { 4 | 5 | public static void main(String[] args) { 6 | Scanner leitor = new Scanner(System.in); 7 | int distance = leitor.nextInt(); 8 | Double consumption = leitor.nextDouble(); 9 | Double mediumConsumption = distance / consumption; 10 | System.out.printf("%.3f km/l", mediumConsumption); 11 | } 12 | } -------------------------------------------------------------------------------- /Fundamentos Aritméticos em Java/5 - Consumo Médio do Automóvel/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Você deve calcular o consumo médio de um automóvel onde será informada a distância total percorrida (em Km) e o total de combustível consumido (em litros). 3 | 4 | # Entrada 5 | Você receberá dois valores: um valor inteiro X com a distância total percorrida (em Km), e um valor real Y que representa o total de combustível consumido, com um dígito após o ponto decimal. 6 | 7 | # Saída 8 | Exiba o valor que representa o consumo médio do automóvel (3 casas após a vírgula), incluindo no final a mensagem "km/l". 9 | 10 | | Exemplo de Entrada | Exemplo de Saída| 11 | | ---|--- | 12 | |550
35.0|14.286 km/l| 13 | |2254
124.4|18.119 km/l| 14 | |4554
464.6|9.802 km/l| -------------------------------------------------------------------------------- /Introdução à Busca e Substituição em Java/1 - Ordenação de Palavras por Tamanho/OrdenacaoPalavrasTamanho.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | import java.util.Comparator; 3 | import java.util.List; 4 | import java.util.Scanner; 5 | import java.util.stream.Collectors; 6 | 7 | public class OrdenacaoPalavrasTamanho { 8 | public static void main(String[] args) { 9 | Scanner sc = new Scanner(System.in); 10 | int quantidadeListas = sc.nextInt(); 11 | 12 | Comparator comparatorPalavras = Comparator.comparing(String::length, Comparator.reverseOrder()) 13 | .thenComparing(Comparator.naturalOrder()); 14 | 15 | while (sc.hasNextLine()) { 16 | String linha = sc.nextLine(); 17 | List lista = Arrays.asList(linha.split(" ")); 18 | System.out.println(lista.stream().sorted(comparatorPalavras).collect(Collectors.joining(" "))); 19 | } 20 | } 21 | } -------------------------------------------------------------------------------- /Introdução à Busca e Substituição em Java/1 - Ordenação de Palavras por Tamanho/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Crie um algoritmo para ordenar um conjunto de palavras pelo seu tamanho. Seu programa deve receber um conjunto de palavras e retornar este mesmo conjunto ordenado pelo tamanho das palavras decrescente, se o tamanho das palavras for igual, deve-se ordernar por ordem alfabética. 3 | 4 | # Entrada 5 | A primeira linha da entrada possui um único inteiro N, que indica o número de casos de teste. Cada caso de teste poderá conter de 1 a 50 palavras inclusive, e cada uma das palavras poderá conter entre 1 e 50 caracteres inclusive. Os caracteres poderão ser espaços, letras, ou números. 6 | 7 | # Saída 8 | A saída deve conter o conjunto de palavras da entrada ordenado pelo tamanho das palavras e caso o tamanho das palavras for igual, deve-se ordernar por ordem alfabética.. Um espaço em branco deve ser impresso entre duas palavras. 9 | 10 | | Exemplo de Entrada | Exemplo de Saída| 11 | | ---|--- | 12 | |2
One three four mond at midnight
one three five|midnight three four mond One at
three five one| 13 | 14 | -------------------------------------------------------------------------------- /Introdução à Busca e Substituição em Java/2 - Encontre a maior substring/MaiorSubstring.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.IOException; 3 | import java.io.InputStreamReader; 4 | import java.io.PrintWriter; 5 | 6 | public class MaiorSubstring { 7 | 8 | static BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); 9 | static PrintWriter out = new PrintWriter(System.out); 10 | 11 | public static void main(String[] args) throws IOException { 12 | String s1, s2, min, max; 13 | while ((s1 = in.readLine()) != null) { 14 | s2 = in.readLine(); 15 | if ( s1.length() > s2.length() ) { 16 | max = s1; 17 | min = s2; 18 | } else { 19 | max = s2; 20 | min = s1; 21 | } 22 | int minLength = min.length(); 23 | int maxS = minLength; 24 | boolean f = true; 25 | while (maxS > 0 && f) { 26 | int diff = minLength - maxS; 27 | for (int i = 0; i <= diff; i++) { 28 | if (max.contains(min.substring(i, i + maxS))) { 29 | f = false; 30 | maxS++; 31 | break; 32 | } 33 | } 34 | maxS--; 35 | } 36 | System.out.println(maxS); 37 | } 38 | out.close(); 39 | } 40 | 41 | } -------------------------------------------------------------------------------- /Introdução à Busca e Substituição em Java/2 - Encontre a maior substring/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Encontre a maior substring comum entre as duas strings informadas. A substring pode ser qualquer parte da string, inclusive ela toda. Se não houver subseqüência comum, a saída deve ser “0”. A comparação é case sensitive ('x' != 'X'). 3 | 4 | # Entrada 5 | A entrada contém vários casos de teste. Cada caso de teste é composto por duas linhas, cada uma contendo uma string. Ambas strings de entrada contém entre 1 e 50 caracteres ('A'-'Z','a'-'z' ou espaço ' '), inclusive, ou no mínimo uma letra ('A'-'Z','a'-'z'). 6 | 7 | # Saída 8 | O tamanho da maior subsequência comum entre as duas Strings. 9 | 10 | | Exemplo de Entrada | Exemplo de Saída| 11 | | ---|--- | 12 | | abcdef
cdofhij|2| 13 | |TWO
FOUR|1| 14 | |abracadabra
open|5| 15 | |Hey This java is hot
Java is a new paradigm|7 | 16 | 17 | -------------------------------------------------------------------------------- /Introdução à Busca e Substituição em Java/3 - Validador de Senhas com requisitos/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Pedro e Fernando são os desenvolvedores em uma stratup e vão desenvolver o novo sistema de cadastro, e pediram a sua ajuda. Sua task é fazer o código que valide as senhas que são cadastradas, para isso você deve atentar aos requisitos a seguir: 3 | 4 | - A senha deve conter, no mínimo, uma letra maiúscula, uma letra minúscula e um número; 5 | - A mesma não pode ter nenhum caractere de pontuação, acentuação ou espaço; 6 | - Além disso, a senha pode ter de 6 a 32 caracteres. 7 | 8 | # Entrada 9 | A saída contém uma linha, que pode ser “Senha valida.”, caso a senha tenha cada item dos requisitos solicitados anteriormente, ou “Senha invalida.”, se um ou mais requisitos não forem atendidos. 10 | 11 | # Saída 12 | Para cada caso de teste, escreva a palavra devidamente corrigida. Analise os exemplos para verificar o padrão, de modo a consertar todos os casos. 13 | 14 | | Exemplo de Entrada | Exemplo de Saída| 15 | | ---|--- | 16 | |Digital Innovation One| Senha invalida.| 17 | |AbcdEfgh99| Senha valida.| 18 | |DigitalInnovationOne123| Senha valida.| 19 | |Digital Innovation One 123 | Senha invalida.| 20 | |Aass9| Senha invalida.| 21 | |Aassd9| Senha valida.| 22 | 23 | -------------------------------------------------------------------------------- /Introdução à Busca e Substituição em Java/3 - Validador de Senhas com requisitos/ValidadorSenhas.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.InputStreamReader; 3 | import java.io.IOException; 4 | import java.util.Arrays; 5 | 6 | public class ValidadorSenhas { 7 | 8 | public static void main(String[] args) throws IOException { 9 | 10 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 11 | String password; 12 | 13 | while ((password = br.readLine()) != null) { 14 | boolean isCorrectLength = password.length() >= 6 && password.length() <= 32; 15 | boolean containsPontuation = !password.matches("^(?=.*[a-zA-Z])(?=.*[0-9])[A-Za-z0-9]+$"); 16 | boolean containsNumber = false; 17 | boolean containsUpperCase = false; 18 | boolean containsLowerCase = false; 19 | 20 | for (int i = 0; i < password.length(); i++) { 21 | if (Character.isDigit(password.charAt(i))) { 22 | containsNumber = true; 23 | } else if (Character.isUpperCase(password.charAt(i))) { 24 | containsUpperCase = true; 25 | } else if (Character.isLowerCase(password.charAt(i))) { 26 | containsLowerCase = true; 27 | } 28 | } 29 | 30 | if (isCorrectLength && !containsPontuation && containsNumber && containsUpperCase && containsLowerCase) { 31 | System.out.println("Senha valida."); 32 | } else { 33 | System.out.println("Senha invalida."); 34 | } 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /Introdução à Busca e Substituição em Java/4 - Pedra, Papel, Tesoura, Lagarto e Spock/PedraPapelTesouraLagartoSpock.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | import java.util.List; 3 | import java.util.Scanner; 4 | 5 | public class PedarPapelTesouraLagartoSpock { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | List combinacoes = Arrays.asList(new String[]{"tesoura papel", "papel pedra", "pedra lagarto", "lagarto spock", "spock tesoura", 9 | "tesoura lagarto", "lagarto papel", "papel spock", "spock pedra", "pedra tesoura"}); 10 | 11 | sc.nextLine(); 12 | while (sc.hasNextLine()) { 13 | String linha = sc.nextLine(); 14 | if(linha.split(" ")[0].equals(linha.split(" ")[1])) { 15 | System.out.println("empate"); 16 | } else if (combinacoes.contains(linha)){ 17 | System.out.println("fernanda"); 18 | } else { 19 | System.out.println("marcia"); 20 | } 21 | } 22 | } 23 | } -------------------------------------------------------------------------------- /Introdução à Busca e Substituição em Java/4 - Pedra, Papel, Tesoura, Lagarto e Spock/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Pedra-papel-tesoura-lagarto-Spock é uma expansão do clássico método de seleção em jogo de pedra-papel-tesoura. Atua sob o mesmo princípio básico, mas inclui outras duas armas adicionais: o lagarto (formado pela mão igual a uma boca de fantoche) e Spock (formada pela saudação dos vulcanos em Star Trek). Isso reduz as chances de uma rodada terminar em um empate. O jogo foi inventado por Sam Kass e Karen Bryla, como "Rock Paper Scissors Lizard Spock". As regras de vantagem são as seguintes: 3 | - Tesoura corta papel 4 | - Papel cobre pedra 5 | - Pedra derruba lagarto 6 | - Lagarto adormece Spock 7 | - Spock derrete tesoura 8 | - Tesoura prende lagarto 9 | - Lagarto come papel 10 | - Papel refuta Spock 11 | - Spock vaporiza pedra 12 | - Pedra quebra tesoura 13 | Um dia, duas amigas, Fernanda e Marcia, decidiram apostar quem pagaria um almoço para o outro, com esta brincadeira. Sua missão será fazer um algoritmo que, baseado no que eles escolherem, informe quem irá ganhar ou se dará empate. 14 | 15 | # Entrada 16 | Haverá diversos casos de teste. O primeiro número a ser lido será um inteiro, representando a quantidade de casos de teste. Cada caso de teste tem duas palavras, representando a escolha de Fernanda e de Marcia, respectivamente. 17 | 18 | # Saída 19 | Para cada caso de teste, imprima quem venceu, ou se houve empate. 20 | 21 | | Exemplo de Entrada | Exemplo de Saída| 22 | | ---|--- | 23 | |3
spock spock
tesoura spock
lagarto spock|empate
Marcia
Fernanda| 24 | 25 | -------------------------------------------------------------------------------- /Introdução à Busca e Substituição em Java/5 - Atalhos para o Weblogger Brasil/AtalhosWebloggerBrasil.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class AtalhosWebloggerBrasil { 4 | public static void main(String[] args) { 5 | Scanner sc = new Scanner(System.in); 6 | while (sc.hasNextLine()) { 7 | String tagHTML = sc.nextLine().replace("_", "").replace("*", ""); 8 | 9 | String[] tagHTMLItalico = tagHTML.split("").replace("*", "").split("<"); 39 | StringBuilder stringBuilder = new StringBuilder(tagHTML[0]); 40 | 41 | for(int i = 1; i < tagHTML.length; i++) { 42 | if(i %2 == 1) stringBuilder.append("<"); 43 | else stringBuilder.append(" e , mas no Weblogger Brasil um autor pode simplesmente colocar um pedaço de texto entre dois caracteres de sublinhado, '_'. Portanto, onde um autor escreve 5 | 6 | `Você _deveria_ ver a foca no zoologico!` 7 | 8 | Weblogger Brasil vai publicar o seguinte: 9 | 10 | `Você deveria ver a foca no zoologico!` 11 | 12 | Outro atalho serve para colocar texto em negrito, o que, em HTML, é feito com as tags e . Weblogger Brasil permite aos autores fazer o mesmo com pares do caractere asterisco, '*'. Quando um autor escreve o texto 13 | 14 | `Marque a conta *a receber* para *paga*.` 15 | 16 | ele vai sair no website assim: 17 | 18 | `Marque a conta a receber para paga.` 19 | 20 | # Entrada 21 | A entrada contem vários casos de teste. Cada caso de teste é composto por uma linha que contem uma string texto, com zero ou mais usos dos atalhos itálico e negrito. Cada texto tem de 1 a 50 caracteres, inclusive. Os únicos caracteres permitidos no texto são os caracteres alfabéticos (de 'a' a 'z' e de 'A' a 'Z'), o sublinhado ('_'), o asterisco ('*'), o caractere de espaço e os símbolos de pontuação ',', ';', '.', '!', '?', '-', '(' e ')'. O caractere sublinhado '_' ocorre no texto um número par de vezes. O asterisco '*' também aparece um número par de vezes no texto. Nenhuma substring do texto entre um par de sublinhados ou entre um par de asteriscos pode conter outros sublinhados ou asteriscos, respectivamente. 22 | 23 | # Saída 24 | Para cada linha de entrada seu programa deve gerar uma linha de saída com o texto traduzido para HTML como demonstrado nos exemplos abaixo. Para tornar itálico um pedaço de texto no HTML, você deve iniciar este pedaço com a tag e terminá-lo com a tag . Para texto em negrito, inicie com e termine com . 25 | 26 | | Exemplo de Entrada | Exemplo de Saída| 27 | | ---|--- | 28 | |`Você _deveria_ ver a foca no zoologico!`
`Marque a conta *a receber* para *paga*.`|`Você deveria ver a foca no zoologico!`
`Marque a conta a receber para paga.`| 29 | 30 | -------------------------------------------------------------------------------- /Ordenação e Filtros em Java/1 - Ordenando Números Pares e Ímpares/OrdenacaoParImpar.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Collections; 3 | import java.util.List; 4 | import java.util.Scanner; 5 | 6 | public class OrdenacaoParImpar { 7 | public static void main(String[] args) { 8 | Scanner sc = new Scanner(System.in); 9 | int N = sc.nextInt(); 10 | List pares = new ArrayList<>(); 11 | List impares = new ArrayList<>(); 12 | 13 | while (sc.hasNextInt()) { 14 | int entrada = sc.nextInt(); 15 | if (entrada % 2 == 0) pares.add(entrada); 16 | else impares.add(entrada); 17 | } 18 | 19 | pares.stream().sorted().forEach(System.out :: println); 20 | impares.stream().sorted(Collections.reverseOrder()).forEach(System.out :: println); 21 | } 22 | } -------------------------------------------------------------------------------- /Ordenação e Filtros em Java/1 - Ordenando Números Pares e Ímpares/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Crie um programa onde você receberá valores inteiros não negativos como entrada. 3 | 4 | Ordene estes valores de acordo com o seguinte critério: 5 | - Primeiro os Pares 6 | - Depois os Ímpares 7 | 8 | Você deve exibir os pares em ordem crescente e na sequência os ímpares em ordem decrescente 9 | 10 | # Entrada 11 | A primeira linha de entrada contém um único inteiro positivo N (1 < N < 10000) Este é o número de linhas de entrada que vem logo a seguir. As próximas N linhas terão, cada uma delas, um valor inteiro não negativo. 12 | 13 | # Saída 14 | Exiba todos os valores lidos na entrada segundo a ordem apresentada acima. Cada número deve ser impresso em uma linha, conforme exemplo de saída abaixo. 15 | 16 | | Exemplo de Entrada | Exemplo de Saída| 17 | | ---|--- | 18 | |10
4
32
34
543
3456
654
567
87
6789
98|4
32
34
98
654
3456
6789
567
543
87| -------------------------------------------------------------------------------- /Ordenação e Filtros em Java/2 - Compras no Supermercado/ComprasSupermercado.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | import java.util.List; 3 | import java.util.Scanner; 4 | import java.util.stream.Collectors; 5 | 6 | public class ComprasSupermercado { 7 | public static void main(String[] args) { 8 | Scanner sc = new Scanner(System.in); 9 | int quantidadeListas = sc.nextInt(); 10 | 11 | while (sc.hasNextLine()) { 12 | String linha = sc.nextLine(); 13 | List lista = Arrays.asList(linha.split(" ")); 14 | System.out.println(lista.stream().distinct().sorted().collect(Collectors.joining(" "))); 15 | } 16 | } 17 | } -------------------------------------------------------------------------------- /Ordenação e Filtros em Java/2 - Compras no Supermercado/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Pedro trabalha sempre até tarde todos os dias, com isso tem pouco tempo tempo para as tarefas domésticas. Para economizar tempo ele faz a lista de compras do supermercado em um aplicativo e costuma anotar cada item na mesma hora que percebe a falta dele em casa. 3 | 4 | O problema é que o aplicativo não exclui itens duplicados, como Pedro anota o mesmo item mais de uma vez e a lista acaba ficando extensa. Sua tarefa é melhorar o aplicativo de notas desenvolvendo um código que exclua os itens duplicados da lista de compras e que os ordene alfabeticamente. 5 | 6 | # Entrada 7 | A primeira linha de entrada contém um inteiro N (N < 100) com a quantidade de casos de teste que vem a seguir, ou melhor, a quantidade de listas de compras para organizar. Cada lista de compra consiste de uma única linha que contém de 1 a 1000 itens ou palavras compostas apenas de letras minúsculas (de 1 a 20 letras), sem acentos e separadas por um espaço. 8 | 9 | # Saída 10 | A saída contém N linhas, cada uma representando uma lista de compra, sem os itens repetidos e em ordem alfabética. 11 | 12 | | Exemplo de Entrada | Exemplo de Saída| 13 | | ---|--- | 14 | |2
carne laranja suco picles laranja picles
laranja pera laranja pera pera|carne laranja picles suco
laranja pera| -------------------------------------------------------------------------------- /Ordenação e Filtros em Java/3 - Uniformes de final de ano/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | O professor Girafales organizou a confecção de um uniforme para as turmas da escola para comemorar o final do ano. Após algumas conversas, ficou decidido com os alunos que eles poderiam escolher a cor do uniforme entre branco ou vermelho. Assim sendo, Girafales precisa de sua ajuda para organizar as listas de quem quer o uniforme em cada uma das turmas, relacionando estas camisetas pela cor, tamanho (P, M ou G) e por último pelo nome. 3 | 4 | # Entrada 5 | Cada caso de teste inicia com um valor N, (1 ≤ N ≤ 60) inteiro e positivo, que indica a quantidade de uniformes a serem feitas para aquela turma. As próximas N*2 linhas contém informações de cada um dos uniformes (serão duas linhas de informação para cada uniforme). A primeira linha irá conter o nome do estudante e a segunda linha irá conter a cor do uniforme ("branco" ou "vermelho") seguido por um espaço e pelo tamanho do uniforme "P" "M" ou "G". A entrada termina quando o valor de N for igual a zero (0) e esta valor não deverá ser processado. 6 | 7 | # Saída 8 | Para cada caso de entrada deverão ser impressas as informações ordenadas pela cor em ordem ascendente, seguido pelos tamanhos em ordem descendente e por último por ordem ascendente de nome, conforme o exemplo abaixo. 9 | 10 | | Exemplo de Entrada | Exemplo de Saída| 11 | | ---|--- | 12 | |9
Maria Jose
branco P
Mangojata Mancuda
vermelho P
Cezar Torres Mo
branco P
Baka Lhau
vermelho P
JuJu Mentina
branco M
Amaro Dinha
vermelho P
Adabi
Finho
branco G
Severina Rigudinha
branco G
Carlos Chade Losna
vermelho P
0|branco P Cezar Torres Mo
branco P Maria Jose
branco M JuJu Mentina
branco G Adabi Finho
branco G Severina Rigudinha
vermelho P Amaro Dinha
vermelho P Baka Lhau
vermelho P Carlos Chade Losna
vermelho P Mangojata Mancuda -------------------------------------------------------------------------------- /Ordenação e Filtros em Java/3 - Uniformes de final de ano/UniformesFinalAno.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Comparator; 3 | import java.util.List; 4 | import java.util.Scanner; 5 | 6 | public class UniformesFinalAno { 7 | public static void main(String[] args) { 8 | Scanner sc = new Scanner(System.in); 9 | int quantidadeListas = sc.nextInt(); 10 | sc.nextLine(); 11 | List uniformes = new ArrayList<>(); 12 | 13 | for(int i=0; i < quantidadeListas; i++) { 14 | String nomeAluno = sc.nextLine(); 15 | String[] corTamanho = sc.nextLine().split(" "); 16 | String cor = corTamanho[0]; 17 | String tamanho = corTamanho[1]; 18 | uniformes.add(new Uniforme(cor, tamanho, nomeAluno)); 19 | } 20 | 21 | Comparator compararUniformes = Comparator 22 | .comparing(Uniforme::getCor) 23 | .thenComparing(Uniforme::getTamanho, Comparator.reverseOrder()) 24 | .thenComparing(Uniforme::getNomeAluno); 25 | 26 | uniformes.stream().sorted(compararUniformes).forEach(System.out::println); 27 | } 28 | 29 | static class Uniforme { 30 | private String cor; 31 | private String tamanho; 32 | private String nomeAluno; 33 | 34 | public Uniforme(String cor, String tamanho, String nomeAluno) { 35 | this.cor = cor; 36 | this.tamanho = tamanho; 37 | this.nomeAluno = nomeAluno; 38 | } 39 | 40 | public String getCor() { 41 | return this.cor; 42 | } 43 | 44 | public String getTamanho() { 45 | return this.tamanho; 46 | } 47 | 48 | public String getNomeAluno() { 49 | return this.nomeAluno; 50 | } 51 | 52 | @Override 53 | public String toString() { 54 | return getCor() + " " + getTamanho() + " " + getNomeAluno(); 55 | } 56 | } 57 | } -------------------------------------------------------------------------------- /Ordenação e Filtros em Java/4 - Fila do banco/FilaBanco.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Arrays; 3 | import java.util.Collections; 4 | import java.util.List; 5 | import java.util.Scanner; 6 | import java.util.stream.Collectors; 7 | 8 | public class FilaBanco { 9 | public static void main(String[] args) { 10 | Scanner sc = new Scanner(System.in); 11 | int quantidadeEntradas = sc.nextInt(); 12 | 13 | for(int i=0; i < quantidadeEntradas; i++) { 14 | int quantidadePessoas = sc.nextInt(); 15 | sc.nextLine(); 16 | String[] filaString = sc.nextLine().split(" "); 17 | List fila = Arrays.asList(filaString).stream().map(Integer::valueOf).collect(Collectors.toList()); 18 | List filaOrdenada = new ArrayList<>(fila); 19 | Collections.sort(filaOrdenada, Collections.reverseOrder()); 20 | 21 | int pessoasMesmaOrdem = 0; 22 | for(int j=0; j < quantidadePessoas; j++) { 23 | if(fila.get(j) == filaOrdenada.get(j)) 24 | pessoasMesmaOrdem++; 25 | } 26 | 27 | System.out.println(pessoasMesmaOrdem); 28 | } 29 | 30 | } 31 | } -------------------------------------------------------------------------------- /Ordenação e Filtros em Java/4 - Fila do banco/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | O banco que você trabalha sempre tem problemas para organizar as filas de atendimento dos clientes. 3 | 4 | Após uma reunião com a gerência ficou decidido que os clientes ao chegar na agência receberão uma senha numérica em seu aparelho de celular via sms e que a ordem da fila será dada não pela ordem de chegada, mas sim pelo número recebido via sms. A ordem de atendimento será decrescente: aqueles que receberam número maior deverão ser atendidos primeiro. 5 | 6 | Então, dada a ordem de chegada dos clientes reordene a fila de acordo com o número recebido via sms, e diga quantos clientes não precisaram trocar de lugar nessa reordenação. 7 | 8 | # Entrada 9 | A primeira linha contém um inteiro N, indicando o número de casos de teste a seguir. 10 | 11 | Cada caso de teste inicia com um inteiro M (1 ≤ M ≤ 1000), indicando o número de clientes. Em seguida haverá M inteiros distintos Pi (1 ≤ Pi ≤ 1000), onde o i-ésimo inteiro indica o número recebido via sms do i-ésimo cliente. 12 | 13 | Os inteiros acima são dados em ordem de chegada, ou seja, o primeiro inteiro diz respeito ao primeiro cliente a chegar na fila, o segundo inteiro diz respeito ao segundo cliente, e assim sucessivamente. 14 | 15 | # Saída 16 | Para cada caso de teste imprima uma linha, contendo um inteiro, indicando o número de clientes que não precisaram trocar de lugar mesmo após a fila ser reordenada. 17 | 18 | | Exemplo de Entrada | Exemplo de Saída| 19 | | ---|--- | 20 | |3
3
100 80 90
4
100 120 30 50
4
100 90 30 25|1
0
4| -------------------------------------------------------------------------------- /Ordenação e Filtros em Java/5 - Gincana no Acampamento/GincanaAcampamento.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.List; 3 | import java.util.Scanner; 4 | 5 | public class GincanaAcampamento { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | 9 | int quantidadeEntradas = 0; 10 | 11 | while( (quantidadeEntradas = sc.nextInt()) !=0) { 12 | sc.nextLine(); 13 | List participantes = new ArrayList<>(); 14 | for(int i=0; i < quantidadeEntradas; i++) { 15 | String[] nomeFicha = sc.nextLine().split(" "); 16 | participantes.add(new Participante(nomeFicha[0], Integer.parseInt(nomeFicha[1]))); 17 | } 18 | 19 | int index=0; 20 | int valorFicha = participantes.get(index).ficha; 21 | while(participantes.size() != 1) { 22 | index = valorFicha % 2 == 0 ? Math.floorMod(index - valorFicha, participantes.size()) : 23 | Math.floorMod(valorFicha + index, participantes.size()); 24 | valorFicha = participantes.get(index).ficha; 25 | participantes.remove(index); 26 | index = valorFicha % 2 == 0 ? index : Math.floorMod(index - 1, participantes.size()); 27 | } 28 | 29 | System.out.println("Vencedor(a): " + participantes.get(0).nome); 30 | } 31 | } 32 | 33 | static class Participante { 34 | public Participante(String nome, int ficha) { 35 | this.nome = nome; 36 | this.ficha = ficha; 37 | } 38 | 39 | public String nome; 40 | public int ficha; 41 | } 42 | } -------------------------------------------------------------------------------- /Ordenação e Filtros em Java/5 - Gincana no Acampamento/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Crie um programa onde você receberá valores inteiros não negativos como entrada. 3 | 4 | Ordene estes valores de acordo com o seguinte critério: 5 | - Primeiro os Pares 6 | - Depois os Ímpares 7 | Você deve exibir os pares em ordem crescente e na sequência os ímpares em ordem decrescente 8 | 9 | # Entrada 10 | A primeira linha de entrada contém um único inteiro positivo N (1 < N < 10000) Este é o número de linhas de entrada que vem logo a seguir. As próximas N linhas terão, cada uma delas, um valor inteiro não negativo. 11 | 12 | # Saída 13 | Exiba todos os valores lidos na entrada segundo a ordem apresentada acima. Cada número deve ser impresso em uma linha, conforme exemplo de saída abaixo. 14 | 15 | | Exemplo de Entrada | Exemplo de Saída| 16 | | ---|--- | 17 | |10
4
32
34
543
3456
654
567
87
6789
98|4
32
34
98
654
3456
6789
567
543
87| -------------------------------------------------------------------------------- /Praticando programação em Java/1 - Abreviando posts do Blog/AbreviandoBlogPost.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.InputStreamReader; 3 | import java.io.IOException; 4 | import java.util.StringTokenizer; 5 | import java.util.Map; 6 | import java.util.HashMap; 7 | import java.util.TreeMap; 8 | import java.util.List; 9 | import java.util.ArrayList; 10 | 11 | public class AbreviandoBlogPosts { 12 | 13 | protected static Map ocorrenciasPalavra; 14 | protected static Map abreviacoes; 15 | 16 | public static void main(String[] args) throws IOException { 17 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 18 | String line; 19 | 20 | while (!".".equals((line = br.readLine()))) { 21 | StringTokenizer st = new StringTokenizer(line); 22 | ocorrenciasPalavra = new HashMap<>(); 23 | abreviacoes = new TreeMap<>(); 24 | while (st.hasMoreTokens()) { 25 | String proximaPalavra = st.nextToken(); 26 | if (proximaPalavra.length() <= 2) continue; 27 | ocorrenciasPalavra.put(proximaPalavra, ocorrenciasPalavra.containsKey(proximaPalavra) ? ocorrenciasPalavra.get(proximaPalavra) + 1 : 1); 28 | abreviacoes.put(proximaPalavra.charAt(0), melhorPalavraAbreviada(proximaPalavra)); 29 | } 30 | imprimirSaida(line); 31 | } 32 | } 33 | 34 | private static String melhorPalavraAbreviada(String proximaPalavra) { 35 | if (!abreviacoes.containsKey(proximaPalavra.charAt(0))) { 36 | return proximaPalavra; 37 | } 38 | int novaReducaoCaracteres = ocorrenciasPalavra.get(proximaPalavra) * (proximaPalavra.length() - 2); 39 | String abreviadaAtual = abreviacoes.get(proximaPalavra.charAt(0)); 40 | int reducaoAtualCaracteres = ocorrenciasPalavra.get(abreviadaAtual) * (abreviadaAtual.length() - 2); 41 | return novaReducaoCaracteres > reducaoAtualCaracteres ? proximaPalavra : abreviadaAtual; 42 | } 43 | 44 | private static void imprimirSaida(String line) { 45 | List listaAbreviacoes = new ArrayList<>(); 46 | for (Character c : abreviacoes.keySet()) { 47 | String palavraAbreviada = abreviacoes.get(c); 48 | line = line.replaceAll("\\b" + palavraAbreviada + "\\b", " " + c + ". "); 49 | listaAbreviacoes.add(c + ". = " + palavraAbreviada); 50 | } 51 | 52 | System.out.println(line.trim()); 53 | System.out.println(listaAbreviacoes.size()); 54 | listaAbreviacoes.forEach(System.out::println); 55 | } 56 | } -------------------------------------------------------------------------------- /Praticando programação em Java/1 - Abreviando posts do Blog/Explicações e Dicas.md: -------------------------------------------------------------------------------- 1 | ## Explicações 2 | Utilizemos o exemplo dado pelo desafio: “hoje eu programei em python”. Python está em minúsculo porque as entradas são todas minúsculas. A saída esperada neste caso seria "h. eu p. em python": a palavra "hoje" pode ser reduzida para "h.", e a palavra "eu" e a palavra "em" não são reduzidas para "e." porque manteria o mesmo número de caracteres da palavra. Entre as palavras "programei" e "python", se abreviarmos "programei" por "p." estaremos reduzindo 7 caracteres, e se abreviarmos "python" por "p." estaremos reduzindo 4 caracteres. Logo, escolhemos a palavra que gera a maior redução, que é "programei" 3 | 4 | Mantendo neste exemplo, qual seria o resultado esperado se a entrada fosse "hoje eu programei em python python"? Repare que neste caso, se abreviarmos "python" para "p.", estaremos reduzindo o texto em 8 caracteres (4 caracteres * 2 palavras), o que é uma redução maior do que abreviar "programei" para "p.". Assim, o resultado seria "h. eu programei em p. p.", com "p." abreviando "python". 5 | 6 | Assim, as regras seriam: 7 | 1. Se uma palavra tem 2 caracteres ou menos, não faz sentido abreviá-la, porque não reduziria a quantidade de caracteres. 8 | 1. Se há mais de uma palavra que inicia pela mesma letra, você deve escolher não necessariamente a maior, mas a que reduzirá o maior número de caracteres. Ou seja, deve levar em conta quantas vezes cada palavra se repete para saber qual reduz mais a quantidade de caracteres. 9 | 10 | Um caso especial que deve ser levado em conta é quando a palavra abreviada escolhida é uma substring de outra palavra do texto. Neste caso, deve-se tomar o cuidado de substituir somente a palavra toda, e não um pedaço dela. Observe o último exemplo dos casos de teste abaixo. Caso seu código não tenha levado isto em consideração, sua saída provavelmente será 'a. a. a a.a'. 11 | 12 | ## Mais casos de teste 13 | Para verificar se o seu código está funcionando, tente os casos abaixo: 14 | 15 | | Exemplo de Entrada | Exemplo de Saída| 16 | | ---|--- | 17 | |abcd abc abc abc|abcd a. a. a.
1
a. = abc| 18 | |abcd abcd abc abc abc|a. a. abc abc abc
1
a. = abcd | 19 | |dwh t cohor dkvwcsg sqoqms b a|dwh t c. d. s. b a
3
c. = cohor
d. = dkvwcsg
s. = sqoqms | 20 | |aaaa aaaa a aaaaa|a. a. a aaaaa
1
a. = aaaa| 21 | 22 | ## Dicas 23 |
24 | Dica 1 25 | Como você pode separar as palavras de uma lista de palavras? 26 |
27 |
28 | Dica 2 29 | Você pode utilizar o método split(separador), que separa uma String em um array de Strings de acordo com o separador. No caso, o separador é espaço em branco (" "). 30 |
31 |
32 | Dica 3 33 | Como você pode guardar o número de vezes em que cada palavra ocorre? 34 |
35 |
36 | Dica 4 37 | Um jeito de guardar o número de ocorrências de cada palavra é usar um Map, com chave igual a palavra, e valor igual ao número de ocorrências dela. 38 |
39 |
40 | Dica 5 41 | Sabendo o número de ocorrências de cada palavra, como você determina, para cada letra, qual é a palavra que gera a maior redução de caracteres quando abreviada? 42 |
43 |
44 | Dica 6 45 | Você pode criar outro mapa, com chave igual ao caracter, e valor igual à palavra que mais reduz a quantidade de caracteres. A fórmula para saber quantos caracteres uma palavra reduz é (tamanhoPalavra-2)*numeroOcorrencias. Você pode usar um array ao invés de um mapa também, em que a posição 0 representa 'a', a posição '1' representa 'b' e assim por diante. 46 |
47 |
48 | Dica 7 49 | Como você imprime as abreviações em ordem alfabética? 50 |
51 |
52 | Dica 8 53 | Se você usar um array, basta imprimir pela ordem das posições. Se usar um Map, uma sugestão é utilizar TreeMap, que consegue retornar as chaves ordenadas. 54 |
55 |
56 | Dica 9 57 | Para substituir apenas a palavra inteira ao invés de um pedaço dela, é possível utilizar o regex '\b': https://www.regular-expressions.info/wordboundaries.html. Lembre-se de utilizar "\\b" caso decida por esta abordagem. 58 |
59 | -------------------------------------------------------------------------------- /Praticando programação em Java/1 - Abreviando posts do Blog/README.md: -------------------------------------------------------------------------------- 1 |

Desafio

2 | Leonardo é um nômade digital e viaja pelo mundo programando em diferentes cafés das cidades por onde passa. Recentemente, resolveu criar um blog, para compartilhar suas experiências e aprendizados com seus amigos. 3 | 4 | Para criação do blog, ele optou por utilizar uma ferramenta pronta, que há um limite de caracteres que se pode escrever por dia, e Leonardo está preocupado que essa limitação, afinal, irá impedir de contar suas melhores experiências. Para contornar esse problema, decidiu usar um sistema de abreviação de palavras em seus posts. 5 | 6 | O sistema de abreviações é simples e funciona da seguinte forma: para cada letra, é possível escolher uma palavra que inicia com tal letra e que aparece no post. Uma vez escolhida a palavra, sempre que ela aparecer no post, ela será substituída por sua letra inicial e um ponto, diminuindo assim o número de caracteres impressos na tela. 7 | 8 | Por exemplo, na frase: “hoje eu programei em Python”, podemos escolher a palavra “programei” para representar a letra ‘p', e a frase ficará assim: “hoje eu p. em Python”, economizando assim sete caracteres. Uma mesma palavra pode aparecer mais de uma vez no texto, e será abreviada todas as vezes. Note que, se após uma abreviação o número de caracteres não diminuir, ela não deve ser usada, tal como no caso da palavra “eu” acima. 9 | 10 | Leonardo precisa que seu post tenha o menor número de caracteres possíveis, e por isso pediu a sua ajuda. Para cada letra, escolha uma palavra, de modo que ao serem aplicadas todas as abreviações, o texto contenha o menor número de caracteres possíveis. 11 | 12 |

Entrada

13 | Haverá diversos casos de teste. Cada caso de teste é composto de uma linha, contendo uma frase de até 10⁴ caracteres. A frase é composta de palavras e espaços em branco, e cada palavra é composta de letras minúsculas ('a'-'z'), e contém entre 1 e 30 caracteres cada. 14 | 15 | O último caso de teste é indicado quando a linha dada conter apenas um “.”, o qual não deverá ser processado. 16 | 17 |

Saída

18 | Para cada caso de teste, imprima uma linha contendo a frase já com as abreviações escolhidas e aplicadas. 19 | 20 | Em seguida, imprima um inteiro N, indicando o número de palavras em que foram escolhidas uma letra para a abreviação no texto. Nas próximas N linhas, imprima o seguinte padrão “C. = P”, onde C é a letra inicial e P é a palavra escolhida para tal letra. As linhas devem ser impressas em ordem crescente da letra inicial. 21 | 22 | | Exemplo de Entrada | Exemplo de Saída| 23 | | ---|--- | 24 | |abcdef abc abc abc
. | a. abc abc abc
1
a. = abcdef| 25 | 26 | -------------------------------------------------------------------------------- /Praticando programação em Java/2 - Conjuntos Bons ou Ruins/ConjuntoBomRuim.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.InputStreamReader; 3 | import java.io.IOException; 4 | import java.util.List; 5 | import java.util.ArrayList; 6 | import java.util.stream.Collectors; 7 | 8 | public class ConjuntoBomRuim { 9 | public static void main(String[] args) throws IOException { 10 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 11 | int N = Integer.valueOf(br.readLine()); 12 | 13 | while (N != 0) { 14 | List conjunto = new ArrayList<>(); 15 | for (int i = 0; i < N; i++) 16 | conjunto.add(br.readLine()); 17 | 18 | conjunto = conjunto.stream().sorted().collect(Collectors.toList()); 19 | 20 | String saida = "Conjunto Bom"; 21 | for (int i = 0; i < N - 1; i++) { 22 | if (conjunto.get(i + 1).startsWith(conjunto.get(i))) { 23 | saida = "Conjunto Ruim"; 24 | break; 25 | } 26 | } 27 | 28 | System.out.println(saida); 29 | N = Integer.valueOf(br.readLine()); 30 | } 31 | } 32 | } -------------------------------------------------------------------------------- /Praticando programação em Java/2 - Conjuntos Bons ou Ruins/Explicações e Dicas.md: -------------------------------------------------------------------------------- 1 | ## Explicações 2 | Exemplos de palavras que são prefixos de outras: 3 | - 'dbc' é prefixo de 'dbcde' 4 | - 'bate' é prefixo de 'batedeira' 5 | - 'giro' é prefixo de 'giroscópio' 6 | 7 | Neste desafio então, se você tiver em um conjunto 'giro' e 'giroscópio' e mais 1000 palavras, ele será um conjunto ruim de qualquer forma porque 'giro' é prefixo de 'giroscópio'. Ou seja, basta achar um caso desses para ser um conjunto ruim 8 | 9 | ## Dicas 10 |
11 | Dica 1 12 | Uma forma de fazer é, para cada palavra, verificar se ela faz parte do início de alguma das outras palavras. 13 |
14 |
15 | Dica 2 16 | Existe algum método que você consiga verificar a condição da dica anterior sem ter que comparar caracter por caracter? 17 |
18 |
19 | Dica 3 20 | Cuidado para não confundir prefixo com estar contido. Ou seja, cuidado para não usar contains() ao invés de startsWith(). 21 |
22 |
23 | Dica 4 24 | O que acontece se você ordenar as palavras? 25 |
26 |
27 | Dica 5 28 | Ao ordenar as palavras em ordem alfabética, é possível que uma palavra que venha depois na lista seja prefixo de uma anterior? Como você pode verificar então se uma palavra é prefixo da outra em uma lista ordenada? 29 |
30 | -------------------------------------------------------------------------------- /Praticando programação em Java/2 - Conjuntos Bons ou Ruins/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Nesse algoritmo você deverá descobrir se um conjunto de palavras é bom ou ruim. Por definição, um conjunto é bom quando nenhuma palavra desse conjunto é um prefixo de outra palavra. Caso contrário, é considerado um conjunto ruim. 3 | 4 | Por exemplo, {dbc, dae, dbcde} é um conjunto ruim, pois dbc é um prefixo de dbcde. Quando duas palavras são idênticas, definimos como uma sendo prefixo da outra. 5 | 6 | # Entrada 7 | A entrada contém vários casos de teste. A primeira linha de cada caso de teste terá um inteiro N (1 ≤ N ≤ 10⁵), que representa a quantidade de palavras no conjunto. Segue então N linhas, cada uma tendo uma palavra de no máximo 100 letras minúsculas. A entrada termina quando N = 0 e não deve ser processada. 8 | 9 | # Saída 10 | Para cada caso de teste, você deverá imprimir "Conjunto Bom", ou "Conjunto Ruim", conforme explicado acima. 11 | 12 | | Exemplo de Entrada | Exemplo de Saída| 13 | | ---|--- | 14 | | 3
abc
dae
abcde
2
abc
def
0| Conjunto Bom
Conjunto Ruim | 15 | 16 | -------------------------------------------------------------------------------- /Praticando programação em Java/3 - Encontre a maior substring/MaiorSubstring.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.IOException; 3 | import java.io.InputStreamReader; 4 | import java.io.PrintWriter; 5 | 6 | public class MaiorSubstring { 7 | 8 | static BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); 9 | static PrintWriter out = new PrintWriter(System.out); 10 | 11 | public static void main(String[] args) throws IOException { 12 | String s1, s2, min, max; 13 | while ((s1 = in.readLine()) != null) { 14 | s2 = in.readLine(); 15 | if ( s1.length() > s2.length() ) { 16 | max = s1; 17 | min = s2; 18 | } else { 19 | max = s2; 20 | min = s1; 21 | } 22 | int minLength = min.length(); 23 | int maxS = minLength; 24 | boolean f = true; 25 | while (maxS > 0 && f) { 26 | int diff = minLength - maxS; 27 | for (int i = 0; i <= diff; i++) { 28 | if (max.contains(min.substring(i, i + maxS))) { 29 | f = false; 30 | maxS++; 31 | break; 32 | } 33 | } 34 | maxS--; 35 | } 36 | System.out.println(maxS); 37 | } 38 | out.close(); 39 | } 40 | 41 | } -------------------------------------------------------------------------------- /Praticando programação em Java/3 - Encontre a maior substring/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Encontre a maior substring comum entre as duas strings informadas. A substring pode ser qualquer parte da string, inclusive ela toda. Se não houver subseqüência comum, a saída deve ser “0”. A comparação é case sensitive ('x' != 'X'). 3 | 4 | # Entrada 5 | A entrada contém vários casos de teste. Cada caso de teste é composto por duas linhas, cada uma contendo uma string. Ambas strings de entrada contém entre 1 e 50 caracteres ('A'-'Z','a'-'z' ou espaço ' '), inclusive, ou no mínimo uma letra ('A'-'Z','a'-'z'). 6 | 7 | # Saída 8 | O tamanho da maior subsequência comum entre as duas Strings. 9 | 10 | | Exemplo de Entrada | Exemplo de Saída| 11 | | ---|--- | 12 | | abcdef
cdofhij|2| 13 | |TWO
FOUR|1| 14 | |abracadabra
open|5| 15 | |Hey This java is hot
Java is a new paradigm|7 | 16 | 17 | -------------------------------------------------------------------------------- /Praticando programação em Java/4 - Entrevista Embaraçosa/EntrevistaEmbaracosa.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.InputStreamReader; 3 | import java.io.IOException; 4 | import java.util.StringTokenizer; 5 | 6 | public class EntrevistaEmbaracosa { 7 | public static void main(String[] args) throws IOException { 8 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 9 | String proximaPalavra; 10 | 11 | while((proximaPalavra = br.readLine()) != null) { 12 | boolean encontrouRepeticao = false; 13 | for(int i=0; i <= proximaPalavra.length() - 1; i++) { 14 | if( proximaPalavra.substring(0, i).endsWith(proximaPalavra.substring(i)) ) { 15 | System.out.println(proximaPalavra.substring(0, i)); 16 | encontrouRepeticao = true; 17 | } 18 | } 19 | if(!encontrouRepeticao) 20 | System.out.println(proximaPalavra); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Praticando programação em Java/4 - Entrevista Embaraçosa/Explicações e Dicas.md: -------------------------------------------------------------------------------- 1 | ## Explicações 2 | O enunciado desta questão não está tão bem escrito. A regra geral é a seguinte: dada uma palavra, divida-a em uma duas, digamos parteInicial e parteFinal. Se a parteInicial terminar com a parteFinal, imprima a parteInicial. Se não houver uma forma de dividir a palavra para atender esta regra, imprima a própria palavra. 3 | Alguns exemplos para ficar mais claro: 4 | - sanduicheiche -> parteInicial = 'sanduiche', parteFinal = 'iche'. Como 'sanduiche' termina em 'iche', imprimimos a parteInicial, que é 'sanduiche'. 5 | - barrilarril -> parteInicial = 'barril', parteFinal = 'arril'. Como 'barril' termina em 'arril', imprimimos a parteInicial, que é 'barril'. 6 | - sol -> Não há como dividir 'sol' de tal forma que a parteInicial termine com a parteFinal. Imprimimos 'sol'. 7 | 8 | É importante ressaltar que uma palavra pode ser dividida de mais de uma forma, e cada uma delas deve ser impressa. Exemplos: 9 | - testetetete 10 | 1. parteInicial = 'testete', parteFinal = 'tete'. Como 'testete' termina em 'tete', imprimimos 'testete' 11 | 1. parteInicial = 'testetete', parteFinal = 'te'. Como 'testetete' termina em 'te', imprimimos 'testetete' 12 | - aaaaa 13 | 1. parteInicial = 'aaa', parteFinal = 'aa'. Como 'aaa' termina em 'aa', imprimimos 'aaa' 14 | 1. parteInicial = 'aaaa', parteFinal = 'a'. Como 'aaaa' termina em 'a', imprimimos 'aaaa' 15 | 16 | Nestes casos em que uma palavra gera mais de uma saída, deve-se imprimir em ordem crescente de tamanho. Nos exemplos acima, 'aaa' vem antes de 'aaaa' e 'testete' vem antes de 'testetete'. 17 | 18 | ## Mais casos de teste 19 | Para verificar se o seu código está funcionando, tente os casos abaixo, além dos exemplos passados no enunciado: 20 | 21 | | Exemplo de Entrada | Exemplo de Saída| 22 | | ---|--- | 23 | |aaaaaaaaaa|aaaaa
aaaaaa
aaaaaaa
aaaaaaaa
aaaaaaaaa| 24 | |testetetete|testete
testetete| 25 | |testandoando|testando| 26 | |agorasimassim|agorasimassim| 27 | |agorassimassim|agorassim| 28 | |abcdefghijklmnopqrstuvwxyzwxyz|abcdefghijklmnopqrstuvwxyz| 29 | |a|a| 30 | |bb|b| 31 | |bbb|bb| 32 | |bab|bab| 33 | |baba|ba| 34 | 35 | ## Dicas 36 |
37 | Dica 1 38 | Como você pode garantir que todas as formas de dividir a palavra em duas serão testadas? 39 |
40 |
41 | Dica 2 42 | Ao invés de checar caractere a caractere para verificar se uma palavra termina com outra, tente utilizar o método endsWith 43 |
44 |
45 | Dica 3 46 | Lembre de garantir que todas as saídas de uma palavra sejam impressas, e de que elas estejam em ordem crescente de tamanho. Isso significa que você não deve utilizar um break e deve percorrer a palavra do início ao fim, e não do fim ao início. 47 |
48 |
49 | Dica 4 50 | Lembre de imprimir a própria palavra caso não encontre uma forma de dividir. 51 |
52 | -------------------------------------------------------------------------------- /Praticando programação em Java/4 - Entrevista Embaraçosa/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | A nutricionista Juliana Alcantra é uma excelente profissional de sua área. Em determinado dia, ela foi entrevistada ao vivo para um jornal da cidade. No entanto, ficou um pouco nervosa na hora, e diante da situação, sua fala ficou um pouco distorcida, repetindo o final de cada palavra após dizer a mesma. Para que isso não aconteça novamente, ela precisa da sua ajuda para escrever um programa que omita a parte repetida, de modo que as palavras sejam pronunciadas como deveriam ser. 3 | 4 | Escreva um programa que, dada uma palavra errada, a mesma seja corrigida. 5 | 6 | # Entrada 7 | Haverá diversos casos de teste. Cada caso de teste é formado por uma palavra, de, no máximo, 30 caracteres, dita da forma errada. A entrada termina com fim de arquivo. 8 | 9 | # Saída 10 | Para cada caso de teste, escreva a palavra devidamente corrigida. Analise os exemplos para verificar o padrão, de modo a consertar todos os casos. 11 | 12 | | Exemplo de Entrada | Exemplo de Saída| 13 | | ---|--- | 14 | |sanduicheiche| sanduiche| 15 | |barrilarril|barril| 16 | |ratoato|rato| 17 | |sol|sol| 18 | |coliseueu|coliseu| 19 | |queijoijo|queijo| 20 | |astroastro|astro| 21 | |a |a| 22 | 23 | -------------------------------------------------------------------------------- /Praticando programação em Java/5 - Validador Senhas/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Pedro e Fernando são os desenvolvedores em uma stratup e vão desenvolver o novo sistema de cadastro, e pediram a sua ajuda. Sua task é fazer o código que valide as senhas que são cadastradas, para isso você deve atentar aos requisitos a seguir: 3 | 4 | - A senha deve conter, no mínimo, uma letra maiúscula, uma letra minúscula e um número; 5 | - A mesma não pode ter nenhum caractere de pontuação, acentuação ou espaço; 6 | - Além disso, a senha pode ter de 6 a 32 caracteres. 7 | 8 | # Entrada 9 | A saída contém uma linha, que pode ser “Senha valida.”, caso a senha tenha cada item dos requisitos solicitados anteriormente, ou “Senha invalida.”, se um ou mais requisitos não forem atendidos. 10 | 11 | # Saída 12 | Para cada caso de teste, escreva a palavra devidamente corrigida. Analise os exemplos para verificar o padrão, de modo a consertar todos os casos. 13 | 14 | | Exemplo de Entrada | Exemplo de Saída| 15 | | ---|--- | 16 | |Digital Innovation One| Senha invalida.| 17 | |AbcdEfgh99| Senha valida.| 18 | |DigitalInnovationOne123| Senha valida.| 19 | |Digital Innovation One 123 | Senha invalida.| 20 | |Aass9| Senha invalida.| 21 | |Aassd9| Senha valida.| 22 | 23 | -------------------------------------------------------------------------------- /Praticando programação em Java/5 - Validador Senhas/ValidadorSenhas.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.InputStreamReader; 3 | import java.io.IOException; 4 | import java.util.Arrays; 5 | 6 | public class ValidadorSenhas { 7 | 8 | public static void main(String[] args) throws IOException { 9 | 10 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 11 | String password; 12 | 13 | while ((password = br.readLine()) != null) { 14 | boolean isCorrectLength = password.length() >= 6 && password.length() <= 32; 15 | boolean containsPontuation = !password.matches("^(?=.*[a-zA-Z])(?=.*[0-9])[A-Za-z0-9]+$"); 16 | boolean containsNumber = false; 17 | boolean containsUpperCase = false; 18 | boolean containsLowerCase = false; 19 | 20 | for (int i = 0; i < password.length(); i++) { 21 | if (Character.isDigit(password.charAt(i))) { 22 | containsNumber = true; 23 | } else if (Character.isUpperCase(password.charAt(i))) { 24 | containsUpperCase = true; 25 | } else if (Character.isLowerCase(password.charAt(i))) { 26 | containsLowerCase = true; 27 | } 28 | } 29 | 30 | if (isCorrectLength && !containsPontuation && containsNumber && containsUpperCase && containsLowerCase) { 31 | System.out.println("Senha valida."); 32 | } else { 33 | System.out.println("Senha invalida."); 34 | } 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /Resolvendo Algoritmos com Java/1 - Coração das Cartas/CoracaoCartas.java: -------------------------------------------------------------------------------- 1 | import java.util.HashMap; 2 | import java.util.Map; 3 | import java.util.Scanner; 4 | 5 | public class CoracaoCartas { 6 | 7 | static Map resultadosSalvos = new HashMap<>(); 8 | 9 | public static void main(String[] args) { 10 | Scanner sc = new Scanner(System.in); 11 | Integer cartasPorPilha = 0; 12 | 13 | while((cartasPorPilha= Integer.valueOf(sc.nextLine())) != 0) { 14 | 15 | int[][] pilhas = new int[cartasPorPilha][3]; 16 | int topoPilha1 = -1; 17 | int topoPilha2 = -1; 18 | int topoPilha3 = -1; 19 | 20 | for(int i=0; i< cartasPorPilha; i++){ 21 | String[] proximasCartas = sc.nextLine().split(" "); 22 | Integer cartaPilha1 = Integer.valueOf(proximasCartas[0]); 23 | Integer cartaPilha2 = Integer.valueOf(proximasCartas[1]); 24 | Integer cartaPilha3 = Integer.valueOf(proximasCartas[2]); 25 | if(cartaPilha1 % 3 != 0) { 26 | pilhas[++topoPilha1][0] = cartaPilha1; 27 | } 28 | if(cartaPilha2 % 3 != 0) { 29 | pilhas[++topoPilha2][1] = cartaPilha2; 30 | } 31 | if(cartaPilha3 % 3 != 0){ 32 | pilhas[++topoPilha3][2] = cartaPilha3; 33 | } 34 | } 35 | System.out.println(isJogoPossivel(pilhas, topoPilha1, topoPilha2, topoPilha3) ? "1" : "0"); 36 | } 37 | } 38 | 39 | static boolean isJogoPossivel(int[][] pilhas, int topoPilha1, int topoPilha2, int topoPilha3) { 40 | if(topoPilha1 == -1 && topoPilha2 == -1 && topoPilha3 == -1) 41 | return true; 42 | 43 | boolean isPossivel = false; 44 | String chave = "p1:" + String.valueOf(topoPilha1) + "p2:" +String.valueOf(topoPilha2) + "p3:" +String.valueOf(topoPilha3); 45 | 46 | if(topoPilha1 > -1 && topoPilha2 > -1 && (pilhas[topoPilha1][0] + pilhas[topoPilha2][1]) % 3 == 0){ 47 | isPossivel |= isJogoPossivel(pilhas, topoPilha1 - 1, topoPilha2 -1, topoPilha3); 48 | resultadosSalvos.putIfAbsent(chave, isPossivel); 49 | } 50 | 51 | if(!isPossivel && topoPilha1 > -1 && topoPilha3 > -1 && (pilhas[topoPilha1][0] + pilhas[topoPilha3][2]) % 3 == 0) { 52 | isPossivel |= isJogoPossivel(pilhas, topoPilha1 - 1, topoPilha2, topoPilha3 - 1); 53 | resultadosSalvos.putIfAbsent(chave, isPossivel); 54 | } 55 | 56 | if(!isPossivel && topoPilha2 > -1 && topoPilha3 > -1 && (pilhas[topoPilha2][1] + pilhas[topoPilha3][2]) % 3 == 0){ 57 | isPossivel |= isJogoPossivel(pilhas, topoPilha1, topoPilha2 - 1, topoPilha3 - 1); 58 | resultadosSalvos.putIfAbsent(chave, isPossivel); 59 | } 60 | 61 | if(!isPossivel && topoPilha1 > -1 && topoPilha2 > -1 && topoPilha3 > -1 && (pilhas[topoPilha1][0] + pilhas[topoPilha2][1] + pilhas[topoPilha3][2]) % 3 == 0){ 62 | isPossivel |= isJogoPossivel(pilhas, topoPilha1 - 1, topoPilha2 - 1, topoPilha3 - 1); 63 | resultadosSalvos.putIfAbsent(chave, isPossivel); 64 | } 65 | 66 | return isPossivel; 67 | } 68 | } -------------------------------------------------------------------------------- /Resolvendo Algoritmos com Java/1 - Coração das Cartas/README.md: -------------------------------------------------------------------------------- 1 |

Desafio

2 | Marcos decidiu abandonar o bar da faculdade onde jogava truco para dedicar-se ao mundo da programação. Para que isso fosse mais fácil, decidiu criar um novo jogo de cartas. 3 | 4 | O coração das cartas, como Marcos apelidou o jogo, é individual e jogado com três pilhas, inicialmente com o mesmo número de cartas. Cada carta tem um valor numérico inteiro de 0 até 9. O jogador pode, a qualquer momento ver o valor de qualquer carta, mas só pode jogar com as cartas que estão no topo das pilhas. Em cada rodada, o jogador pode remover qualquer combinação de cartas que estejam no topo da pilha (pode escolher 1, 2 ou até 3 cartas) cuja soma dos valores seja múltiplo de 3. O jogo é ganho quando todas as cartas forem removidas das pilhas. Se alguma carta não puder ser removida, perde-se o jogo. 5 | 6 |

Entrada

7 | A entrada é composta por várias instâncias Cada instância é iniciada por um inteiro N (0 ≤ N ≤ 100), que identifica o número de cartas em cada pilha. A entrada termina quando N = 0. Cada uma das N linhas seguintes contém três inteiros A, B e C, que descrevem os valores numéricos das cartas em um nível da pilha (0 ≤ A, B, C ≤ 9). As pilhas são descritas do topo até o fundo. 8 | 9 |

Saída

10 | Para cada instância, imprima uma linha contendo o número 1 se o jogador pode ganhar a instância do jogo ou o número 0 se o jogo for impossível. 11 | 12 | | Exemplo de Entrada | Exemplo de Saída| 13 | | ---|--- | 14 | |2
1 1 1
2 0 4
3
1 0 0
0 1 0
0 0 0
0|1
0| 15 | 16 | -------------------------------------------------------------------------------- /Resolvendo Algoritmos com Java/2- Abreviando posts do Blog/AbreviandoBlogPost.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.InputStreamReader; 3 | import java.io.IOException; 4 | import java.util.StringTokenizer; 5 | import java.util.Map; 6 | import java.util.HashMap; 7 | import java.util.TreeMap; 8 | import java.util.List; 9 | import java.util.ArrayList; 10 | 11 | public class AbreviandoBlogPosts { 12 | 13 | protected static Map ocorrenciasPalavra; 14 | protected static Map abreviacoes; 15 | 16 | public static void main(String[] args) throws IOException { 17 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 18 | String line; 19 | 20 | while (!".".equals((line = br.readLine()))) { 21 | StringTokenizer st = new StringTokenizer(line); 22 | ocorrenciasPalavra = new HashMap<>(); 23 | abreviacoes = new TreeMap<>(); 24 | while (st.hasMoreTokens()) { 25 | String proximaPalavra = st.nextToken(); 26 | if (proximaPalavra.length() <= 2) continue; 27 | ocorrenciasPalavra.put(proximaPalavra, ocorrenciasPalavra.containsKey(proximaPalavra) ? ocorrenciasPalavra.get(proximaPalavra) + 1 : 1); 28 | abreviacoes.put(proximaPalavra.charAt(0), melhorPalavraAbreviada(proximaPalavra)); 29 | } 30 | imprimirSaida(line); 31 | } 32 | } 33 | 34 | private static String melhorPalavraAbreviada(String proximaPalavra) { 35 | if (!abreviacoes.containsKey(proximaPalavra.charAt(0))) { 36 | return proximaPalavra; 37 | } 38 | int novaReducaoCaracteres = ocorrenciasPalavra.get(proximaPalavra) * (proximaPalavra.length() - 2); 39 | String abreviadaAtual = abreviacoes.get(proximaPalavra.charAt(0)); 40 | int reducaoAtualCaracteres = ocorrenciasPalavra.get(abreviadaAtual) * (abreviadaAtual.length() - 2); 41 | return novaReducaoCaracteres > reducaoAtualCaracteres ? proximaPalavra : abreviadaAtual; 42 | } 43 | 44 | private static void imprimirSaida(String line) { 45 | List listaAbreviacoes = new ArrayList<>(); 46 | for (Character c : abreviacoes.keySet()) { 47 | String palavraAbreviada = abreviacoes.get(c); 48 | line = line.replaceAll("\\b" + palavraAbreviada + "\\b", " " + c + ". "); 49 | listaAbreviacoes.add(c + ". = " + palavraAbreviada); 50 | } 51 | 52 | System.out.println(line.trim()); 53 | System.out.println(listaAbreviacoes.size()); 54 | listaAbreviacoes.forEach(System.out::println); 55 | } 56 | } -------------------------------------------------------------------------------- /Resolvendo Algoritmos com Java/2- Abreviando posts do Blog/Explicações e Dicas.md: -------------------------------------------------------------------------------- 1 | ## Explicações 2 | Utilizemos o exemplo dado pelo desafio: “hoje eu programei em python”. Python está em minúsculo porque as entradas são todas minúsculas. A saída esperada neste caso seria "h. eu p. em python": a palavra "hoje" pode ser reduzida para "h.", e a palavra "eu" e a palavra "em" não são reduzidas para "e." porque manteria o mesmo número de caracteres da palavra. Entre as palavras "programei" e "python", se abreviarmos "programei" por "p." estaremos reduzindo 7 caracteres, e se abreviarmos "python" por "p." estaremos reduzindo 4 caracteres. Logo, escolhemos a palavra que gera a maior redução, que é "programei" 3 | 4 | Mantendo neste exemplo, qual seria o resultado esperado se a entrada fosse "hoje eu programei em python python"? Repare que neste caso, se abreviarmos "python" para "p.", estaremos reduzindo o texto em 8 caracteres (4 caracteres * 2 palavras), o que é uma redução maior do que abreviar "programei" para "p.". Assim, o resultado seria "h. eu programei em p. p.", com "p." abreviando "python". 5 | 6 | Assim, as regras seriam: 7 | 1. Se uma palavra tem 2 caracteres ou menos, não faz sentido abreviá-la, porque não reduziria a quantidade de caracteres. 8 | 1. Se há mais de uma palavra que inicia pela mesma letra, você deve escolher não necessariamente a maior, mas a que reduzirá o maior número de caracteres. Ou seja, deve levar em conta quantas vezes cada palavra se repete para saber qual reduz mais a quantidade de caracteres. 9 | 10 | ## Mais casos de teste 11 | Para verificar se o seu código está funcionando, tente os casos abaixo: 12 | 13 | | Exemplo de Entrada | Exemplo de Saída| 14 | | ---|--- | 15 | |abcd abc abc abc|abcd a. a. a.
1
a. = abc| 16 | |abcd abcd abc abc abc|a. a. abc abc abc
1
a. = abcd | 17 | |dwh t cohor dkvwcsg sqoqms b a|dwh t c. d. s. b a
3
c. = cohor
d. = dkvwcsg
s. = sqoqms | 18 | 19 | ## Dicas 20 |
21 | Dica 1 22 | Como você pode separar as palavras de uma lista de palavras? 23 |
24 |
25 | Dica 2 26 | Você pode utilizar o método split(separador), que separa uma String em um array de Strings de acordo com o separador. No caso, o separador é espaço em branco (" "). 27 |
28 |
29 | Dica 3 30 | Como você pode guardar o número de vezes em que cada palavra ocorre? 31 |
32 |
33 | Dica 4 34 | Um jeito de guardar o número de ocorrências de cada palavra é usar um Map, com chave igual a palavra, e valor igual ao número de ocorrências dela. 35 |
36 |
37 | Dica 5 38 | Sabendo o número de ocorrências de cada palavra, como você determina, para cada letra, qual é a palavra que gera a maior redução de caracteres quando abreviada? 39 |
40 |
41 | Dica 6 42 | Você pode criar outro mapa, com chave igual ao caracter, e valor igual à palavra que mais reduz a quantidade de caracteres. A fórmula para saber quantos caracteres uma palavra reduz é (tamanhoPalavra-2)*numeroOcorrencias. Você pode usar um array ao invés de um mapa também, em que a posição 0 representa 'a', a posição '1' representa 'b' e assim por diante. 43 |
44 |
45 | Dica 7 46 | Como você imprime as abreviações em ordem alfabética? 47 |
48 |
49 | Dica 8 50 | Se você usar um array, basta imprimir pela ordem das posições. Se usar um Map, uma sugestão é utilizar TreeMap, que consegue retornar as chaves ordenadas. 51 |
52 | -------------------------------------------------------------------------------- /Resolvendo Algoritmos com Java/2- Abreviando posts do Blog/README.md: -------------------------------------------------------------------------------- 1 |

Desafio

2 | Leonardo é um nômade digital e viaja pelo mundo programando em diferentes cafés das cidades por onde passa. Recentemente, resolveu criar um blog, para compartilhar suas experiências e aprendizados com seus amigos. 3 | 4 | Para criação do blog, ele optou por utilizar uma ferramenta pronta, que há um limite de caracteres que se pode escrever por dia, e Leonardo está preocupado que essa limitação, afinal, irá impedir de contar suas melhores experiências. Para contornar esse problema, decidiu usar um sistema de abreviação de palavras em seus posts. 5 | 6 | O sistema de abreviações é simples e funciona da seguinte forma: para cada letra, é possível escolher uma palavra que inicia com tal letra e que aparece no post. Uma vez escolhida a palavra, sempre que ela aparecer no post, ela será substituída por sua letra inicial e um ponto, diminuindo assim o número de caracteres impressos na tela. 7 | 8 | Por exemplo, na frase: “hoje eu programei em Python”, podemos escolher a palavra “programei” para representar a letra ‘p', e a frase ficará assim: “hoje eu p. em Python”, economizando assim sete caracteres. Uma mesma palavra pode aparecer mais de uma vez no texto, e será abreviada todas as vezes. Note que, se após uma abreviação o número de caracteres não diminuir, ela não deve ser usada, tal como no caso da palavra “eu” acima. 9 | 10 | Leonardo precisa que seu post tenha o menor número de caracteres possíveis, e por isso pediu a sua ajuda. Para cada letra, escolha uma palavra, de modo que ao serem aplicadas todas as abreviações, o texto contenha o menor número de caracteres possíveis. 11 | 12 |

Entrada

13 | Haverá diversos casos de teste. Cada caso de teste é composto de uma linha, contendo uma frase de até 10⁴ caracteres. A frase é composta de palavras e espaços em branco, e cada palavra é composta de letras minúsculas ('a'-'z'), e contém entre 1 e 30 caracteres cada. 14 | 15 | O último caso de teste é indicado quando a linha dada conter apenas um “.”, o qual não deverá ser processado. 16 | 17 |

Saída

18 | Para cada caso de teste, imprima uma linha contendo a frase já com as abreviações escolhidas e aplicadas. 19 | 20 | Em seguida, imprima um inteiro N, indicando o número de palavras em que foram escolhidas uma letra para a abreviação no texto. Nas próximas N linhas, imprima o seguinte padrão “C. = P”, onde C é a letra inicial e P é a palavra escolhida para tal letra. As linhas devem ser impressas em ordem crescente da letra inicial. 21 | 22 | | Exemplo de Entrada | Exemplo de Saída| 23 | | ---|--- | 24 | |abcdef abc abc abc
. | a. abc abc abc
1
a. = abcdef| 25 | 26 | -------------------------------------------------------------------------------- /Resolvendo Algoritmos com Java/3 - Combinação de strings/CombinacaoStrings.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class CombinacaoStrings { 4 | public static void main(String[] args) { 5 | Scanner sc = new Scanner(System.in); 6 | sc.nextLine(); 7 | 8 | while(sc.hasNextLine()) { 9 | String[] entrada = sc.nextLine().split(" "); 10 | String str1 = entrada[0]; 11 | String str2 = entrada[1]; 12 | String sobra = ""; 13 | int shortestLenght = str1.length() < str2.length() ? str1.length() : str2.length(); 14 | if (str1.length() != str2.length()) { 15 | sobra = str1.length() > str2.length() ? str1.substring(str2.length()) : str2.substring(str1.length()); 16 | } 17 | StringBuilder stringBuilder = new StringBuilder(); 18 | for (int i=0; i < shortestLenght*2; i++) { 19 | stringBuilder.append((i%2 == 0) ? str1.charAt(i/2) : str2.charAt(i/2)); 20 | } 21 | System.out.println(stringBuilder.toString() + sobra); 22 | } 23 | } 24 | } -------------------------------------------------------------------------------- /Resolvendo Algoritmos com Java/3 - Combinação de strings/README.md: -------------------------------------------------------------------------------- 1 |

Desafio

2 | Crie um algoritmo que receba dois inputs que sejam strings e combine-as alternando as letras de cada string. 3 | 4 | Deve começar pela primeira letra da primeira string, seguido pela primeira letra da segunda string, em seguida pela segunda letra da primeira string e continuar dessa forma sucessivamente. 5 | 6 | As letras restantes da cadeia mais longa devem ser adicionadas ao fim da string resultante e retornada. 7 | 8 |

Entrada

9 | A entrada contém vários casos de teste. A primeira linha contém um inteiro N que indica a quantidade de casos de teste que vem a seguir. Cada caso de teste é composto por uma linha que contém duas cadeias de caracteres, cada cadeia de caracteres contém entre 1 e 50 caracteres inclusive. 10 | 11 |

Saída

12 | Combine as duas cadeias de caracteres da entrada como mostrado no exemplo abaixo e exiba a cadeia resultante. 13 | 14 | | Exemplo de Entrada | Exemplo de Saída| 15 | | ---|--- | 16 | |2
aA Bb
aa bb|aBAb
ababs| 17 | 18 | -------------------------------------------------------------------------------- /Resolvendo Algoritmos com Java/4 - Hash Mágico/HashMagico.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class HashMagico { 4 | public static void main(String[] args) { 5 | Scanner sc = new Scanner(System.in); 6 | int quantidadeCasos = sc.nextInt(); 7 | 8 | for(int i=0; i < quantidadeCasos; i++) { 9 | int quantidadeLinhas = sc.nextInt(); 10 | sc.nextLine(); 11 | 12 | int hash = 0; 13 | for(int j=0; j < quantidadeLinhas; j++) { 14 | String linha = sc.nextLine(); 15 | for(int k=0; k < linha.length(); k++) { 16 | hash += k + j + linha.charAt(k) - 'A'; 17 | } 18 | } 19 | 20 | System.out.println(hash); 21 | } 22 | } 23 | } -------------------------------------------------------------------------------- /Resolvendo Algoritmos com Java/4 - Hash Mágico/README.md: -------------------------------------------------------------------------------- 1 |

Desafio

2 | O conceito de hash é transformar uma grande quantidade de dados em uma pequena quantidade de informações. Nesse algoritmo você terá uma entrada com várias linhas, cada uma com uma string. 3 | 4 | O valor de cada caracter é computado como segue: 5 | 6 | Valor = (Posição no alfabeto) + (Elemento de entrada) + (Posição do elemento) 7 | 8 | As posições iniciam em zero. 'A' tem posição 0 no alfabeto, ‘C' tem posição 2 no alfabeto, ... O cálculo de hash retornado é a soma de todos os caracteres da entrada. Por exemplo, se a entrada for: 9 | 10 | CBA 11 | 12 | DDD 13 | 14 | então cada caractere deverá ser computado como segue: 15 | 16 | 2 = 2 + 0 + 0 : 'C' no elemento 0 posição 0 17 | 18 | 2 = 1 + 0 + 1 : 'B' no elemento 0 posição 1 19 | 20 | 2 = 0 + 0 + 2 : 'A' no elemento 0 posição 2 21 | 22 | 4 = 3 + 1 + 0 : 'D' no elemento 1 posição 0 23 | 24 | 5 = 3 + 1 + 1 : 'D' no elemento 1 posição 1 25 | 26 | 6 = 3 + 1 + 2 : 'D' no elemento 1 posição 2 27 | 28 | O cálculo final de hash será 2+2+2+4+5+6 = 21. 29 | 30 |

Entrada

31 | A entrada contém vários casos de teste. A primeira linha de entrada contém um inteiro N que indica a quantidade de casos de teste. Cada caso de teste inicia com um inteiro L (1 ≤ L ≤ 100) que indica a quantidade de linhas que vem a seguir. Cada uma destas L linhas contém uma string com até 50 letras maiúsculas ('A' - 'Z'). 32 | 33 |

Saída

34 | Para cada caso de teste imprima o valor de hash que é calculado conforme o exemplo apresentado acima. 35 | 36 | | Exemplo de Entrada | Exemplo de Saída| 37 | | ---|--- | 38 | |1
2
OSADOISAJDSAOIDJA
ASOIJDOSAJDASOIDJA|594| 39 | 40 | -------------------------------------------------------------------------------- /Resolvendo Algoritmos com Java/5 - O Tabuleiro Secreto/README.md: -------------------------------------------------------------------------------- 1 |

Desafio

2 | O senhor Milli, morador da cidade Petland, é o famoso proprietário da maior fábrica de jogos de tabuleiros do mundo. 3 | 4 | Recentemente, ele teve a ideia de lançar um novo jogo exclusivo de tabuleiro, que ele apelidou de Tabuleiro da Frequência. 5 | 6 | O jogo ocorre da seguinte forma. Inicialmente, um tabuleiro com dimensões N × N é dado contendo apenas 0’s. Depois disso, Q operações são propostas, podendo ser de 4 tipos: 7 | 8 | - 1 X R: Atribuir o valor R a todos os números da linha X; 9 | 10 | - 2 X R: Atribuir o valor R a todos os números da coluna X; 11 | 12 | - 3 X: Imprimir o valor mais frequente na linha X; 13 | 14 | - 4 X: Imprimir o valor mais frequente da coluna X. 15 | 16 | Milli não é muito bom com computadores, mas é bastante preguiçoso. Sabendo que você é um dos melhores programadores do mundo, ele precisa sua ajuda para resolver este problema. 17 | 18 |

Entrada

19 | A primeira linha da entrada é composta por dois inteiros N e Q (1 ≤ N, Q ≤ 105), representando, respectivamente, o tamanho do tabuleiro e a quantidade de operações. As próximas Q linhas da entrada vão conter as Q operações. O primeiro inteiro de cada linha vai indicar o tipo da operação. Caso seja 1 ou 2, será seguido por mais dois inteiros X (1 ≤ X ≤ N) e R (0 ≤ R ≤ 50). Caso seja 3 ou 4, será seguido por apenas mais um inteiro X. 20 | 21 |

Saída

22 | Para cada operação do tipo 3 ou 4, seu programa deve produzir uma linha, contendo o valor da resposta correspondente. Se uma linha ou coluna tiver dois ou mais valores que se repetem o mesmo número de vezes, você deve imprimir o maior deles. Por exemplo, se uma linha tem os valores [5,7,7,2,5,2,1,3], tanto o 2, 5 e 7 se repetem duas vezes, então a resposta será 7, pois é o maior deles. 23 | 24 | | Exemplo de Entrada | Exemplo de Saída| 25 | | ---|--- | 26 | |2 4
1 1 1
2 2 2
3 1
3 2|2
2| 27 | |3 6
1 1 2
1 2 3
1 3 4
4 3
1 3 0
4 3|4
3| 28 | 29 | -------------------------------------------------------------------------------- /Resolvendo Algoritmos com Java/5 - O Tabuleiro Secreto/TabuleiroSecreto.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.util.Map.Entry; 3 | 4 | public class Main { 5 | 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | int dimensao = sc.nextInt(); 9 | int operacoes = sc.nextInt(); 10 | int[][] tabuleiro = new int[dimensao][dimensao]; 11 | sc.nextLine(); 12 | 13 | while(sc.hasNextLine()) { 14 | String[] operacao = sc.nextLine().split(" "); 15 | int linhaOuColuna = Integer.parseInt(operacao[1]) - 1; 16 | switch(operacao[0]){ 17 | case "1": 18 | for(int i=0; i < dimensao; i++) 19 | tabuleiro[linhaOuColuna][i] = Integer.parseInt(operacao[2]); 20 | break; 21 | case "2": 22 | for(int i=0; i < dimensao; i++) 23 | tabuleiro[i][linhaOuColuna] = Integer.parseInt(operacao[2]); 24 | break; 25 | case "3": 26 | System.out.println(valorMaisFrequente(tabuleiro[linhaOuColuna])); 27 | break; 28 | case "4": 29 | int[] coluna = new int[dimensao]; 30 | for(int i=0; i < dimensao; i++) 31 | coluna[i] = tabuleiro[i][linhaOuColuna]; 32 | System.out.println(valorMaisFrequente(coluna)); 33 | break; 34 | } 35 | } 36 | } 37 | 38 | public static int valorMaisFrequente(int[] arr) { 39 | Map frequenciaValores = new HashMap<>(); 40 | for(int i=0; i frequenciaValores) { 49 | List maioresRepeticoes = new ArrayList(); 50 | Integer maiorRepeticao = Collections.max(frequenciaValores.values()); 51 | List chaves = new ArrayList(frequenciaValores.keySet()); 52 | for (Integer chave : chaves) { 53 | Integer valorRepeticao = frequenciaValores.get(chave); 54 | if (valorRepeticao >= maiorRepeticao) { 55 | maioresRepeticoes.add(chave); 56 | } 57 | } 58 | Integer maiorNumeroComMaiorRepeticao = Collections.max(maioresRepeticoes); 59 | return maiorNumeroComMaiorRepeticao; 60 | } 61 | } -------------------------------------------------------------------------------- /Solucionando problemas básicos em Java/1 - Multiplicação Simples/MultiplicacaoSimples.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.InputStreamReader; 3 | import java.io.IOException; 4 | import java.util.StringTokenizer; 5 | 6 | public class MultiplicacaoSimples { 7 | public static void main(String[] args) throws IOException { 8 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 9 | StringTokenizer st = new StringTokenizer(br.readLine()); 10 | int a = Integer.parseInt(st.nextToken()); 11 | 12 | st = new StringTokenizer(br.readLine()); 13 | int b = Integer.parseInt(st.nextToken()); 14 | int total = a * b; 15 | System.out.println("PROD = " + total); 16 | } 17 | } -------------------------------------------------------------------------------- /Solucionando problemas básicos em Java/2 - Menor e Posição/MenorEPosicaoMelhorado.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class MenorEPosicao { 4 | 5 | public static void main(String[] args) { 6 | Scanner leitor = new Scanner(System.in); 7 | int N = leitor.nextInt(); 8 | int menor = Integer.MAX_VALUE, posMenor = 0, entrada; 9 | for (int i = 0; i < N; i++) { 10 | entrada = leitor.nextInt(); 11 | if (entrada < menor) { 12 | menor = entrada; 13 | posMenor = i; 14 | } 15 | } 16 | System.out.println("Menor valor: " + menor); 17 | System.out.println("Posicao: " + posMenor); 18 | } 19 | 20 | } -------------------------------------------------------------------------------- /Solucionando problemas básicos em Java/2 - Menor e Posição/MenorEPosicaoSugestaoDIO.java: -------------------------------------------------------------------------------- 1 | import java.io.IOException; 2 | import java.util.Scanner; 3 | 4 | public class MenorEPosicao { 5 | 6 | public static void main(String[] args) throws IOException { 7 | Scanner leitor = new Scanner(System.in); 8 | int N = leitor.nextInt(); 9 | int[] X = new int[N]; 10 | int menor = 0, posMenor = 0; 11 | for (int i = 0; i < N; i++) { 12 | X[i] = leitor.nextInt(); 13 | if (i == 0) { 14 | menor = X[i]; 15 | posMenor = i; 16 | } else if (X[i] < menor) { 17 | menor = X[i]; 18 | posMenor = i; 19 | } 20 | } 21 | System.out.println("Menor valor: " + menor); 22 | System.out.println("Posicao: " + posMenor); 23 | } 24 | 25 | } -------------------------------------------------------------------------------- /Solucionando problemas básicos em Java/3 - Números Ímpares/NumerosImpares.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class NumerosImpares { 4 | 5 | public static void main(String[] args) { 6 | Scanner entrada = new Scanner(System.in); 7 | int num = entrada.nextInt(); 8 | for (int i = 1; i <= num; i = i + 2) { 9 | System.out.println(i); 10 | } 11 | } 12 | 13 | } -------------------------------------------------------------------------------- /Solução de Problemas com Java/1 - Contagem Repetida de números/ContagemRepetida.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | import java.util.Locale; 3 | import java.util.Scanner; 4 | import java.util.SortedMap; 5 | import java.util.TreeMap; 6 | 7 | public class ContagemRepetida { 8 | 9 | public static void main(String[] args) { 10 | Scanner sc = new Scanner(System.in); 11 | ArrayList lista = new ArrayList(); 12 | 13 | int entrada =sc.nextInt(); 14 | while(entrada --> 0) 15 | lista.add(sc.nextInt()); 16 | 17 | SortedMap contaQuant = new TreeMap<>(); 18 | lista.forEach(id -> contaQuant.compute(id, (key , val) -> (val == null ? 1 : val + 1))); 19 | 20 | contaQuant.entrySet().forEach(entry->{ 21 | System.out.printf("%d aparece %d vez(es)\n", entry.getKey(), entry.getValue()); 22 | }); 23 | 24 | sc.close(); 25 | } 26 | } -------------------------------------------------------------------------------- /Solução de Problemas com Java/1 - Contagem Repetida de números/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Neste desafio sua tarefa será ler vários números e em seguida dizer quantas vezes cada número aparece, ou seja, deve-se escrever cada um dos valores distintos que aparecem na entrada por ordem crescente de valor. 3 | 4 | # Entrada 5 | A primeira linha de entrada contem um único inteiro N, que indica a quantidade de valores que serão lidos para X (1 ≤ N ≤ 2000) logo em seguida. Com certeza cada número não aparecerá mais do que 20 vezes na entrada de dados. 6 | 7 | # Saída 8 | Imprima a saída de acordo com o exemplo fornecido abaixo, indicando quantas vezes cada um deles aparece na entrada por ordem crescente de valor. 9 | 10 | | Exemplo de Entrada | Exemplo de Saída| 11 | | ---|--- | 12 | |7
8
10
8
260
4
10
10|4 aparece 1 vez(es)
8 aparece 2 vez(es)
10 aparece 3 vez(es)
260 aparece 1 vez(es)| -------------------------------------------------------------------------------- /Solução de Problemas com Java/2 - Vogais Extraterrestres/README.md: -------------------------------------------------------------------------------- 1 | ## Desafio 2 | Desde o Gerador de Improbabilidade Infinita, muitos nem questionam sobre vidas extraterrestres, e se aprofundam em questionamentos mais improváveis, como, por exemplo, será que seres de outros planetas usam os mesmos caracteres que nós para se comunicarem? E se isso for verdade, será que usam as mesmas letras vogais que a gente? Pensando nisso, vários cientistas criaram inúmeros tipos de alfabetos alienígenas, usando as letras do nosso alfabeto, além dos dígitos, de 0 a 9, com as suas respectivas vogais. Baseados nisto, eles querem a sua ajuda para identificar vogais em alfabetos alienígenas e realizar a contagem. 3 | 4 | Escreva um programa que, dado uma sequência de vogais, em um determinado alfabeto alienígena, contabilize, em um texto escrito com o mesmo alfabeto, quantas vogais o mesmo possui. 5 | 6 | ## Entrada 7 | Haverá diversos casos de teste. Cada caso de teste é formado por duas linhas. A primeira linha informa uma palavra, formada por todas as vogais alienígenas de um determinado planeta. A segunda linha contém uma frase formada por letras do mesmo alfabeto. A entrada termina com fim de arquivo. 8 | 9 | ## Saída 10 | Para cada caso de teste, imprima a quantidade de vogais alienígenas correspondente. 11 | 12 | | Exemplo de Entrada | Exemplo de Saída| 13 | | ---|--- | 14 | |aeiou
o rato roeu a roupa do rei de roma|16| 15 | |4310
t3st3 p4r4 c0d1f1c4r|8| 16 | |kwy
the quick brown fox jumps over the lazy dog|3| -------------------------------------------------------------------------------- /Solução de Problemas com Java/2 - Vogais Extraterrestres/VogaisExtraterrestres.java: -------------------------------------------------------------------------------- 1 | import java.util.Arrays; 2 | import java.util.List; 3 | import java.util.Scanner; 4 | import java.util.stream.Collectors; 5 | 6 | public class VogaisExtraterrestres { 7 | public static void main(String[] args) { 8 | Scanner sc = new Scanner(System.in); 9 | 10 | while (sc.hasNextLine()) { 11 | String vogais = sc.nextLine(); 12 | String frase = sc.nextLine(); 13 | 14 | int countVogais = 0; 15 | for(char vogal : vogais.toCharArray()) { 16 | countVogais += frase.chars().filter(c -> c == vogal).count(); 17 | } 18 | System.out.println(countVogais); 19 | } 20 | } 21 | } -------------------------------------------------------------------------------- /Solução de Problemas com Java/3 - Melhor amigo do Pablo/MelhorAmigoPablo.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | import java.util.Set; 3 | import java.util.TreeSet; 4 | 5 | public class MelhorAmigoPablo { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | Set alunosAmigos = new TreeSet<>(); 9 | Set alunosNaoAmigos = new TreeSet<>(); 10 | String vencedor = ""; 11 | String entrada; 12 | 13 | while (!"FIM".equals(entrada = sc.nextLine())) { 14 | String nomeAluno = entrada.split(" ")[0]; 15 | boolean isAmigo = "SIM".equals(entrada.split(" ")[1]); 16 | if(isAmigo) { 17 | alunosAmigos.add(nomeAluno); 18 | if (nomeAluno.length() > vencedor.length()) 19 | vencedor = nomeAluno; 20 | } else { 21 | alunosNaoAmigos.add(nomeAluno); 22 | } 23 | } 24 | 25 | alunosAmigos.forEach(System.out::println); 26 | alunosNaoAmigos.forEach(System.out::println); 27 | System.out.println("\nAmigo do Pablo:"); 28 | System.out.println(vencedor); 29 | } 30 | } -------------------------------------------------------------------------------- /Solução de Problemas com Java/3 - Melhor amigo do Pablo/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Todo final de ano ocorre uma festa na escola. As inscrições para participar da festa são abertas no início de julho. No momento da inscrição, o aluno pode escolher se quer ser "O Amigo do Pablo" na festa ou não. O mais lógico seria escolher a opção Sim, afinal, é um privilégio ser O Amigo do Pablo, já que ele é a pessoa mais descolada da escola. Porém, há indivíduos que definitivamente não pretendem ser O Amigo do Pablo, e por motivos desconhecidos. 3 | 4 | Somente um será o escolhido. Em vista disso, muitos alunos que escolheram a opção Sim realizaram a inscrição diversas vezes para aumentar a própria probabilidade de ser O Amigo do Pablo. A diretora da escola pediu que você desenvolva um programa que organize as inscrições do site, pois está havendo um spam de inscrições. O critério para ser o escolhido é a quantidade de letras do primeiro nome, e em caso de empate, vence aquele que realizou primeiro a inscrição. A organização final dos inscritos deverá seguir a ordem de escolha (Sim ou Não), mas respeitando a ordem alfabética. 5 | 6 | OBS.: Ninguém que escolheu a opção Não realizou a inscrição mais de uma vez. 7 | 8 | # Entrada 9 | A entrada contém somente um caso de teste. Cada linha é composta pelo primeiro nome do participante (sem espaços), seguido da opção SIM (caso o usuário queira ser O Amigo do Pablo) ou NAO (caso não queira). A entrada termina assim que o usuário digita "FIM" (sem as aspas). 10 | 11 | # Saída 12 | Seu programa deverá imprimir os inscritos pela ordem de escolha e por ordem alfabética, seguido do nome do vencedor. Imprima uma linha em branco entre a lista de inscritos e o nome do vencedor. 13 | 14 | | Exemplo de Entrada | Exemplo de Saída| 15 | | ---|--- | 16 | |Joao NAO
Carlos SIM
Abner NAO
Samuel SIM
Ricardo NAO
Abhay SIM
Samuel SIM
Andres SIM
Roberto NAO
Carlos SIM
Samuel SIM
Samuel SIM
Abhay SIM
Aline SIM
Andres SIM
FIM|Abhay
Aline
Andres
Carlos
Samuel
Abner
Joao
Ricardo
Roberto

Amigo do Pablo:
Carlos| -------------------------------------------------------------------------------- /Solução de Problemas com Java/4 - Entrevista Embaraçosa/EntrevistaEmbaracosa.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.InputStreamReader; 3 | import java.io.IOException; 4 | import java.util.StringTokenizer; 5 | 6 | public class EntrevistaEmbaracosa { 7 | public static void main(String[] args) throws IOException { 8 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 9 | String proximaPalavra; 10 | 11 | while((proximaPalavra = br.readLine()) != null) { 12 | boolean encontrouRepeticao = false; 13 | for(int i=0; i <= proximaPalavra.length() - 1; i++) { 14 | if( proximaPalavra.substring(0, i).endsWith(proximaPalavra.substring(i)) ) { 15 | System.out.println(proximaPalavra.substring(0, i)); 16 | encontrouRepeticao = true; 17 | } 18 | } 19 | if(!encontrouRepeticao) 20 | System.out.println(proximaPalavra); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Solução de Problemas com Java/4 - Entrevista Embaraçosa/Explicações e Dicas.md: -------------------------------------------------------------------------------- 1 | ## Explicações 2 | O enunciado desta questão não está tão bem escrito. A regra geral é a seguinte: dada uma palavra, divida-a em uma duas, digamos parteInicial e parteFinal. Se a parteInicial terminar com a parteFinal, imprima a parteInicial. Se não houver uma forma de dividir a palavra para atender esta regra, imprima a própria palavra. 3 | Alguns exemplos para ficar mais claro: 4 | - sanduicheiche -> parteInicial = 'sanduiche', parteFinal = 'iche'. Como 'sanduiche' termina em 'iche', imprimimos a parteInicial, que é 'sanduiche'. 5 | - barrilarril -> parteInicial = 'barril', parteFinal = 'arril'. Como 'barril' termina em 'arril', imprimimos a parteInicial, que é 'barril'. 6 | - sol -> Não há como dividir 'sol' de tal forma que a parteInicial termine com a parteFinal. Imprimimos 'sol'. 7 | 8 | É importante ressaltar que uma palavra pode ser dividida de mais de uma forma, e cada uma delas deve ser impressa. Exemplos: 9 | - testetetete 10 | 1. parteInicial = 'testete', parteFinal = 'tete'. Como 'testete' termina em 'tete', imprimimos 'testete' 11 | 1. parteInicial = 'testetete', parteFinal = 'te'. Como 'testetete' termina em 'te', imprimimos 'testetete' 12 | - aaaaa 13 | 1. parteInicial = 'aaa', parteFinal = 'aa'. Como 'aaa' termina em 'aa', imprimimos 'aaa' 14 | 1. parteInicial = 'aaaa', parteFinal = 'a'. Como 'aaaa' termina em 'a', imprimimos 'aaaa' 15 | 16 | ## Mais casos de teste 17 | Para verificar se o seu código está funcionando, tente os casos abaixo, além dos exemplos passados no enunciado: 18 | 19 | | Exemplo de Entrada | Exemplo de Saída| 20 | | ---|--- | 21 | |aaaaaaaaaa|aaaaa
aaaaaa
aaaaaaa
aaaaaaaa
aaaaaaaaa| 22 | |testetetete|testete
testetete| 23 | |testandoando|testando| 24 | |agorasimassim|agorasimassim| 25 | |agorassimassim|agorassim| 26 | |abcdefghijklmnopqrstuvwxyzwxyz|abcdefghijklmnopqrstuvwxyzwxyz| 27 | |a|a| 28 | |bb|b| 29 | |bbb|bb| 30 | |bab|bab| 31 | |baba|ba| 32 | 33 | ## Dicas 34 |
35 | Dica 1 36 | Como você pode garantir que todas as formas de dividir a palavra em duas serão testadas? 37 |
38 |
39 | Dica 2 40 | Ao invés de checar caractere a caractere para verificar se uma palavra termina com outra, tente utilizar o método endsWith 41 |
42 |
43 | Dica 3 44 | Lembre de garantir que todas as saídas de uma palavra sejam impressas, e de que elas estejam em ordem crescente de tamanho. Isso significa que você não deve utilizar um break e deve percorrer a palavra do início ao fim, e não do fim ao início. 45 |
46 |
47 | Dica 4 48 | Lembre de imprimir a própria palavra caso não encontre uma forma de dividir. 49 |
50 | -------------------------------------------------------------------------------- /Solução de Problemas com Java/4 - Entrevista Embaraçosa/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | A nutricionista Juliana Alcantra é uma excelente profissional de sua área. Em determinado dia, ela foi entrevistada ao vivo para um jornal da cidade. No entanto, ficou um pouco nervosa na hora, e diante da situação, sua fala ficou um pouco distorcida, repetindo o final de cada palavra após dizer a mesma. Para que isso não aconteça novamente, ela precisa da sua ajuda para escrever um programa que omita a parte repetida, de modo que as palavras sejam pronunciadas como deveriam ser. 3 | 4 | Escreva um programa que, dada uma palavra errada, a mesma seja corrigida. 5 | 6 | # Entrada 7 | Haverá diversos casos de teste. Cada caso de teste é formado por uma palavra, de, no máximo, 30 caracteres, dita da forma errada. A entrada termina com fim de arquivo. 8 | 9 | # Saída 10 | Para cada caso de teste, escreva a palavra devidamente corrigida. Analise os exemplos para verificar o padrão, de modo a consertar todos os casos. 11 | 12 | | Exemplo de Entrada | Exemplo de Saída| 13 | | ---|--- | 14 | |sanduicheiche| sanduiche| 15 | |barrilarril|barril| 16 | |ratoato|rato| 17 | |sol|sol| 18 | |coliseueu|coliseu| 19 | |queijoijo|queijo| 20 | |astroastro|astro| 21 | |a |a| 22 | 23 | -------------------------------------------------------------------------------- /Solução de Problemas com Java/5 - Conjuntos Bons ou Ruins/ConjuntoBomRuim.java: -------------------------------------------------------------------------------- 1 | import java.io.BufferedReader; 2 | import java.io.InputStreamReader; 3 | import java.io.IOException; 4 | import java.util.List; 5 | import java.util.ArrayList; 6 | import java.util.stream.Collectors; 7 | 8 | public class ConjuntoBomRuim { 9 | public static void main(String[] args) throws IOException { 10 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 11 | int N = Integer.valueOf(br.readLine()); 12 | 13 | while (N != 0) { 14 | List conjunto = new ArrayList<>(); 15 | for (int i = 0; i < N; i++) 16 | conjunto.add(br.readLine()); 17 | 18 | conjunto = conjunto.stream().sorted().collect(Collectors.toList()); 19 | 20 | String saida = "Conjunto Bom"; 21 | for (int i = 0; i < N - 1; i++) { 22 | if (conjunto.get(i + 1).startsWith(conjunto.get(i))) { 23 | saida = "Conjunto Ruim"; 24 | break; 25 | } 26 | } 27 | 28 | System.out.println(saida); 29 | N = Integer.valueOf(br.readLine()); 30 | } 31 | } 32 | } -------------------------------------------------------------------------------- /Solução de Problemas com Java/5 - Conjuntos Bons ou Ruins/Explicações e Dicas.md: -------------------------------------------------------------------------------- 1 | ## Explicações 2 | Exemplos de palavras que são prefixos de outras: 3 | - 'dbc' é prefixo de 'dbcde' 4 | - 'bate' é prefixo de 'batedeira' 5 | - 'giro' é prefixo de 'giroscópio' 6 | 7 | Neste desafio então, se você tiver em um conjunto 'giro' e 'giroscópio' e mais 1000 palavras, ele será um conjunto ruim de qualquer forma porque 'giro' é prefixo de 'giroscópio'. Ou seja, basta achar um caso desses para ser um conjunto ruim 8 | 9 | ## Dicas 10 |
11 | Dica 1 12 | Uma forma de fazer é, para cada palavra, verificar se ela faz parte do início de alguma das outras palavras. 13 |
14 |
15 | Dica 2 16 | Existe algum método que você consiga verificar a condição da dica anterior sem ter que comparar caracter por caracter? 17 |
18 |
19 | Dica 3 20 | Cuidado para não confundir prefixo com estar contido. Ou seja, cuidado para não usar contains() ao invés de startsWith(). 21 |
22 |
23 | Dica 4 24 | O que acontece se você ordenar as palavras? 25 |
26 |
27 | Dica 5 28 | Ao ordenar as palavras em ordem alfabética, é possível que uma palavra que venha depois na lista seja prefixo de uma anterior? Qual é a única possibilidade para uma palavra ser prefixo da outra em uma lista ordenada? 29 |
-------------------------------------------------------------------------------- /Solução de Problemas com Java/5 - Conjuntos Bons ou Ruins/README.md: -------------------------------------------------------------------------------- 1 | # Desafio 2 | Nesse algoritmo você deverá descobrir se um conjunto de palavras é bom ou ruim. Por definição, um conjunto é bom quando nenhuma palavra desse conjunto é um prefixo de outra palavra. Caso contrário, é considerado um conjunto ruim. 3 | 4 | Por exemplo, {dbc, dae, dbcde} é um conjunto ruim, pois dbc é um prefixo de dbcde. Quando duas palavras são idênticas, definimos como uma sendo prefixo da outra. 5 | 6 | # Entrada 7 | A entrada contém vários casos de teste. A primeira linha de cada caso de teste terá um inteiro N (1 ≤ N ≤ 10⁵), que representa a quantidade de palavras no conjunto. Segue então N linhas, cada uma tendo uma palavra de no máximo 100 letras minúsculas. A entrada termina quando N = 0 e não deve ser processada. 8 | 9 | # Saída 10 | Para cada caso de teste, você deverá imprimir "Conjunto Bom", ou "Conjunto Ruim", conforme explicado acima. 11 | 12 | | Exemplo de Entrada | Exemplo de Saída| 13 | | ---|--- | 14 | | 3
abc
dae
abcde
2
abc
def
0| Conjunto Bom
Conjunto Ruim | 15 | 16 | -------------------------------------------------------------------------------- /Solução de Problemas com Java/6 - Produto e divisão/ProdutoDivisao.java: -------------------------------------------------------------------------------- 1 | import java.math.BigDecimal; 2 | import java.math.RoundingMode; 3 | import java.util.Scanner; 4 | 5 | public class CombinacaoStrings { 6 | public static void main(String[] args) { 7 | BigDecimal resultado = new BigDecimal(1); 8 | Scanner sc = new Scanner(System.in); 9 | sc.nextLine(); 10 | 11 | while (sc.hasNextLine()) { 12 | BigDecimal digito = new BigDecimal(sc.nextInt()); 13 | String operador = sc.nextLine().trim(); 14 | if ("/".equals(operador)) resultado = resultado.divide(digito, 3, RoundingMode.CEILING); 15 | if ("*".equals(operador)) resultado = resultado.multiply(digito); 16 | } 17 | System.out.println(resultado.toBigInteger()); 18 | } 19 | } -------------------------------------------------------------------------------- /Solução de Problemas com Java/6 - Produto e divisão/README.md: -------------------------------------------------------------------------------- 1 | ## Desafio 2 | Você tem a obrigação de testar as calculadores, para que façam apenas operações de multiplicação e divisão. Além disso, o termo a ser digitado em cada operação, (o número exibido no visor que será dividido ou multiplicado), só pode conter um único dígito. 3 | 4 | Quando ligada, a calculadora exibe o número 1. Após isso, o usuário pode digitar um número com um único dígito e escolher se esse número deve multiplicar ou dividir o número exibido anteriormente; o resultado da operação escolhida é então exibido na calculadora. Pode-se repetir esse processo quantas vezes quiser. 5 | 6 | Apesar de ser permitido apenas números inteiros de um dígito, a calculadora permite exibir números com múltiplos dígitos e até mesmo números fracionários. 7 | 8 | Apresentada a sequência de operações realizadas logo depois de ligada, seu objetivo é conferir o resultado exibido. 9 | 10 | No primeiro caso de teste abaixo, o usuário deseja calcular o resultado da seguinte expressão: 1 × 2 × 1 × 3. Note que a primeira ocorrência do número 1 vem do fato da calculadora mostrar inicialmente 1 ao invés de 0. 11 | 12 | No segundo caso de teste abaixo, o usuário deseja calcular o resultado da seguinte expressão: ((1/2)/3) × 6. 13 | 14 | ## Entrada 15 | A primeira e única linha da entrada contém um inteiro N (1 ≤ N ≤ 100 000). Cada uma das próximas N linhas contém um dígito e um caractere '*' ou '/', que representam uma operação realizada na calculadora. 16 | 17 | ## Saída 18 | O programa deve imprimir uma única linha contendo o resultado que deve ser exibido pela calculadora ao final de todas as operações. 19 | 20 | | Exemplo de Entrada | Exemplo de Saída| 21 | | ---|--- | 22 | |3
2 *
1 *
3 *|6| 23 | |3
2 /
3 /
6 *|1| 24 | |11
9 *
9 *
9 *
9 *
9 *
9 *
9 *
9 *
9 *
9 *
9 /|387420489| --------------------------------------------------------------------------------