├── .gitignore ├── C# ├── Desafios Básicos C# │ ├── MultiplicacaoSimples.cs │ └── ParOuImpar.cs ├── Desafios Iniciais - GFT Start #3 .NET │ └── CalculoSimples.cs ├── Desafios aritméticos em C# │ ├── bazinga.cs │ ├── comunicacao-em-piralandia.cs │ ├── crescimento-populacional.cs │ ├── media-1.cs │ └── tempo-de-um-evento.cs ├── Desafios avançados em C# │ ├── media3.cs │ └── tempo-jogo-minutos.cs ├── Desafios numéricos em C# │ ├── OMaior.cs │ ├── SequenciaLogica2.cs │ ├── TipoDeCombustivel.cs │ └── TiposDeTriangulos.cs ├── Desenvolvendo algoritmos com C# │ ├── album-da-copa.cs │ ├── animal.cs │ └── calculo-de-viagem.cs ├── Fundamentos Aritméticos em C# │ └── contagem-de-cedulas.cs ├── Introdução a Programação com .NET │ ├── bazinga.cs │ └── coxinha-de-bueno.cs ├── Introdução a Programação com C# │ ├── distancia.cs │ ├── dividindo-X-por-Y.cs │ ├── media2.cs │ ├── positivos-media.cs │ ├── quanta-mandioca.cs │ └── sequencia-logica.cs ├── Introdução a Resolução de Desafios com C# │ └── NumerosImpares.cs ├── Praticando programação em C# │ ├── coordenadas-de-um-ponto.cs │ └── pink-cerebro.cs ├── Primeiros desafios com C# │ ├── Mes.cs │ └── QuantidadeNumerosPositivos.cs ├── Primeiros desafios em C# │ └── Diferenca.cs ├── Primeiros programas em C# │ ├── area-circulo.cs │ ├── multiplos.cs │ └── soma-simples.cs ├── Programando em C# │ ├── QuadradoDePares.cs │ ├── SequenciaIJ2.cs │ ├── SequenciaS.cs │ ├── SucessorPar.cs │ ├── VaiTerCopa.cs │ └── Xenlongao.cs ├── Resolvendo Algoritmos │ ├── cardapio-aereo.cs │ ├── conversao-de-tempo.cs │ ├── hora-da-corrida.cs │ ├── idade-em-dias.cs │ ├── pizza-antes-do-final-do-ano.cs │ ├── rodizio-de-cavalos-e-carruagens.cs │ └── tempo-do-dobby.cs ├── Resolvendo Desafios Básicos em C# │ ├── GuilhermeESuasPipas.cs │ ├── MaiorEPosicao.cs │ └── SomaSeImparesConsecutivosI.cs ├── Resolvendo Desafios Iniciais em C# │ ├── HoHoHo.cs │ ├── Pneu.cs │ └── Quadrante.cs ├── Resolvendo desafios Intermediários em C# │ ├── Intervalo2.cs │ ├── PUM.cs │ └── PoligonosRegularesSimples.cs ├── Solucionando desafios intermediários em C# │ ├── formula-de-bhaskara.cs │ ├── notas-e-moedas.cs │ ├── teorematda-divisao-euclidiana.cs │ ├── teste-de-selecao-1.cs │ └── triangulo.cs ├── Solução de Problemas Essenciais com C# │ ├── a-corrida-de-tartarugas.cs │ ├── pedro-bento-e-o-mundo-de-oz.cs │ ├── quadrado-e-ao-cubo.cs │ ├── ultrapassando-V.cs │ └── validacao-de-nota.cs ├── Solução de problemas básicos em C# │ ├── tuitando.cs │ └── visita-na-feira.cs ├── Solução de problemas com .NET │ ├── compras-no-supermercado.cs │ ├── fila-do-banco.cs │ ├── programa-para-validacao-de-notas.cs │ └── validador-de-senhas-com-requisitos.cs └── Solução de problemas em C# │ ├── aumento-salario.cs │ ├── consumo-medio-do-automovel.cs │ ├── ddd.cs │ ├── encaixa-nao.cs │ ├── preenchimento-vetor-I.cs │ └── trigo-tabuleiro.cs ├── Java ├── Desafio Aritmético em Java │ ├── AbaixoDiagonalPrincipal.java │ ├── AbaixoDiagonalSecundaria.java │ └── AcimaDiagonalSecundaria.java ├── Desafios Aritméticos em Java │ └── divisores.java ├── Desafios Avançados em Java │ ├── AMudanca.java │ ├── AreaSuperior.java │ └── FibonacciEmVetor.java ├── Desafios matemáticos em Java │ ├── AreaDireita.java │ ├── AreaEsquerda.java │ └── AreaInferior.java ├── Desafios numéricos em Java │ ├── FatorialSimples.java │ └── SeisNumerosPares.java ├── Desafios para iniciantes em Java │ ├── HoHoHo.java │ └── Quadrante.java ├── Fundamentos Aritméticos em Java │ ├── AnaliseNumeros.java │ ├── ConsumoMedioAutomovel.java │ ├── ContagemCedulas.java │ ├── ExibindoNumerosPares.java │ └── QtdeNumerosPositivos.java ├── Iniciando a programação em Java │ ├── DDD.java │ └── EntradaESaidaCPF.java ├── Introdução a Busca e Substituição em Java │ ├── AtalhosWebBlogger.java │ ├── MaiorSubstring.java │ ├── OrdenacaoPalavrasPorTamanho.java │ ├── PedraPapelTesouraLagartoSpock.java │ └── ValidadorSenhas.java ├── Introdução a Programação com Java │ ├── EncaixaOuNaoI.java │ ├── FolhaPagamento.java │ ├── Media1.java │ ├── MultiplicacaoSimples.java │ ├── Multiplos.java │ ├── SomaSimples.java │ ├── TempoDeJogo.java │ └── VisitaFeira.java ├── Introdução a Programação em Java │ ├── ConversaoDeTempo.java │ └── Tuitando.java ├── Ordenação e Filtros em Java │ ├── ComprasSupermercado.java │ ├── FilaBanco.java │ ├── GincanaAcampamento.java │ ├── OrdenandoNumerosParesImpares.java │ └── UniformesFinalAno.java ├── Primeiros desafios de código com Java │ ├── Mes.java │ ├── TesteDeSelecao1.java │ └── ValidacaoDeNota.java ├── Primeiros passos com Java │ ├── Distancia.java │ ├── DividindoXPorY.java │ └── SomaSimples.java ├── Primeiros passos em Java │ ├── Batmain.java │ ├── Diferenca.java │ ├── Divisores.java │ ├── Domingo.java │ ├── ParesEntreCincoNumeros.java │ └── Theon.java ├── Resolvendo Algoritmos com Java │ ├── AbreviacaoPostsBlog.java │ ├── CombinacaoStrings.java │ ├── CoracaoCartas.java │ ├── HashMagico.java │ └── TabuleiroSecreto.java ├── Resolvendo Desafios Intermediários em Java │ ├── EntradaESaidaDeNumerosInteiros.java │ ├── SenhaFixa.java │ └── TamanhoDaPlaca.java ├── Resolvendo Desafios em Java │ ├── Chuva.java │ └── PreenchimentoVetorIII.java ├── Resolvendo Desafios médios em Java │ ├── AMesagemDoPadreDoBalao.java │ ├── CrescenteEDecrescente.java │ └── ReservatorioDeMel.java ├── Solucionando problemas básicos em Java │ ├── MenorPosicao.java │ └── NumerosImpares.java ├── Solução de Problemas com Java │ ├── BarrasOuro.java │ ├── ConjuntosBonsRuins.java │ ├── ContagemRepetidaNumeros.java │ ├── EntrevistaEmbaracosa.java │ ├── MelhorAmigoPablo.java │ ├── ProdutoDivisao.java │ └── VogaisExtraterrestres.java └── Solução de problemas básicos em Java │ ├── ExibindoNumerosPares.java │ ├── IdadeEmDias.java │ └── NotasDaProva.java ├── JavaScript ├── Busca e Laços de Repetição │ ├── degustacao-de-vinho.js │ └── pink-e-cerebro.js ├── Desafio Aritmético em JavaScript │ ├── AreaInferior.js │ ├── NomeNoFormulario.js │ └── PositivosEMedia.js ├── Desafios Aritméticos em JavaScript │ ├── coxinha-de-bueno.js │ ├── fibonacci-facil.js │ ├── preenchimento-vetor-I.js │ ├── substituicao-vetor-I.js │ └── teorema-da-divisao-euclidiana.js ├── Desafios Iniciais JavaScript │ ├── Intervalo.js │ └── Tabuada.js ├── Desafios Intermediários JavaScript │ └── Saida6.js ├── Desafios Lógicos │ ├── abreviando-posts-do-blog.js │ ├── album-da-copa.js │ ├── brinquedos-do-papai-noel.js │ ├── hash-magico.js │ ├── o-tabuleiro-secreto.js │ └── votacao-para-bobo-da-corte.js ├── Desafios Médios JavaScript │ ├── FasesDaLua.js │ └── PoligonosRegularesSimples.js ├── Desafios avançados de código em JavaScript │ └── Diferenca.js ├── Desenvolvimento de problemas avançados em JavaScript │ └── animal.js ├── Fundamentos Aritméticos em JavaScript │ ├── analise-de-numeros.js │ ├── consumo-medio-do-automovel.js │ ├── contagem-de-cedulas.js │ ├── exibindo-numeros-pares.js │ └── quantidade-de-numeros-positivos.js ├── Introdução a Busca e Substituição em JavaScript │ ├── atalhos-para-o-weblogger-brasil.js │ ├── ordenacao-de-palavras-por-tamanho.js │ └── validador-de-senhas-com-requisitos.js ├── Introdução a Programação com JavaScript │ ├── folha-de-pagamento.js │ ├── multiplicacao-simples.js │ └── visita-na-feira.js ├── Introdução a Programação │ └── quanta-mandioca.js ├── Ordenação e Filtros em JavaScript │ ├── fila-do-banco.js │ └── ordenando-numeros-pares-e-impares.js ├── Ordenação, filtros e Desafios │ ├── compras-no-supermercado.js │ ├── comunicacao-em-piralandia.js │ ├── encontre-a-maior-substring.js │ ├── menor-e-posicao.js │ ├── o-escolhido.js │ └── pedra-papel-tesoura-lagarto-e-spock.js ├── Praticando Programação com JavaScript │ ├── distancia.js │ └── dividindo-X-por-Y.js ├── Problemas Aritméticos │ ├── calculo-de-viagem.js │ ├── soma-simples.js │ └── taxa-de-imposto-de-renda.js ├── Programando com JS │ ├── QuadradoPares.js │ └── Resto2.js ├── Programando com JavaScript - Iniciante │ └── NumerosImpares.js ├── Resolvendo Algoritmos com JavaScript │ ├── combinacao-de-strings.js │ └── coracao-das-cartas.js ├── Resolvendo Algoritmos │ ├── album-da-copa.js │ ├── programa-para-validacao-de-notas.js │ └── tipo-de-combustivel.js ├── Resolvendo Desafios Básicos em JavaScript │ ├── Multiplos.js │ └── TesteSeleção1.js ├── Resolvendo Desafios Intermediários em JavaScript │ ├── GuilhermeSuasPipas.js │ ├── Tomadas.js │ └── Triangulo.js ├── Resolvendo desafios em JavaScript │ ├── FrotaTaxi.js │ ├── NossosDiasNuncaVoltarao.js │ └── Xadrez.js ├── Solução de Problemas Cotidianos │ ├── cardapio-aereo.js │ ├── conversao-de-tempo.js │ ├── hora-da-corrida.js │ ├── idade-em-dias.js │ ├── pizza-antes-do-final-do-ano.js │ ├── rodizio-de-cavalos-e-carruagens.js │ └── tempo-do-dobby.js ├── Solução de Problemas Essenciais │ ├── ultrapassando-V.js │ └── validacao-de-nota.js ├── Solução de Problemas com JavaScript │ ├── barras-de-ouro.js │ ├── conjuntos-bons-ou-ruins.js │ ├── contagem-repetida-de-numeros.js │ ├── entrevista-embaracosa.js │ ├── melhor-amigo-do-pablo.js │ ├── produto-e-divisao.js │ └── vogais-extraterrestres.js ├── Solução de Problemas │ ├── a-corrida-de-tartarugas.js │ ├── fila-do-banco.js │ ├── gincana-no-acampamento.js │ ├── pedro-bento-e-o-mundo-de-oz.js │ ├── quadrado-e-ao-cubo.js │ └── uniformes-de-final-de-ano.js └── Solução de problemas básicos em JavaScript │ └── blobs.js ├── Kotlin ├── Desafios Matemáticos em Kotlin │ ├── ConsumoMedioAutomóvel.kt │ └── CoxinhaBueno.kt ├── Desafios numéricos em Kotlin │ ├── JogoMatematicoPaula.kt │ └── TDARacional.kt ├── Introdução a programação com Kotlin │ ├── ConversaoDeTempo.kt │ ├── IdadeEmDias.kt │ └── Media3.kt ├── Introdução a programação em Kotlin │ ├── NumerosImpares.kt │ ├── QuadradoCubo.kt │ └── SomaSimples.kt ├── Praticando Aritmética em Kotlin │ ├── ColunaMatriz.kt │ ├── ExibindoNumerosPares.kt │ ├── PreenchimentoVetorI.kt │ └── SubstituicaoVetorI.kt ├── Praticando programação com Kotlin │ ├── ContagemDeCedulas.kt │ └── Distancia.kt ├── Praticando programação em Kotlin │ ├── BobConduite.kt │ ├── ConversaoSimplesBase.kt │ └── JogoMatematicoPaula.kt ├── Primeiros passos em Kotlin │ ├── MediaUm.kt │ ├── MultiplicacaoSimples.kt │ └── SequenciaLogica.kt ├── Solucionando desafios em Kotlin │ ├── AcimaDiagonalPrincipal.kt │ ├── AnaliseDeNumeros.kt │ ├── FibonacciFacil.kt │ ├── TesteDeSelecaoUm.kt │ └── Triangulo.kt └── Solucionando problemas em Kotlin │ ├── AreaCirculo.kt │ ├── CorridaTartarugas.kt │ ├── Figurinhas.kt │ ├── PrimoRapido.kt │ └── TaxaImpostoRenda.kt ├── LICENSE ├── Python ├── Desafios matemáticos em Python │ ├── PreenchimentoVetorIII.py │ ├── RodizioCavalosCarruagens.py │ └── TempoJogoMinutos.py ├── Resolvendo algoritmos com Python │ ├── ARespostaTheon.py │ ├── ExibindoNumerosPares.py │ └── FibonacciFacil.py ├── Solucionando Desafios em Python │ ├── FolhaPagamento.py │ ├── Media3.py │ └── ProgramaParaValidacaoNotas.py └── Soluções Aritméticas em Python │ ├── NotasDaProva.py │ ├── PreenchimentoVetorI.py │ └── triangulo.py ├── README.md ├── Ruby ├── Praticando com desafios intermediários em Ruby │ ├── CrescimentoPopulacional.rb │ ├── EncaixaOuNao.rb │ ├── FibonacciFacil.rb │ ├── SequenciaLogica.rb │ └── TipoDeCombustivel.rb ├── Solucionando desafios matemáticos em Ruby │ ├── AcimaDaDiagonalPrincipal.rb │ ├── FibonacciEmVetor.rb │ └── SubstituicaoEmVetorI.rb └── Solucionando problemas básicos em Ruby │ ├── DDD.rb │ ├── IdadeEmDias.rb │ └── ParOuImpar.rb └── assets ├── abaixo-diagonal-principal.png ├── abaixo-diagonal-secundaria.png ├── acima-diagonal-principal.png ├── acima-diagonal-secundaria.png ├── animal.png ├── area-direita.png ├── area-esquerda.png ├── area-inferior.png ├── area-superior.png ├── banner.png ├── batmain.jpg ├── bob-conduite.jpg ├── coluna-matriz.png ├── conversao-simples-base.gif ├── coordenadas-de-um-ponto.png ├── csharp.svg ├── ddd.png ├── fases-da-lua.png ├── figurinhas.jpg ├── java.svg ├── javascript.svg ├── kotlin.svg ├── mudanca.png ├── notas-prova.png ├── o-maior.png ├── poligonos-regulares-simples.jpg ├── python.svg ├── ruby.svg ├── taxa-imposto-renda.png ├── xadrez.png └── xenlongao.png /.gitignore: -------------------------------------------------------------------------------- 1 | .vscode/ 2 | 3 | -------------------------------------------------------------------------------- /C#/Desafios Básicos C#/MultiplicacaoSimples.cs: -------------------------------------------------------------------------------- 1 | // Multiplicação Simples 2 | 3 | /* 4 | Você receberá dois valores inteiros. Faça a leitura e em seguida calcule o 5 | produto entre estes dois valores. Atribua esta operação à variável PROD, 6 | mostrando esta de acordo com a mensagem de saída esperada (exemplo abaixo). 7 | 8 | - Entrada 9 | 10 | A entrada contém 2 valores inteiros. 11 | 12 | - Saída 13 | 14 | Exiba a variável PROD conforme exemplo abaixo, tendo obrigatoriamente um espaço 15 | em branco antes e depois da igualdade. 16 | */ 17 | 18 | using System; 19 | 20 | class Program { 21 | static void Main(string[] args) { 22 | int a, b; 23 | 24 | a = Convert.ToInt32(Console.ReadLine()); 25 | b = Convert.ToInt32(Console.ReadLine()); 26 | 27 | Console.WriteLine("PROD = " + (a * b)); 28 | Console.ReadLine(); 29 | } 30 | } -------------------------------------------------------------------------------- /C#/Desafios Básicos C#/ParOuImpar.cs: -------------------------------------------------------------------------------- 1 | // Par ou Ímpar 2 | 3 | /* 4 | Leia um valor inteiro N. Este valor será a quantidade de valores que serão 5 | lidos em seguida. Para cada valor lido, mostre uma mensagem em inglês dizendo 6 | se este valor lido é par (EVEN), ímpar (ODD), positivo (POSITIVE) ou negativo 7 | (NEGATIVE). No caso do valor ser igual a zero (0), embora a descrição correta 8 | seja (EVEN NULL), pois por definição zero é par, seu programa deverá imprimir 9 | apenas NULL. 10 | 11 | - Entrada 12 | 13 | A primeira linha da entrada contém um valor inteiro N(N < 10000) que indica o 14 | número de casos de teste. Cada caso de teste a seguir é um valor inteiro X 15 | (-107 < X <107). 16 | 17 | - Saída 18 | 19 | Para cada caso, imprima uma mensagem correspondente, de acordo com o exemplo 20 | abaixo. Todas as letras deverão ser maiúsculas e sempre deverá haver um espaço 21 | entre duas palavras impressas na mesma linha. 22 | */ 23 | 24 | using System; 25 | 26 | class Desafio { 27 | public static void Main() { 28 | int tc, i, x; 29 | 30 | tc = int.Parse(Console.ReadLine()); 31 | 32 | for ( i = 0; i < tc; i++) { 33 | x = int.Parse(Console.ReadLine()); 34 | 35 | if (x == 0) Console.WriteLine("NULL"); 36 | if (x != 0) { 37 | if (x > 0) { 38 | Console.WriteLine(x % 2 ==0 ? "EVEN POSITIVE" : "ODD POSITIVE"); 39 | } else if (x < 0) { 40 | Console.WriteLine(x % 2 ==0 ? "EVEN NEGATIVE" : "ODD NEGATIVE"); 41 | } 42 | } 43 | } 44 | Console.ReadLine(); 45 | } 46 | } -------------------------------------------------------------------------------- /C#/Desafios Iniciais - GFT Start #3 .NET/CalculoSimples.cs: -------------------------------------------------------------------------------- 1 | // Cálculo Simples 2 | 3 | /* 4 | Neste problema, deve-se ler o código de uma peça 1, o número de peças 1, o valor 5 | unitário de cada peça 1, o código de uma peça 2, o número de peças 2 e o valor 6 | unitário de cada peça 2. Após, calcule e mostre o valor a ser pago. 7 | 8 | - Entrada 9 | 10 | O arquivo de entrada contém duas linhas de dados. Em cada linha haverá 3 valores, 11 | respectivamente dois inteiros e um valor com 2 casas decimais. 12 | 13 | - Saída 14 | 15 | A saída deverá ser uma mensagem conforme o exemplo fornecido abaixo, lembrando de 16 | deixar um espaço após os dois pontos e um espaço após o "R$". O valor deverá ser 17 | apresentado com 2 casas após o ponto. 18 | */ 19 | 20 | using System; 21 | 22 | class DIO{ 23 | static void Main(string[] args) { 24 | string[] input; 25 | input = Console.ReadLine().Split(' '); 26 | 27 | int cod1 = int.Parse(input[0]); 28 | int n1 = int.Parse(input[1]); 29 | double valor1 = double.Parse(input[2]); 30 | input = Console.ReadLine().Split(' '); 31 | 32 | int cod2 = int.Parse(input[0]); 33 | int n2 = int.Parse(input[1]); 34 | double valor2 = double.Parse(input[2]); 35 | double total = (n1 * valor1) + (n2 * valor2); 36 | 37 | Console.WriteLine("VALOR A PAGAR: R$ {0:F2}", total); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /C#/Desafios aritméticos em C#/comunicacao-em-piralandia.cs: -------------------------------------------------------------------------------- 1 | // Comunicação em Piralândia 2 | 3 | /* 4 | Os cientistas brasileiros descobriram um exoplaneta a 1 bilhão de anos luz da 5 | terra. Ele foi carinhosamente batizado de Piralândia, uma homenagem a cidade de 6 | Piracicaba, onde moram os cientistas. Após algum tempo observando esse planeta, 7 | os cientistas puderam ver que nele haviam habitantes e, além disso, esses 8 | habitantes estavam tentando fazer contato com os cientistas através de uma 9 | comunicação numérica. 10 | 11 | Só que a numeração que encontraram estava invertida e como muitas delas foram 12 | descobertas, os cientistas chamaram você para conseguir automatizar esse 13 | processo. Logo, dado um número grande, sua tarefa é imprimir esse número 14 | invertido. 15 | 16 | - Entrada 17 | 18 | O arquivo contém apenas uma linha de teste que é o número encontrado 19 | (0 < n < 9999999999). 20 | 21 | Obs.: Perceba que o número lido é muito alto para armazenar em uma variável do 22 | tipo int, logo você irá precisar utilizar o tipo long, que para a leitura e 23 | impressão em C, você deve utilizar o %llu. 24 | 25 | - Saída 26 | 27 | Imprimir o número lido invertido. Não esqueça de imprimir a quebra de linha 28 | (\n) no final, caso contrário você receberá (Presentation Error). 29 | */ 30 | 31 | using System; 32 | 33 | class URI { 34 | static void Main(string[] args) { 35 | string n = Console.ReadLine(); 36 | char[] arr = n.ToCharArray(); 37 | 38 | Array.Reverse(arr); 39 | string v = new string(arr); 40 | 41 | Console.WriteLine(v); 42 | } 43 | } -------------------------------------------------------------------------------- /C#/Desafios aritméticos em C#/media-1.cs: -------------------------------------------------------------------------------- 1 | // Média 1 2 | 3 | /* 4 | Leia 2 valores de ponto flutuante de dupla precisão A e B, que correspondem a 5 | 2 notas de um aluno. A seguir, calcule a média do aluno, sabendo que a nota A 6 | tem peso 3.5 e a nota B tem peso 7.5 (A soma dos pesos portanto é 11). Assuma 7 | que cada nota pode ir de 0 até 10.0, sempre com uma casa decimal. 8 | 9 | - Entrada 10 | 11 | O arquivo de entrada contém 2 valores com uma casa decimal cada um. 12 | 13 | - Saída 14 | 15 | Calcule e imprima a variável MEDIA conforme exemplo abaixo, com 5 dígitos após 16 | o ponto decimal e com um espaço em branco antes e depois da igualdade. Utilize 17 | variáveis de dupla precisão (double) e como todos os problemas, não esqueça de 18 | imprimir o fim de linha após o resultado, caso contrário, você receberá 19 | "Presentation Error". 20 | */ 21 | 22 | using System; 23 | 24 | class URI { 25 | static void Main(string[] args) { 26 | double a, b, mediaP; 27 | 28 | a = Convert.ToDouble(Console.ReadLine()); 29 | b = Convert.ToDouble(Console.ReadLine()); 30 | mediaP = (( a * 3.5) + ( b * 7.5)) / (3.5 + 7.5); 31 | 32 | Console.WriteLine("MEDIA = {0}", mediaP.ToString("0.00000")); 33 | } 34 | } -------------------------------------------------------------------------------- /C#/Desafios numéricos em C#/OMaior.cs: -------------------------------------------------------------------------------- 1 | // O Maior 2 | 3 | /* 4 | Desenvolva um programa capaz de ler três valores e apresentar o maior deles e 5 | adicionar a mensagem “ eh o maior”. Use a seguinte forma como base: 6 | 7 | vide arquivo o-maior.png em assets 8 | 9 | Obs.: a fórmula apenas calcula o maior entre os dois primeiros (a e b). Um 10 | segundo passo, portanto é necessário para chegar no resultado esperado. 11 | 12 | • Entrada 13 | 14 | O arquivo de entrada contém três valores inteiros. 15 | 16 | • Saída 17 | 18 | Imprima o maior dos três valores seguido pela mensagem " eh o maior". 19 | */ 20 | 21 | using System; 22 | 23 | class Program { 24 | static void Main(string[] args) { 25 | string[] vet = Console.ReadLine().Split(' '); 26 | int a = Convert.ToInt32(vet[0]); 27 | int b = Convert.ToInt32(vet[1]); 28 | int c = Convert.ToInt32(vet[2]); 29 | int MAIOR = 0; 30 | 31 | if (a >= b && a >= c) { 32 | MAIOR = a; 33 | } else if(b >= a && b >= c) { 34 | MAIOR = b; 35 | } else { 36 | MAIOR = c; 37 | } 38 | 39 | Console.WriteLine($"{MAIOR} eh o maior"); 40 | } 41 | } -------------------------------------------------------------------------------- /C#/Desafios numéricos em C#/SequenciaLogica2.cs: -------------------------------------------------------------------------------- 1 | // Sequência Lógica 2 2 | 3 | /* 4 | Você terá desafio de escrever um programa que leia dois valores X e Y. A 5 | seguir, mostre uma sequência de 1 até Y, passando para a próxima linha a cada 6 | X números. 7 | 8 | • Entrada 9 | 10 | O arquivo de entrada contém dois valores inteiros, (1 < X < 20) e (X < Y < 11 | 100000). 12 | 13 | • Saída 14 | 15 | Cada sequência deve ser impressa em uma linha apenas, com 1 espaço em branco 16 | entre cada número, conforme exemplo abaixo. Não deve haver espaço em branco 17 | após o último valor da linha. 18 | */ 19 | 20 | using System; 21 | 22 | class Program { 23 | static void Main(string[] args) { 24 | string[] vet = Console.ReadLine().Split(' '); 25 | int x = int.Parse(vet[0]); 26 | int y = int.Parse(vet[1]); 27 | 28 | for (int i = 1; i<=y; i++) { 29 | Console.Write(i); 30 | 31 | if (((i % x) == 0)) { 32 | Console.WriteLine(); 33 | } else { 34 | Console.Write(" "); 35 | } 36 | } 37 | } 38 | } -------------------------------------------------------------------------------- /C#/Desenvolvendo algoritmos com C#/calculo-de-viagem.cs: -------------------------------------------------------------------------------- 1 | // Cálculo de viagem 2 | 3 | /* Rubens quer calcular e mostrar a quantidade de litros de combustível gastos 4 | em uma viagem de carro, sendo que seu carro faz 12 KM/L. Como ele não sabe 5 | fazer um programa que o auxilie nessa missão, ele te pede ajuda. Para efetuar 6 | o cálculo, deve-se fornecer o tempo gasto em horas na viagem e a velocidade 7 | média durante a mesma em km/h. Assim, você conseguirá passar para Rubens qual 8 | a distância percorrida e, em seguida, calcular quantos litros serão necessários 9 | para a viagem que ele quer fazer. Mostre o valor com 3 casas decimais após o 10 | ponto. 11 | 12 | - Entrada 13 | 14 | O arquivo de entrada contém dois inteiros. O primeiro é o tempo gasto na 15 | viagem em horas e o segundo é a velocidade média durante a mesma em km/h. 16 | 17 | - Saída 18 | 19 | Imprima a quantidade de litros necessária para realizar a viagem, com três 20 | dígitos após o ponto decimal */ 21 | 22 | using System; 23 | using static System.Math; 24 | 25 | class Program { 26 | static void Main(string[] args) { 27 | string[] km = Console.ReadLine().Split(" "); 28 | int h = Int32.Parse(km[0]); 29 | int veloc = Int32.Parse(km[1]); 30 | double x = 12; 31 | double litro = (h * veloc); 32 | double total = litro/x; 33 | 34 | Console.WriteLine(total.ToString("N3")); 35 | } 36 | } -------------------------------------------------------------------------------- /C#/Fundamentos Aritméticos em C#/contagem-de-cedulas.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | 3 | namespace DIO 4 | { 5 | class Program 6 | { 7 | static void Main(string[] args) 8 | { 9 | int ValorTotal, NotaAtual, QuantidadeDeNotas, ValorRestante; 10 | 11 | ValorTotal = int.Parse(Console.ReadLine()); 12 | Console.WriteLine(ValorTotal); 13 | int[] Notas = {100, 50, 20, 10, 5 , 2 , 1}; 14 | ValorRestante = ValorTotal; 15 | int contador = 0; 16 | do { 17 | NotaAtual = Notas[contador]; 18 | QuantidadeDeNotas = ValorRestante / NotaAtual; 19 | Console.WriteLine($"{QuantidadeDeNotas} nota(s) de R$ {NotaAtual},00"); 20 | ValorRestante = ValorRestante % NotaAtual; 21 | contador = contador + 1; 22 | } while (contador < Notas.Length); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /C#/Introdução a Programação com C#/distancia.cs: -------------------------------------------------------------------------------- 1 | // Distância 2 | 3 | /* Duas motos (X e Y) partem em uma mesma direção. A moto X sai com velocidade 4 | constante de 60 Km/h e a moto Y sai com velocidade constante de 90 Km/h. 5 | 6 | Em uma hora (60 minutos) a moto Y consegue se distanciar 30 quilômetros da 7 | moto X, ou seja, consegue se afastar um quilômetro a cada 2 minutos. 8 | 9 | O seu desafio é ler a distância (em Km) e calcular quanto tempo leva 10 | (em minutos) para a moto Y tomar essa distância da outra moto. 11 | 12 | - Entrada 13 | 14 | O arquivo de entrada contém um número inteiro K que representa a quantidade 15 | de quilômetro que que a moto Y deve estar da moto X. 16 | 17 | - Saída 18 | 19 | Imprima o tempo necessário para a moto Y ficar com a quantidade K de 20 | quilômetro da moto X, seguido da mensagem " minutos". */ 21 | 22 | using System; 23 | 24 | class Desafio { 25 | static void Main() { 26 | int quilometros = Int32.Parse(Console.ReadLine()); 27 | int minutos = quilometros * 2; 28 | 29 | Console.WriteLine(minutos + " minutos"); 30 | } 31 | } -------------------------------------------------------------------------------- /C#/Introdução a Programação com C#/dividindo-X-por-Y.cs: -------------------------------------------------------------------------------- 1 | // Dividindo X por Y 2 | 3 | /* 4 | Você terá o desafio de escrever um algoritmo que leia 2 números e imprima 5 | o resultado da divisão do primeiro pelo segundo. Caso não for possível mostre 6 | a mensagem “divisao impossivel” para os valores em questão. 7 | 8 | - Entrada 9 | 10 | A entrada contém um número inteiro N. Este N será a quantidade de pares de 11 | valores inteiros (X e Y) que serão lidos em seguida. 12 | 13 | - Saída 14 | 15 | Para cada caso mostre o resultado da divisão com um dígito após o ponto 16 | decimal, ou “divisao impossivel” caso não seja possível efetuar o cálculo. 17 | */ 18 | 19 | using System; 20 | 21 | class Desafio { 22 | static void Main() { 23 | int limit = Int32.Parse(Console.ReadLine()); 24 | 25 | for (int i = 0; i < limit; i++) { 26 | string[] line = Console.ReadLine().Split(" "); 27 | double X = double.Parse(line[0]); 28 | double Y = double.Parse(line[1]); 29 | 30 | if (Y == 0) { 31 | Console.WriteLine("divisao impossivel"); 32 | } else { 33 | double divisao = X / Y; 34 | 35 | if (divisao < 0 && (divisao.ToString("N1") == "0.0")) 36 | Console.WriteLine("-0.0"); 37 | else 38 | Console.WriteLine(divisao.ToString("N1")); 39 | } 40 | } 41 | } 42 | } -------------------------------------------------------------------------------- /C#/Introdução a Programação com C#/media2.cs: -------------------------------------------------------------------------------- 1 | // Média 2 2 | /* 3 | Leia 3 valores, no caso, variáveis A, B e C, que são as três notas de um aluno. 4 | A seguir, calcule a média do aluno, sabendo que a nota A tem peso 2, a nota B 5 | tem peso 3 e a nota C tem peso 5. Considere que cada nota pode ir de 0 até 6 | 10.0, sempre com uma casa decimal. 7 | 8 | - Entrada 9 | 10 | O arquivo de entrada contém 3 valores com uma casa decimal, de dupla precisão 11 | (double). 12 | 13 | - Saída 14 | 15 | Imprima a variável MEDIA conforme exemplo abaixo, com 1 dígito após o ponto 16 | decimal e com um espaço em branco antes e depois da igualdade. Assim como 17 | todos os problemas, não esqueça de imprimir o fim de linha após o resultado, 18 | caso contrário, você receberá "Presentation Error". 19 | */ 20 | 21 | using System; 22 | 23 | namespace Start { 24 | class Program { 25 | static void Main(string[] args) { 26 | double A, B, C; 27 | 28 | A = double.Parse(Console.ReadLine()); 29 | B = double.Parse(Console.ReadLine()); 30 | C = double.Parse(Console.ReadLine()); 31 | 32 | Console.WriteLine("MEDIA = " + String.Format("{0:0.0}", ((A * 2) + (B * 3) + (C * 5)) / (2 + 3 + 5))); 33 | Console.ReadKey(); 34 | } 35 | } 36 | } -------------------------------------------------------------------------------- /C#/Introdução a Programação com C#/positivos-media.cs: -------------------------------------------------------------------------------- 1 | // Positivos e Média 2 | 3 | /* 4 | Leia 6 valores. Em seguida, mostre quantos destes valores digitados foram 5 | positivos. Na próxima linha, deve-se mostrar a média de todos os valores 6 | positivos digitados, com um dígito após o ponto decimal. 7 | 8 | - Entrada 9 | 10 | A entrada contém 6 números que podem ser valores inteiros ou de ponto 11 | flutuante. Pelo menos um destes números será positivo. 12 | 13 | - Saída 14 | 15 | O primeiro valor de saída é a quantidade de valores positivos. A próxima linha 16 | deve mostrar a média dos valores positivos digitados. 17 | */ 18 | 19 | using System; 20 | 21 | class Media { 22 | public static void Main() { 23 | double a, b = 0.0, avg; 24 | int positivo = 0; 25 | 26 | for (int i = 0; i < 6; i++) { 27 | a = double.Parse(Console.ReadLine()); 28 | 29 | if (a > 0.0) { 30 | positivo += 1; 31 | b += a; 32 | } 33 | } 34 | 35 | avg = (b / positivo); 36 | Console.WriteLine("{0} valores positivos", positivo); 37 | Console.WriteLine("{0}", Math.Round(avg, 1)); 38 | } 39 | } -------------------------------------------------------------------------------- /C#/Introdução a Programação com C#/sequencia-logica.cs: -------------------------------------------------------------------------------- 1 | // Sequência Lógica 2 | 3 | /* 4 | Desenvolva um programa capaz de ler um valor inteiro N. N * 2 linhas de saída 5 | vão ser apresentadas na execução do programa, seguindo a lógica do exemplo 6 | mais abaixo. Para os valores com mais de seis dígitos, todos os dígitos devem 7 | ser apresentados. 8 | 9 | - Entrada 10 | 11 | O arquivo de entrada contém um número inteiro positivo N (1 < N < 1000). 12 | 13 | - Saída 14 | 15 | Imprima a saída conforme o exemplo fornecido. 16 | */ 17 | 18 | using System; 19 | 20 | class Program { 21 | static void Main(string[] args) { 22 | int n = Convert.ToInt32(Console.ReadLine()); 23 | 24 | for (int i = 1; i <= n; ++i) { 25 | Console.WriteLine(Math.Pow(i, 1) + " " + Math.Pow(i, 2) + " " + Math.Pow(i, 3)); 26 | Console.WriteLine(Math.Pow(i, 1) + " " + (Math.Pow(i, 2) + 1) + " " + (Math.Pow(i, 3) + 1)); 27 | } 28 | } 29 | } -------------------------------------------------------------------------------- /C#/Introdução a Resolução de Desafios com C#/NumerosImpares.cs: -------------------------------------------------------------------------------- 1 | // Números Ímpares 2 | 3 | /* 4 | Leia um valor inteiro X (1 <= X <= 1000). Em seguida mostre os ímpares de 1 5 | até X, um valor por linha, inclusive o X, se for o caso. 6 | 7 | • Entrada 8 | 9 | O arquivo de entrada contém 1 valor inteiro qualquer. 10 | 11 | • Saída 12 | 13 | Imprima todos os valores ímpares de 1 até X, inclusive X, se for o caso. 14 | */ 15 | 16 | using System; 17 | 18 | class MinhaClasse { 19 | static void Main(string[] args) { 20 | string[] valores = Console.ReadLine().Split(' '); 21 | int A = int.Parse(valores[0]); 22 | int B = int.Parse(valores[1]); 23 | 24 | if (A % B == 0 || B % A == 0 ) { 25 | Console.WriteLine("Sao Multiplos"); 26 | } 27 | else { 28 | Console.WriteLine("Nao sao Multiplos"); 29 | } 30 | } 31 | } -------------------------------------------------------------------------------- /C#/Praticando programação em C#/coordenadas-de-um-ponto.cs: -------------------------------------------------------------------------------- 1 | // Coordenadas de um Ponto 2 | 3 | /* 4 | Leia 2 valores com uma casa decimal (x e y), que devem representar as 5 | coordenadas de um ponto em um plano. A seguir, determine qual o quadrante ao 6 | qual pertence o ponto, ou se está sobre um dos eixos cartesianos ou na origem 7 | (x = y = 0). 8 | 9 | Se o ponto estiver na origem, escreva a mensagem “Origem”. 10 | 11 | Se o ponto estiver sobre um dos eixos escreva “Eixo X” ou “Eixo Y”, conforme 12 | for a situação. 13 | 14 | - Entrada 15 | 16 | A entrada contem as coordenadas de um ponto. 17 | 18 | - Saída 19 | 20 | A saída deve apresentar o quadrante em que o ponto se encontra. 21 | */ 22 | 23 | using System; 24 | 25 | class URI { 26 | static void Main(string[] args) { 27 | string[] input = Console.ReadLine().Split(); 28 | double X = double.Parse(input[0]); 29 | double Y = double.Parse(input[1]); 30 | 31 | if (X == 0 && Y == 0) { 32 | Console.WriteLine("Origem"); 33 | } else if (X == 0 && Y != 0) { 34 | Console.WriteLine("Eixo Y"); 35 | } else if (X != 0 && Y == 0) { 36 | Console.WriteLine("Eixo X"); 37 | } else if (X > 0 && Y > 0) { 38 | Console.WriteLine("Q1"); 39 | } else if (X < 0 && Y > 0) { 40 | Console.WriteLine("Q2"); 41 | } else if (X < 0 && Y < 0) { 42 | Console.WriteLine("Q3"); 43 | } else if (X > 0 && Y < 0) { 44 | Console.WriteLine("Q4"); 45 | } else { 46 | throw new ArgumentOutOfRangeException(); 47 | } 48 | } 49 | } -------------------------------------------------------------------------------- /C#/Primeiros desafios com C#/QuantidadeNumerosPositivos.cs: -------------------------------------------------------------------------------- 1 | // Quantidade de Números Positivos 2 | 3 | /* 4 | Crie um programa que leia 6 valores. Você poderá receber valores negativos e/ou 5 | positivos como entrada, devendo desconsiderar os valores nulos. Em seguida, 6 | apresente a quantidade de valores positivos digitados. 7 | 8 | • Entrada 9 | 10 | Você receberá seis valores, negativos e/ou positivos. 11 | 12 | • Saída 13 | 14 | Exiba uma mensagem dizendo quantos valores positivos foram lidos assim como é 15 | exibido abaixo no exemplo de saída. Não esqueça da mensagem "valores positivos" 16 | ao final. 17 | */ 18 | 19 | using System; 20 | 21 | class Program { 22 | static void Main(string[] args) { 23 | double valor1 = double.Parse(Console.ReadLine()); 24 | double valor2 = double.Parse(Console.ReadLine()); 25 | double valor3 = double.Parse(Console.ReadLine()); 26 | double valor4 = double.Parse(Console.ReadLine()); 27 | double valor5 = double.Parse(Console.ReadLine()); 28 | double valor6 = double.Parse(Console.ReadLine()); 29 | int ehPositivo = 0; 30 | 31 | if (valor1 > 0.0) { 32 | ehPositivo += 1; 33 | } 34 | 35 | if (valor2 > 0.0) { 36 | ehPositivo += 1; 37 | } 38 | 39 | if (valor3 > 0.0) { 40 | ehPositivo += 1; 41 | } 42 | 43 | if (valor4 > 0.0) { 44 | ehPositivo += 1; 45 | } 46 | 47 | if (valor5 > 0.0) { 48 | ehPositivo += 1; 49 | } 50 | 51 | if (valor6 > 0.0) { 52 | ehPositivo += 1; 53 | } 54 | 55 | Console.WriteLine(ehPositivo + " valores positivos"); 56 | } 57 | } -------------------------------------------------------------------------------- /C#/Primeiros desafios em C#/Diferenca.cs: -------------------------------------------------------------------------------- 1 | // Diferença 2 | 3 | /* 4 | Leia quatro valores inteiros A, B, C e D. A seguir, calcule e mostre a diferença 5 | do produto de A e B pelo produto de C e D segundo a fórmula: DIFERENCA = (A * B - C * D). 6 | 7 | - Entrada 8 | 9 | O arquivo de entrada contém 4 valores inteiros. 10 | 11 | - Saída 12 | 13 | Imprima a mensagem DIFERENCA com todas as letras maiúsculas, conforme exemplo 14 | abaixo, com um espaço em branco antes e depois da igualdade. 15 | */ 16 | 17 | using System; 18 | 19 | namespace Desafio { 20 | class Program { 21 | static void Main(string[] args) { 22 | int A, B, C, D; 23 | 24 | A = int.Parse(Console.ReadLine()); 25 | B = int.Parse(Console.ReadLine()); 26 | C = int.Parse(Console.ReadLine()); 27 | D = int.Parse(Console.ReadLine()); 28 | 29 | Console.WriteLine("DIFERENCA = " + (A * B - C * D)); 30 | Console.ReadKey(); 31 | } 32 | } 33 | } -------------------------------------------------------------------------------- /C#/Primeiros programas em C#/area-circulo.cs: -------------------------------------------------------------------------------- 1 | // Área do Círculo 2 | 3 | /* 4 | A fórmula para calcular a área de uma circunferência é: area = π . raio2. 5 | Considerando para este problema que π = 3.14159: 6 | 7 | - Efetue o cálculo da área, elevando o valor de raio ao quadrado e multiplicando 8 | por π. 9 | 10 | - Entrada 11 | 12 | A entrada contém um valor de ponto flutuante (dupla precisão), no caso, a 13 | variável raio. 14 | 15 | - Saída 16 | 17 | Apresentar a mensagem "A=" seguido pelo valor da variável area, conforme exemplo 18 | abaixo, com 4 casas após o ponto decimal. Utilize variáveis de dupla precisão 19 | (double). Como todos os problemas, não esqueça de imprimir o fim de linha após 20 | o resultado, caso contrário, você receberá "Presentation Error". 21 | */ 22 | 23 | using System; 24 | 25 | class Classe { 26 | static void Main(string[] args) { 27 | double pi = 3.14159, r; 28 | 29 | r = Convert.ToDouble(Console.ReadLine()); 30 | 31 | Console.WriteLine("A=" + (pi * (r * r)).ToString("0.0000")); 32 | } 33 | } -------------------------------------------------------------------------------- /C#/Primeiros programas em C#/multiplos.cs: -------------------------------------------------------------------------------- 1 | // Múltiplos 2 | 3 | /* 4 | Leia 2 valores inteiros (A e B). Após, o programa deve mostrar uma mensagem 5 | "Sao Multiplos" ou "Nao sao Multiplos", indicando se os valores lidos são 6 | múltiplos entre si. 7 | 8 | - Entrada 9 | 10 | A entrada contém valores inteiros. 11 | 12 | - Saída 13 | 14 | A saída deve conter uma das mensagens conforme descrito acima. 15 | */ 16 | 17 | using System; 18 | 19 | class MinhaClasse { 20 | static void Main(string[] args) { 21 | string[] valores = Console.ReadLine().Split(' '); 22 | int A = int.Parse(valores[0]); 23 | int B = int.Parse(valores[1]); 24 | 25 | if (A % B == 0 || B % A == 0 ) { 26 | Console.WriteLine("Sao Multiplos"); 27 | } 28 | else { 29 | Console.WriteLine("Nao sao Multiplos"); 30 | } 31 | } 32 | } -------------------------------------------------------------------------------- /C#/Primeiros programas em C#/soma-simples.cs: -------------------------------------------------------------------------------- 1 | // Soma Simples 2 | 3 | /* 4 | Leia dois valores inteiros identificados como variáveis A e B. Calcule a soma 5 | entre elas e chame essa variável de SOMA. 6 | A seguir escreva o valor desta variável. 7 | 8 | - Entrada 9 | 10 | O arquivo de entrada contém 2 valores inteiros. 11 | 12 | - Saída 13 | 14 | Imprima a variável SOMA com todas as letras maiúsculas, inserindo um espaço em 15 | branco antes e depois do símbolo de igualdade, seguido pelo valor 16 | correspondente à soma de A e B. 17 | */ 18 | 19 | using System; 20 | 21 | class Program { 22 | static void Main(string[] args) { 23 | int A = Convert.ToInt32(Console.ReadLine()); 24 | int B = Convert.ToInt32(Console.ReadLine()); 25 | 26 | int SOMA = A + B; 27 | 28 | Console.WriteLine("SOMA = {0}", SOMA); 29 | } 30 | } -------------------------------------------------------------------------------- /C#/Programando em C#/QuadradoDePares.cs: -------------------------------------------------------------------------------- 1 | // Quadrado de Pares 2 | 3 | /* 4 | Leia um valor inteiro N. Apresente o quadrado de cada um dos valores pares, de 1 5 | até N, inclusive N, se for o caso. 6 | 7 | - Entrada 8 | 9 | A entrada contém um valor inteiro N (5 < N < 2000). 10 | 11 | - Saída 12 | 13 | Imprima o quadrado de cada um dos valores pares, de 1 até N, conforme o exemplo 14 | abaixo. 15 | 16 | Tome cuidado! Algumas linguagens tem por padrão apresentarem como saída 1e+006 ao 17 | invés de 1000000 o que ocasionará resposta errada. Neste caso, configure a precisão 18 | adequadamente para que isso não ocorra. 19 | */ 20 | 21 | using System; 22 | 23 | class DIO { 24 | static void Main(string[] args) { 25 | int n = Convert.ToInt32(Console.ReadLine()); 26 | long r; 27 | 28 | for (int p = 2; p <= n; p+=2) { 29 | r = (p * p); 30 | Console.WriteLine($"{p}^2 = {r}"); 31 | } 32 | } 33 | } -------------------------------------------------------------------------------- /C#/Programando em C#/SequenciaIJ2.cs: -------------------------------------------------------------------------------- 1 | // Sequência IJ 2 2 | 3 | /* 4 | Você deve fazer um programa que apresente a sequencia conforme o exemplo abaixo. 5 | 6 | - Entrada 7 | 8 | Não há nenhuma entrada neste problema. 9 | 10 | - Saída 11 | 12 | Imprima a sequencia conforme exemplo abaixo 13 | */ 14 | 15 | using System; 16 | 17 | class DIO { 18 | static void Main(string[] args) { 19 | for (int i = 1; i <= 9; i+=2) { 20 | for(int j = 7; j >= 5; j--) { 21 | Console.WriteLine($"I={i} J={j}"); 22 | } 23 | } 24 | } 25 | } -------------------------------------------------------------------------------- /C#/Programando em C#/SequenciaS.cs: -------------------------------------------------------------------------------- 1 | // Sequência S 2 | 3 | /* 4 | Escreva um algoritmo para calcular e escrever o valor de S, sendo S dado pela 5 | fórmula: S = 1 + 1/2 + 1/3 + … + 1/100 6 | 7 | - Entrada 8 | 9 | Não há nenhuma entrada neste problema. 10 | 11 | - Saída 12 | 13 | A saída contém um valor correspondente ao valor de S. 14 | O valor deve ser impresso com dois dígitos após o ponto decimal. 15 | */ 16 | 17 | using System; 18 | 19 | class DIO { 20 | static void Main(string[] args) { 21 | double a, c, S= 0; 22 | 23 | for (a = 1; a <= 100; a++) { 24 | c = 1 / a; 25 | S += c; 26 | } 27 | 28 | var x = Math.Round(S,2); 29 | Console.WriteLine(x); 30 | } 31 | } -------------------------------------------------------------------------------- /C#/Programando em C#/SucessorPar.cs: -------------------------------------------------------------------------------- 1 | // Sucessor Par 2 | 3 | /* 4 | Para se preparar para os outros problemas, vamos fazer um teste. Dado um número X, 5 | retorne o menor número par maior do que X. 6 | 7 | - Entrada 8 | 9 | Uma linha contendo um número 0 < X < 107. 10 | 11 | - Saída 12 | 13 | Uma linha contendo a resposta do problema. 14 | */ 15 | 16 | using System; 17 | 18 | class DIO { 19 | static void Main(string[] args) { 20 | int x = int.Parse(Console.ReadLine()); 21 | 22 | x += (x % 2 == 0 ? 2 : 1); 23 | Console.WriteLine(x); 24 | } 25 | } -------------------------------------------------------------------------------- /C#/Programando em C#/VaiTerCopa.cs: -------------------------------------------------------------------------------- 1 | // Vai ter Copa? 2 | 3 | /* 4 | Kluper é o país sede da copa do mundo. Porém, há muitas pessoas protestando contra 5 | o governo. Em redes sociais é possível ver pessoas afirmando que não vai ter copa 6 | devido aos protestos e insatisfação política 7 | 8 | Mas esses rumores de que não haverá copa são totalmente falsos, e o governo já 9 | avisou: vai ter copa sim! 10 | 11 | - Entrada 12 | 13 | A entrada contém vários casos de teste. Cada caso de teste consiste de uma linha 14 | contendo o número N de reclamações sobre a copa encaminhadas para o governo 15 | (0 ≤ N ≤ 100). 16 | 17 | - Saída 18 | 19 | Para cada teste, a saída consiste de uma linha dizendo "vai ter copa!" caso não 20 | haja reclamações para o governo. Caso haja reclamações, a saída deverá dizer "vai 21 | ter duas!". 22 | */ 23 | 24 | using System; 25 | 26 | class DIO { 27 | static void Main(string[] args) { 28 | string str; 29 | 30 | while((str = Console.ReadLine())!= null) { 31 | int x = int.Parse(str); 32 | 33 | if (x == 0) { 34 | Console.WriteLine("vai ter copa!"); 35 | } else { 36 | Console.WriteLine("vai ter duas!"); 37 | } 38 | } 39 | } 40 | } -------------------------------------------------------------------------------- /C#/Resolvendo Algoritmos/conversao-de-tempo.cs: -------------------------------------------------------------------------------- 1 | // Conversão de Tempo 2 | 3 | /* Você terá o desafio de ler um valor inteiro, que é o tempo de duração em 4 | segundos de um determinado evento em uma loja, e informe-o expresso no formato 5 | horas:minutos:segundos. 6 | 7 | - Entrada 8 | 9 | O arquivo de entrada contém um valor inteiro N. 10 | 11 | - Saída 12 | 13 | Imprima o tempo lido no arquivo de entrada (segundos), convertido para 14 | horas:minutos:segundos, conforme exemplo fornecido. */ 15 | 16 | using System; 17 | 18 | class ConversaoDeTempo { 19 | static void Main(string[] args) { 20 | var tempo = int.Parse(Console.ReadLine()); 21 | var horas = (tempo / 3600); 22 | var minutos = (tempo % 3600) / 60; 23 | var segundos = (tempo % 3600) % 60; 24 | 25 | Console.WriteLine($"{horas}:{minutos}:{segundos}"); 26 | } 27 | } -------------------------------------------------------------------------------- /C#/Resolvendo Algoritmos/idade-em-dias.cs: -------------------------------------------------------------------------------- 1 | // Idade em Dias 2 | 3 | /* Você terá o desafio de ler um valor inteiro correspondente à idade de uma 4 | pessoa em dias e informe-a em anos, meses e dias 5 | 6 | Obs.: apenas para facilitar o cálculo, considere todo ano com 365 dias e todo 7 | mês com 30 dias. Nos casos de teste nunca haverá uma situação que permite 12 8 | meses e alguns dias, como 360, 363 ou 364. 9 | 10 | - Entrada 11 | 12 | O arquivo de entrada contém um valor inteiro. 13 | 14 | - Saída 15 | 16 | Imprima a saída conforme exemplo fornecido. */ 17 | 18 | using System; 19 | 20 | class IdadeEmDias { 21 | public static void Main (string[] args) { 22 | var idadeEmDias = int.Parse(Console.ReadLine()); 23 | var anos = (idadeEmDias / 365); 24 | var meses = (idadeEmDias % 365) / 30; 25 | var dias = (idadeEmDias % 365) % 30; 26 | 27 | Console.WriteLine($"{anos} ano(s)\n{meses} mes(es)\n{dias} dia(s)"); 28 | } 29 | } -------------------------------------------------------------------------------- /C#/Resolvendo Desafios Básicos em C#/GuilhermeESuasPipas.cs: -------------------------------------------------------------------------------- 1 | // Guilherme e suas Pipas 2 | 3 | /* 4 | Guilherme adora brincar com pipas, pipas de várias cores, formas e tamanhos. 5 | Ele tem percebido que para as pipas possuírem maior estabilidade, e dessa forma 6 | voarem mais alto, elas devem possuir um barbante bem esticado ligando todos os 7 | pares de pontas não vizinhas. 8 | 9 | Apesar de ser uma criança bastante criativa e astuta, Guilherme não sabe como 10 | determinar a quantidade de barbantes que ele terá que utilizar para tornar uma 11 | pipa de n lados, estável. Você pode ajudá-lo?. 12 | 13 | - Entrada 14 | 15 | A entrada será composta por uma única linha, que contém um inteiro 3 ≤ n ≤ 105, 16 | representando o número de lados da pipa. 17 | 18 | - Saída 19 | 20 | Imprima um número inteiro, que será a quantidade de barbantes que Guilherme 21 | terá que utilizar para tornar a pipa de n lados estável. 22 | */ 23 | 24 | using System; 25 | 26 | class TESTE { 27 | static void Main(string[] args) { 28 | long N = long.Parse(Console.ReadLine()); 29 | long resposta = (N * (N - 3)) / 2; 30 | 31 | Console.WriteLine(resposta); 32 | } 33 | } -------------------------------------------------------------------------------- /C#/Resolvendo Desafios Básicos em C#/MaiorEPosicao.cs: -------------------------------------------------------------------------------- 1 | // Maior e Posição 2 | 3 | /* 4 | Você recebeu o desafio de ler 100 valores inteiros. Apresente então o maior 5 | valor lido e a posição dentre os 100 valores lidos. 6 | 7 | - Entrada 8 | 9 | O arquivo de entrada contém 100 números inteiros, positivos e distintos. 10 | 11 | - Saída 12 | 13 | Apresente o maior valor lido e a posição de entrada, conforme exemplo abaixo. 14 | */ 15 | 16 | using System; 17 | 18 | class TESTE { 19 | static void Main(string[] args) { 20 | int n; 21 | int maior = 0; 22 | int posicao = 0; 23 | 24 | for (int i = 1; i <= 100 ; i++) { 25 | n = Convert.ToInt32(Console.ReadLine()); 26 | 27 | if (n > maior) { 28 | maior = n; 29 | posicao = i; 30 | } 31 | } 32 | Console.WriteLine(maior); 33 | Console.WriteLine(posicao); 34 | } 35 | } -------------------------------------------------------------------------------- /C#/Resolvendo Desafios Básicos em C#/SomaSeImparesConsecutivosI.cs: -------------------------------------------------------------------------------- 1 | // Soma de Ímpares Consecutivos I 2 | 3 | /* 4 | Leia 2 valores inteiros X e Y. A seguir, calcule e mostre a soma dos números 5 | impares entre eles. 6 | 7 | - Entrada 8 | 9 | O arquivo de entrada contém dois valores inteiros. 10 | 11 | - Saída 12 | 13 | O programa deve imprimir um valor inteiro. Este valor é a soma dos valores 14 | ímpares que estão entre os valores fornecidos na entrada que deverá caber em 15 | um inteiro. 16 | */ 17 | 18 | using System; 19 | 20 | namespace TESTE { 21 | class Program { 22 | static void Main(string[] args) { 23 | int x, y, min, max, soma; 24 | 25 | x = int.Parse(Console.ReadLine()); 26 | y = int.Parse(Console.ReadLine()); 27 | 28 | if (x < y) { 29 | min = x; 30 | max = y; 31 | } else { 32 | min = y; 33 | max = x; 34 | } 35 | 36 | soma = 0; 37 | 38 | for (int i = min+1; i < max; i++) { 39 | if (i % 2 != 0) { 40 | soma += i; 41 | } 42 | } 43 | 44 | Console.WriteLine(soma); 45 | } 46 | } 47 | } -------------------------------------------------------------------------------- /C#/Resolvendo Desafios Iniciais em C#/HoHoHo.cs: -------------------------------------------------------------------------------- 1 | // Ho Ho Ho 2 | 3 | /* 4 | Papai Noel está brincando com seus duendes para entretê-los durante a véspera 5 | do Natal. A brincadeira consiste nos elfos escreverem números em pedaços de 6 | papel e colocarem no gorro do Papai Noel. Após todos terminarem de colocar os 7 | números Noel sorteia um papel e aquele número representa quantos "Ho" o Noel 8 | deve falar. 9 | 10 | Seu trabalho é ajudar o Papai Noel montando um problema que mostre todos os 11 | "Ho" que ele deve falar dado o número sorteado. 12 | 13 | - Entrada 14 | 15 | A entrada é composta por um único inteiro N (0 < N ≤ 106) representando quantos 16 | "Ho" serão falados por Noel. 17 | 18 | - Saída 19 | 20 | A saída é composta por todos "Ho" que Papai Noel deve falar separados por um 21 | espaço. Após o último "Ho" deve ser apresentado um "!" encerrando o programa. 22 | */ 23 | 24 | using System; 25 | 26 | namespace _52._36_URI_1759 { 27 | class Program { 28 | static void Main(string[] args) { 29 | int N = int.Parse(Console.ReadLine()); 30 | 31 | for (int i = 0; i < N-1; i++) { 32 | Console.Write("Ho "); 33 | } 34 | Console.WriteLine("Ho!"); 35 | } 36 | } 37 | } -------------------------------------------------------------------------------- /C#/Resolvendo Desafios Iniciais em C#/Pneu.cs: -------------------------------------------------------------------------------- 1 | // Pneu 2 | 3 | /* 4 | Calibrar os pneus do carro deve ser uma tarefa cotidiana de todos os motoristas. 5 | Para isto, os postos de gasolina possuem uma bomba de ar. A maioria das bombas 6 | atuais são eletrônicas, permitindo que o motorista indique a pressão desejada 7 | num teclado. Ao ser ligada ao pneu, a bomba primeiro lê a pressão atual e 8 | calcula a diferença de pressão entre a desejada e a lida. Com esta diferença 9 | ela esvazia ou enche o pneu para chegar na pressão correta. 10 | 11 | Sua ajuda foi requisitada para desenvolver o programa da próxima bomba da 12 | SBC - Sistemas de Bombas Computadorizadas. 13 | 14 | Escreva um programa que, dada a pressão desejada digitada pelo motorista e a 15 | pressão do pneu lida pela bomba, indica a diferença entre a pressão desejada e 16 | a pressão lida. 17 | 18 | - Entrada 19 | 20 | A primeira linha da entrada contém um inteiro N que indica a pressão desejada 21 | pelo motorista (1 ≤ N ≤ 40). A segunda linha contém um inteiro M que indica a 22 | pressão lida pela bomba (1 ≤ M ≤ 40). 23 | 24 | - Saída 25 | 26 | Seu programa deve imprimir uma única linha, contendo a diferença entre a 27 | pressão desejada e a pressão lida. 28 | */ 29 | 30 | using System; 31 | 32 | class TESTE { 33 | static void Main () { 34 | var A = int.Parse(Console.ReadLine()); 35 | var B = int.Parse(Console.ReadLine()); 36 | 37 | Console.Write(A - B); 38 | } 39 | } -------------------------------------------------------------------------------- /C#/Resolvendo Desafios Iniciais em C#/Quadrante.cs: -------------------------------------------------------------------------------- 1 | // Quadrante 2 | 3 | /* 4 | Desenvolva um programa para ler as coordenadas (M,N) de uma quantidade 5 | indeterminada de pontos no sistema cartesiano. Para cada ponto escrever o 6 | quadrante a que ele pertence. O algoritmo será encerrado quando pelo menos uma 7 | de duas coordenadas for NULA (nesta situação sem escrever mensagem alguma). 8 | 9 | - Entrada 10 | 11 | A entrada contém vários casos de teste. Cada caso de teste contém 2 valores 12 | inteiros. 13 | 14 | - Saída 15 | 16 | Para cada caso de teste mostre em qual quadrante do sistema cartesiano se 17 | encontra a coordenada lida, conforme o exemplo. 18 | */ 19 | 20 | using System; 21 | 22 | class TESTE { 23 | public static void Main() { 24 | int X, Y; 25 | 26 | while (true) { 27 | string[] s = Console.ReadLine().Split(' '); 28 | X = int.Parse(s[0]); 29 | Y = int.Parse(s[1]); 30 | 31 | if (X == 0 || Y == 0) 32 | break; 33 | else if (X > 0 && Y > 0) 34 | Console.WriteLine("primeiro"); 35 | else if (X > 0 && Y < 0) 36 | Console.WriteLine("quarto"); 37 | else if (X < 0 && Y < 0) 38 | Console.WriteLine("terceiro"); 39 | else if (X < 0 && Y > 0) 40 | Console.WriteLine("segundo"); 41 | } 42 | Console.ReadLine(); 43 | } 44 | } -------------------------------------------------------------------------------- /C#/Resolvendo desafios Intermediários em C#/Intervalo2.cs: -------------------------------------------------------------------------------- 1 | // Intervalo 2 2 | 3 | /* 4 | Leia um valor inteiro N. Este valor será a quantidade de valores inteiros X que 5 | serão lidos em seguida. 6 | Mostre quantos destes valores X estão dentro do intervalo [10,20] e quantos 7 | estão fora do intervalo, mostrando essas informações. 8 | 9 | - Entrada 10 | 11 | A primeira linha da entrada contém um valor inteiro N (N < 10000), que indica 12 | o número de casos de teste. 13 | Cada caso de teste a seguir é um valor inteiro X (-107 < X <107). 14 | 15 | - Saída 16 | 17 | Para cada caso, imprima quantos números estão dentro (in) e quantos valores 18 | estão fora (out) do intervalo. 19 | */ 20 | 21 | using System; 22 | 23 | class TESTE { 24 | public static void Main() { 25 | int tc, a, i; 26 | int Interval = 0; 27 | int outInterval = 0; 28 | tc = int.Parse(Console.ReadLine()); 29 | 30 | for (i = 0; i < tc; i++) { 31 | a = int.Parse(Console.ReadLine()); 32 | 33 | if (a >= 10 && a <= 20) { 34 | Interval++; 35 | } else { 36 | outInterval++; 37 | } 38 | } 39 | Console.WriteLine("{0} in", Interval); 40 | Console.WriteLine("{0} out", outInterval); 41 | } 42 | } -------------------------------------------------------------------------------- /C#/Resolvendo desafios Intermediários em C#/PUM.cs: -------------------------------------------------------------------------------- 1 | // PUM 2 | 3 | /* 4 | Desenvolva um programa que leia um valor inteiro N. Este N refere-se à 5 | quantidade de linhas de saída que serão apresentadas na execução do programa. 6 | 7 | - Entrada 8 | 9 | O arquivo de entrada contém um número inteiro positivo N. 10 | 11 | - Saída 12 | 13 | Imprima a saída conforme o exemplo fornecido. 14 | */ 15 | 16 | using System; 17 | 18 | namespace TESTE { 19 | class Program { 20 | static void Main(string[] args) { 21 | int N = int.Parse(Console.ReadLine()); 22 | 23 | int primeiro = 1; 24 | for (int i = 1; i <= N; i++) { 25 | Console.WriteLine($"{primeiro} {primeiro+1} {primeiro+2} PUM"); 26 | primeiro+=4; 27 | } 28 | } 29 | } 30 | } -------------------------------------------------------------------------------- /C#/Resolvendo desafios Intermediários em C#/PoligonosRegularesSimples.cs: -------------------------------------------------------------------------------- 1 | // Polígonos Regulares Simples 2 | 3 | /* 4 | Na geometria Euclidiana, um polígono regular é um polígono em que todos os 5 | ângulos são iguais e todos os lados tem o mesmo comprimento. Um polígono 6 | simples é aquele cujos segmentos de reta não se interceptam. Abaixo pode-se ver 7 | vários mosaicos feitos por polígonos regulares. 8 | 9 | vide imagem em assets 10 | 11 | Você deve escrever um programa que, dados o número e o comprimento dos lados 12 | de um polígono regular, mostre seu perímetro. 13 | 14 | - Entrada 15 | 16 | A entrada tem dois inteiros positivos: N e L, que são, respectivamente, o 17 | número de lados e o comprimento de cada lado de um polígono regular 18 | (3 ≤ N ≤ 1000000 and 1 ≤ L ≤ 4000). 19 | 20 | - Saída 21 | 22 | A saída é o perímetro P do polígono regular em uma única linha. 23 | */ 24 | 25 | using System; 26 | 27 | class Problem { 28 | static void Main(string[] args) { 29 | string[] v = Console.ReadLine().Split(); 30 | 31 | Console.WriteLine(int.Parse(v[0]) * int.Parse(v[1])); 32 | } 33 | } -------------------------------------------------------------------------------- /C#/Solucionando desafios intermediários em C#/formula-de-bhaskara.cs: -------------------------------------------------------------------------------- 1 | // Fórmula de Bhaskara 2 | 3 | /* 4 | Leia 3 valores de ponto flutuante e efetue o cálculo das raízes da equação de 5 | Bhaskara. Se não for possível calcular as raízes, mostre a mensagem 6 | correspondente “Impossivel calcular”, caso haja uma divisão por 0 ou raiz de 7 | número negativo. 8 | 9 | - Entrada 10 | 11 | Leia três valores de ponto flutuante (double) A, B e C. 12 | 13 | - Saída 14 | 15 | Se não houver possibilidade de calcular as raízes, apresente a mensagem 16 | "Impossivel calcular". Caso contrário, imprima o resultado das raízes com 5 17 | dígitos após o ponto, com uma mensagem correspondente conforme exemplo abaixo. 18 | Imprima sempre o final de linha após cada mensagem. 19 | */ 20 | 21 | using System; 22 | 23 | class minhaClasse { 24 | static void Main(string[] args) { 25 | double a, b, c, delta, r1, r2; 26 | string[] valor = Console.ReadLine().Split(); 27 | 28 | a = Convert.ToDouble(valor[0]); 29 | b = Convert.ToDouble(valor[1]); 30 | c = Convert.ToDouble(valor[2]); 31 | delta = (Math.Pow(b, 2) - (4 * a * c)); 32 | r1 = (-b + Math.Sqrt(delta)) / (2 * a); 33 | r2 = (-b - Math.Sqrt(delta)) / (2 * a); 34 | 35 | if (a != 0 && delta > 0) { 36 | Console.WriteLine($"R1 = {r1.ToString("F5")}"); 37 | Console.WriteLine($"R2 = {r2.ToString("F5")}"); 38 | } else { 39 | Console.WriteLine("Impossivel calcular"); 40 | } 41 | } 42 | } -------------------------------------------------------------------------------- /C#/Solucionando desafios intermediários em C#/teste-de-selecao-1.cs: -------------------------------------------------------------------------------- 1 | // Teste de Seleção 1 2 | 3 | /* 4 | Leia 4 valores inteiros A, B, C e D. Com base nisso, se o valor de B for maior 5 | do que de C e se D for maior do que A, e a soma de C com D for maior que a soma 6 | de A e B e se tanto C quanto D forem positivos e, ainda, se a variável A for 7 | par, escreva a mensagem "Valores aceitos", senão escrever "Valores nao aceitos". 8 | 9 | - Entrada 10 | 11 | Quatro números inteiros A, B, C e D. 12 | 13 | - Saída 14 | 15 | Imprima a mensagem corretamente esperada pela validação dos valores. 16 | */ 17 | 18 | using System; 19 | 20 | class minhaClasse { 21 | static void Main(string[] args) { 22 | string [] selections = Console.ReadLine().Split(' '); 23 | int A = int.Parse(selections[0]); 24 | int B = int.Parse(selections[1]); 25 | int C = int.Parse(selections[2]); 26 | int D = int.Parse(selections[3]); 27 | 28 | if (B>C && D>A && C+D > A+B && C>0 && D>0 && (A % 2 == 0 )) { 29 | Console.WriteLine("Valores aceitos"); 30 | } else { 31 | Console.WriteLine("Valores nao aceitos"); 32 | } 33 | } 34 | } -------------------------------------------------------------------------------- /C#/Solucionando desafios intermediários em C#/triangulo.cs: -------------------------------------------------------------------------------- 1 | // Triângulo 2 | 3 | /* 4 | Leia 3 valores reais (A, B e C) e verifique se eles formam ou não um triângulo. 5 | Em caso positivo, calcule o perímetro do triângulo e apresente a mensagem: 6 | Perimetro = XX.X 7 | 8 | Em caso negativo, calcule a área do trapézio que tem A e B como base e C como 9 | altura, mostrando a mensagem 10 | Area = XX.X 11 | 12 | - Entrada 13 | 14 | A entrada contém três valores reais. 15 | 16 | - Saída 17 | 18 | O resultado deve ser apresentado com uma casa decimal. 19 | */ 20 | 21 | using System; 22 | 23 | class minhaClasse { 24 | static void Main(string[] args) { 25 | double a, b, c; 26 | string[] valor = Console.ReadLine().Split(); 27 | 28 | a = Convert.ToDouble(valor[0]); 29 | b = Convert.ToDouble(valor[1]); 30 | c = Convert.ToDouble(valor[2]); 31 | 32 | if((a joias = new List(); 31 | 32 | do { 33 | joia = Console.ReadLine(); 34 | 35 | if (!string.IsNullOrWhiteSpace(joia)) { 36 | joias.Add(joia); 37 | } else { 38 | break; 39 | } 40 | } while (true); 41 | 42 | IEnumerable distinctJoias = joias.Distinct(); 43 | Console.WriteLine(distinctJoias.Count()); 44 | } 45 | } -------------------------------------------------------------------------------- /C#/Solução de Problemas Essenciais com C#/quadrado-e-ao-cubo.cs: -------------------------------------------------------------------------------- 1 | // Quadrado e ao Cubo 2 | 3 | /* Você terá o desafio de escrever um programa que leia um valor inteiro 4 | N (1 < N < 1000). Este N é a quantidade de linhas de saída que serão 5 | apresentadas na execução do programa. 6 | 7 | - Entrada 8 | 9 | O arquivo de entrada contém um número inteiro positivo N. 10 | 11 | - Saída 12 | 13 | Imprima a saída conforme o exemplo fornecido. */ 14 | 15 | using System; 16 | 17 | class Desafio { 18 | static void Main() { 19 | var numero = Int32.Parse(Console.ReadLine()); 20 | 21 | if(numero != null) { 22 | for(int i = 1; i <= numero; i++) { 23 | var numeros = $"{i} {i * i} {i * i * i}"; 24 | 25 | Console.WriteLine(numeros); 26 | } 27 | } else { 28 | Console.WriteLine("Insira um número!"); 29 | } 30 | } 31 | } -------------------------------------------------------------------------------- /C#/Solução de Problemas Essenciais com C#/validacao-de-nota.cs: -------------------------------------------------------------------------------- 1 | // Validação de Nota 2 | 3 | /* Para ajudar a calcular as notas referentes às duas avaliações dos alunos, 4 | uma professora pediu para que você desenvolva um programa que calcule e imprima 5 | a média semestral. Faça com que o algoritmo só aceite notas válidas (uma nota 6 | válida deve pertencer ao intervalo [0,10]). Cada nota deve ser validada 7 | separadamente. 8 | 9 | -Entrada 10 | 11 | A entrada contém vários valores reais, positivos ou negativos. O programa deve 12 | ser encerrado quando forem lidas duas notas válidas. 13 | 14 | - Saída 15 | 16 | Se uma nota inválida for lida, deve ser impressa a mensagem "nota invalida". 17 | Quando duas notas válidas forem lidas, deve ser impressa a mensagem "media = " 18 | seguido do valor do cálculo. O valor deve ser apresentado com duas casas após 19 | o ponto decimal. */ 20 | 21 | using System; 22 | 23 | class Desafio { 24 | public static void Main() { 25 | double somaDasNotas = 0; 26 | int contador = 0; 27 | 28 | do { 29 | double notaEntradaConsole = double.Parse(Console.ReadLine()); 30 | 31 | if(notaEntradaConsole < 0 || notaEntradaConsole > 10) { 32 | Console.WriteLine("nota invalida"); 33 | } else { 34 | contador++; 35 | somaDasNotas += notaEntradaConsole; 36 | } 37 | } while (contador < 2); 38 | 39 | Console.WriteLine("media = " + (somaDasNotas / 2).ToString("N2")); 40 | } 41 | } -------------------------------------------------------------------------------- /C#/Solução de problemas básicos em C#/tuitando.cs: -------------------------------------------------------------------------------- 1 | // Tuitando 2 | 3 | /* 4 | O microblog Twitter é conhecido por limitar as postagens em 140 caracteres. 5 | Conferir se um texto vai caber em um tuíte é sua tarefa. 6 | 7 | - Entrada 8 | 9 | A entrada é uma linha de texto T (1 ≤ |T| ≤ 500). 10 | 11 | - Saída 12 | 13 | A saída é dada em uma única linha. Ela deve ser "TWEET" (sem as aspas) se a 14 | linha de texto T tem até 140 caracteres. Se T tem mais de 140 caracteres, a 15 | saída deve ser "MUTE". 16 | */ 17 | 18 | using System; 19 | 20 | class minhaClasse { 21 | static void Main(string[] args) { 22 | string v = Console.ReadLine(); 23 | char[] arr = v.ToCharArray(); 24 | 25 | if( arr.Length <= 140 ) 26 | Console.WriteLine("TWEET"); 27 | else 28 | Console.WriteLine("MUTE"); 29 | } 30 | } -------------------------------------------------------------------------------- /C#/Solução de problemas básicos em C#/visita-na-feira.cs: -------------------------------------------------------------------------------- 1 | // Visita na Feira 2 | 3 | /* Você está na feira com a sua sacola e parou em uma balança. O feirante lhe 4 | entregou pimentões amarelos e vermelhos. Agora iremos somar os pimentões 5 | amarelos e vermelhos para descobrir o total de pimentões na sacola. Você 6 | receberá 2 inteiros que devem ser lidos e armazenados nas variáveis A 7 | (pimentões amarelos) e B (pimentões vermelhos). Faça a soma de A e B atribuindo 8 | o seu resultado na variável X (total de pimentões). Apresente X como descrito 9 | na mensagem de exemplo abaixo. Não apresente outra mensagem além da mensagem 10 | especificada. 11 | 12 | - Entrada 13 | 14 | A entrada contém 2 valores inteiros, separados por um espaço. 15 | 16 | - Saída 17 | 18 | Imprimir a mensagem "X = " (sendo a letra X maiúscula) seguido pelo valor da 19 | variável X e pelo final de linha. Assegure que exista um espaço antes e depois 20 | do sinal de igualdade. */ 21 | 22 | using System; 23 | 24 | class minhaClasse{ 25 | static void Main(string[] args) { 26 | int a, b, x; 27 | string[] entrada = Console.ReadLine().Split(' '); 28 | 29 | a = Convert.ToInt32(entrada[0]); 30 | b = Convert.ToInt32(entrada[1]); 31 | x = a + b; 32 | 33 | Console.WriteLine("X = {0}", x); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /C#/Solução de problemas com .NET/validador-de-senhas-com-requisitos.cs: -------------------------------------------------------------------------------- 1 | // Validador de senhas com requisitos 2 | 3 | /* Pedro e Fernando são os desenvolvedores em uma startup e vão desenvolver o 4 | novo sistema de cadastro, e pediram a sua ajuda. Sua task é fazer o código que 5 | valide as senhas que são cadastradas, para isso você deve atentar aos 6 | requisitos a seguir: 7 | 8 | - A senha deve conter, no mínimo, uma letra maiúscula, uma letra minúscula e 9 | um número; 10 | - A mesma não pode ter nenhum caractere de pontuação, acentuação ou espaço; 11 | - Além disso, a senha pode ter de 6 a 32 caracteres. 12 | 13 | - Entrada 14 | 15 | A entrada contém vários casos de teste e termina com final de arquivo. Cada 16 | linha tem uma string S, correspondente a senha que é inserida pelo usuário 17 | no momento do cadastro. 18 | 19 | - Saída 20 | 21 | A saída contém uma linha, que pode ser “Senha valida.”, caso a senha tenha 22 | cada item dos requisitos solicitados anteriormente, ou “Senha invalida.”, se 23 | um ou mais requisitos não forem atendidos. */ 24 | 25 | using System; 26 | using System.Text.RegularExpressions; 27 | 28 | class Desafio { 29 | static void Main() { 30 | while (true) { 31 | string senha = Console.ReadLine(); 32 | 33 | if (string.IsNullOrEmpty(senha)) break; 34 | Regex rx = new Regex("^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])[a-zA-Z0-9]{6,32}$"); 35 | Match match = rx.Match(senha); 36 | 37 | if (match.Success) { 38 | Console.WriteLine("Senha valida."); 39 | } else { 40 | Console.WriteLine("Senha invalida."); 41 | } 42 | } 43 | } 44 | } -------------------------------------------------------------------------------- /C#/Solução de problemas em C#/consumo-medio-do-automovel.cs: -------------------------------------------------------------------------------- 1 | // Consumo Médio do Automóvel 2 | 3 | /* Você deve calcular o consumo médio de um automóvel onde será informada a 4 | distância total percorrida (em Km) e o total de combustível consumido 5 | (em litros). 6 | 7 | - Entrada 8 | 9 | Você receberá dois valores: um valor inteiro X com a distância total percorrida 10 | (em Km, e um valor real Y que representa o total de combustível consumido, com 11 | um dígito após o ponto decimal. 12 | 13 | - Saída 14 | 15 | Exiba o valor que representa o consumo médio do automóvel (3 casas após a 16 | vírgula), incluindo no final a mensagem "km/l". */ 17 | 18 | using System; 19 | 20 | class minhaClasse { 21 | static void Main(string[] args) { 22 | int distancia; 23 | double combustivelGasto, consumoMedio; 24 | 25 | distancia = Convert.ToInt32(Console.ReadLine()); 26 | combustivelGasto = Convert.ToDouble(Console.ReadLine()); 27 | consumoMedio = distancia / combustivelGasto; 28 | 29 | Console.WriteLine("{0:0.000} km/l", consumoMedio); 30 | } 31 | } -------------------------------------------------------------------------------- /C#/Solução de problemas em C#/encaixa-nao.cs: -------------------------------------------------------------------------------- 1 | // Encaixa ou Não? 2 | 3 | /* 4 | Paulinho tem em suas mãos um novo problema. Agora a sua professora lhe pediu 5 | que construísse um programa para verificar, à partir de dois valores muito 6 | grandes A e B, se B corresponde aos últimos dígitos de A. 7 | 8 | - Entrada 9 | 10 | A entrada consiste de vários casos de teste. A primeira linha de entrada 11 | contém um inteiro N que indica a quantidade de casos de teste. Cada caso de 12 | teste consiste de dois valores A e B maiores que zero, cada um deles podendo 13 | ter até 1000 dígitos. 14 | 15 | - Saída 16 | 17 | Para cada caso de entrada imprima uma mensagem indicando se o segundo valor 18 | encaixa no primeiro valor, conforme exemplo abaixo. 19 | */ 20 | 21 | using System.IO; 22 | using System.Linq; 23 | using System; 24 | 25 | class Program { 26 | static void Main(string[] args) { 27 | int qt = int.Parse(Console.ReadLine()); 28 | string[] v = new string[2]; 29 | 30 | for (int i = 0; i < qt; ++i) { 31 | v = Console.ReadLine().Split(" "); 32 | string a = v[0]; 33 | string b = v[1]; 34 | 35 | if (b.Length > a.Length) 36 | Console.WriteLine("nao encaixa"); 37 | else if (a.EndsWith(b)) 38 | Console.WriteLine("encaixa"); 39 | else 40 | Console.WriteLine("nao encaixa"); 41 | } 42 | } 43 | } -------------------------------------------------------------------------------- /C#/Solução de problemas em C#/preenchimento-vetor-I.cs: -------------------------------------------------------------------------------- 1 | // Preenchimento de Vetor I 2 | 3 | /* 4 | Precisamos saber quanto uma determinada empresa deve pagar para seus 5 | colaboradores, porém temos apenas a quantidade de horas trabalhadas e o valor 6 | hora. Escreva um programa que leia o número de um colaborador, seu número de 7 | horas trabalhadas, o valor que recebe por hora e calcula o salário desse 8 | colaborador. Em seguida, apresente o número e o salário do colaborador, com 9 | duas casas decimais. 10 | 11 | - Entrada 12 | 13 | Você receberá 2 números inteiros e 1 número com duas casas decimais, 14 | representando o número, quantidade de horas trabalhadas e o valor que o 15 | funcionário recebe por hora trabalhada. 16 | 17 | - Saída 18 | 19 | Exiba o número e o salário do colaborador, conforme exemplo abaixo, com um 20 | espaço em branco antes e depois da igualdade. No caso do salário, também deve 21 | haver um espaço em branco após o $. 22 | */ 23 | 24 | using System; 25 | 26 | class Program { 27 | static void Main(string[] args) { 28 | int valorLido = int.Parse(Console.ReadLine()); 29 | int[] n = new int[10]; 30 | 31 | n[0] = valorLido; 32 | 33 | for (int i = 1; i < 10; ++i) { 34 | n[i] = n[i-1] * 2; 35 | } 36 | 37 | for (int i = 0; i < 10; ++i) { 38 | Console.WriteLine($"N[{i}] = {n[i]}"); 39 | } 40 | } 41 | } -------------------------------------------------------------------------------- /Java/Desafio Aritmético em Java/AbaixoDiagonalPrincipal.java: -------------------------------------------------------------------------------- 1 | // Abaixo da Diagonal Principal 2 | 3 | /* 4 | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e 5 | uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média 6 | considerando somente aqueles elementos que estão abaixo da diagonal principal 7 | da matriz, conforme ilustrado abaixo (área verde). 8 | 9 | vide arquivo em assets abaixo-diagonal-principal.png 10 | 11 | • Entrada 12 | 13 | A primeira linha de entrada contém um único caractere Maiúsculo O ('S' ou 'M'), 14 | indicando a operação (Soma ou Média) que deverá ser realizada com os elementos 15 | da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz. 16 | 17 | • Saída 18 | 19 | Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto 20 | decimal. 21 | */ 22 | 23 | import java.io.IOException; 24 | import java.util.Scanner; 25 | 26 | public class AbaixoDiagonalPrincipal { 27 | public static void main(String[] args) throws IOException { 28 | Scanner leitor = new Scanner(System.in); 29 | double soma = 0; 30 | char O = leitor.next().toUpperCase().charAt(0); 31 | double[][] M = new double[12][12]; 32 | 33 | for (int i = 0; i < 12; ++i) { 34 | for (int j = 0; j < 12; ++j) { 35 | M[i][j] = leitor.nextDouble(); 36 | } 37 | } 38 | 39 | for (int i = 1; i < 12; ++i) { 40 | for (int j = 0; j < i; ++j) { 41 | soma += M[i][j]; 42 | } 43 | } 44 | 45 | if (O == 'M') soma /= ((M.length * M.length) - 12) / 2; 46 | 47 | System.out.println(String.format("%.1f", soma)); 48 | } 49 | } -------------------------------------------------------------------------------- /Java/Desafio Aritmético em Java/AcimaDiagonalSecundaria.java: -------------------------------------------------------------------------------- 1 | // Acima da Diagonal Secundária 2 | 3 | /* 4 | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e 5 | uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média 6 | considerando somente aqueles elementos que estão acima da diagonal secundária 7 | da matriz, conforme ilustrado abaixo (área verde). 8 | 9 | vide arquivo em assets acima-diagonal-secundaria.png 10 | 11 | • Entrada 12 | 13 | A primeira linha de entrada contém um único caractere Maiúsculo O ('S' ou 'M'), 14 | indicando a operação (Soma ou Média) que deverá ser realizada com os elementos 15 | da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz. 16 | 17 | • Saída 18 | 19 | Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto 20 | decimal. 21 | */ 22 | 23 | import java.io.IOException; 24 | import java.util.Scanner; 25 | 26 | public class AcimaDiagonalSecundaria { 27 | public static void main(String[] args) throws IOException { 28 | Scanner leitor = new Scanner(System.in); 29 | double soma = 0; 30 | char O = leitor.next().toUpperCase().charAt(0); 31 | double[][] M = new double[12][12]; 32 | 33 | for (int i = 0; i < 12; ++i) { 34 | for (int j = 0; j < 12; ++j) { 35 | M[i][j] = leitor.nextDouble(); 36 | } 37 | } 38 | 39 | for (int i = 0; i < 11; ++i) { 40 | for (int j = 0; j < 11-i; ++j) { 41 | soma += M[i][j]; 42 | } 43 | } 44 | 45 | if (O == 'M') soma /= ((M.length * M.length) - 12) / 2; 46 | 47 | System.out.println(String.format("%.1f", soma)); 48 | } 49 | } -------------------------------------------------------------------------------- /Java/Desafios Avançados em Java/AreaSuperior.java: -------------------------------------------------------------------------------- 1 | // Área Superior 2 | 3 | /* 4 | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e 5 | uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média 6 | considerando somente aqueles elementos que estão na área superior da matriz, 7 | conforme ilustrado abaixo (área verde). 8 | 9 | vide arquivo em assets area-superior.png 10 | 11 | • Entrada 12 | 13 | A primeira linha de entrada contém um único caractere Maiúsculo O ('S' ou 'M'), 14 | indicando a operação (Soma ou Média) que deverá ser realizada com os elementos 15 | da matriz. Seguem 144 valores com ponto flutuante de dupla precisão que compõem 16 | a matriz. 17 | 18 | • Saída 19 | 20 | Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto 21 | decimal. 22 | */ 23 | 24 | import java.io.IOException; 25 | import java.util.Scanner; 26 | 27 | public class AreaSuperior { 28 | public static void main(String[] args) throws IOException { 29 | Scanner leitor = new Scanner(System.in); 30 | double soma = 0; 31 | char O = leitor.next().toUpperCase().charAt(0); 32 | double[][] M = new double[12][12]; 33 | 34 | for (int i = 0; i < 12; ++i) { 35 | for (int j = 0; j < 12; ++j) { 36 | M[i][j] = leitor.nextDouble(); 37 | } 38 | } 39 | 40 | for (int i = 0; i < 5; ++i) { 41 | for (int j = 1; j < 11; ++j) { 42 | if (j > i && i + j < 11) soma += M[i][j]; 43 | } 44 | } 45 | 46 | if (O == 'M') soma /= ((M.length * M.length) - 24) / 4; 47 | 48 | System.out.println(String.format("%.1f", soma)); 49 | } 50 | } -------------------------------------------------------------------------------- /Java/Desafios Avançados em Java/FibonacciEmVetor.java: -------------------------------------------------------------------------------- 1 | // Fibonacci em Vetor 2 | 3 | /* 4 | Nesse desafio você terá que desenvolver um programa que leia um valor e 5 | apresente o número de Fibonacci correspondente a este valor lido. Lembre-se que 6 | os 2 primeiros elementos da série de Fibonacci são 0 e 1 e cada próximo termo 7 | é a soma dos 2 anteriores a ele. Todos os valores de Fibonacci calculados neste 8 | problema devem caber em um inteiro de 64 bits sem sinal. 9 | 10 | • Entrada 11 | 12 | A primeira linha da entrada contém um inteiro T, indicando o número de casos 13 | de teste. Cada caso de teste contém um único inteiro N (0 ≤ N ≤ 60), 14 | correspondente ao enésimo termo da série de Fibonacci. 15 | 16 | • Saída 17 | 18 | Para cada caso de teste da entrada, imprima a mensagem "Fib(N) = X", onde X é 19 | o N-ésimo termo da série de Fibonacci. 20 | */ 21 | 22 | import java.io.IOException; 23 | import java.util.Scanner; 24 | 25 | public class FibonacciEmVetor { 26 | public static void main(String[] args) throws IOException { 27 | Scanner leitor = new Scanner(System.in); 28 | int T = leitor.nextInt(); 29 | 30 | for (int i = 0; i < T; ++i) { 31 | int N = leitor.nextInt(); 32 | long anterior = 0, atual = 1, auxiliar; 33 | 34 | for (int j = 0; j < N; ++j) { 35 | auxiliar = atual; 36 | atual = atual + anterior; 37 | anterior = auxiliar; 38 | } 39 | 40 | System.out.println("Fib("+ N +") = " + anterior); 41 | } 42 | } 43 | } -------------------------------------------------------------------------------- /Java/Desafios matemáticos em Java/AreaDireita.java: -------------------------------------------------------------------------------- 1 | // Área Direita 2 | 3 | /* 4 | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e 5 | uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média 6 | considerando somente aqueles elementos que estão na área direita da matriz, 7 | conforme ilustrado abaixo (área verde). 8 | 9 | vide arquivo em assets area-direita.png 10 | 11 | - Entrada 12 | 13 | A primeira linha de entrada contem um único caractere Maiúsculo O ('S' ou 'M'), 14 | indicando a operação (Soma ou Média) que deverá ser realizada com os elementos 15 | da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz. 16 | 17 | - Saída 18 | 19 | Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto 20 | decimal. 21 | */ 22 | 23 | import java.io.IOException; 24 | import java.util.Scanner; 25 | 26 | public class AreaDireita { 27 | public static void main(String[] args) throws IOException { 28 | Scanner leitor = new Scanner(System.in); 29 | double soma = 0; 30 | char O = leitor.next().toUpperCase().charAt(0); 31 | double[][] M = new double[12][12]; 32 | 33 | for (int i = 0; i < 12; ++i) { 34 | for (int j = 0; j < 12; ++j) { 35 | M[i][j] = leitor.nextDouble(); 36 | } 37 | } 38 | 39 | for (int i = 0; i < 12; ++i) { 40 | for (int j = 0; j < 12; ++j) { 41 | if (((i < 6) && (j >= 12 - i)) || ((i >= 6) && (j > i))) 42 | soma += M[i][j]; 43 | } 44 | } 45 | 46 | if (O == 'M') 47 | soma /= 30; 48 | 49 | System.out.println(String.format("%.1f", soma)); 50 | } 51 | } -------------------------------------------------------------------------------- /Java/Desafios matemáticos em Java/AreaEsquerda.java: -------------------------------------------------------------------------------- 1 | // Área Esquerda 2 | 3 | /* 4 | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e 5 | uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média 6 | considerando somente aqueles elementos que estão na área esquerda da matriz, 7 | conforme ilustrado abaixo (área verde). 8 | 9 | vide arquivo em assets area-esquerda.png 10 | 11 | - Entrada 12 | 13 | A primeira linha de entrada contem um único caractere Maiúsculo O ('S' ou 'M'), 14 | indicando a operação (Soma ou Média) que deverá ser realizada com os elementos 15 | da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz. 16 | 17 | - Saída 18 | 19 | Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto 20 | decimal. 21 | */ 22 | 23 | import java.io.IOException; 24 | import java.util.Scanner; 25 | 26 | public class AreaEsquerda { 27 | public static void main(String[] args) throws IOException { 28 | Scanner leitor = new Scanner(System.in); 29 | double soma = 0; 30 | char O = leitor.next().toUpperCase().charAt(0); 31 | double[][] M = new double[12][12]; 32 | 33 | for (int i = 0; i < 12; ++i) { 34 | for (int j = 0; j < 12; ++j) { 35 | M[i][j] = leitor.nextDouble(); 36 | } 37 | } 38 | 39 | for (int i = 0; i < 12; ++i) { 40 | for (int j = 0; j < 12; ++j) { 41 | if (((i < 6) && (j < i)) || ((i >= 6) && (j < 11 - i))) 42 | soma += M[i][j]; 43 | } 44 | } 45 | 46 | if (O == 'M') 47 | soma /= 30; 48 | 49 | System.out.println(String.format("%.1f", soma)); 50 | } 51 | } -------------------------------------------------------------------------------- /Java/Desafios numéricos em Java/FatorialSimples.java: -------------------------------------------------------------------------------- 1 | // Fatorial Simples 2 | 3 | /* 4 | Ler um valor N. Calcular e escrever seu respectivo fatorial. Fatorial de 5 | N = N * (N-1) * (N-2) * (N-3) * ... * 1. 6 | 7 | - Entrada 8 | 9 | A entrada contém um valor inteiro N (0 < N < 13). 10 | 11 | - Saída 12 | 13 | A saída contém um valor inteiro, correspondente ao fatorial de N. 14 | */ 15 | 16 | import java.io.IOException; 17 | import java.util.Scanner; 18 | 19 | public class FatorialSimples { 20 | public static void main(String[] args) throws IOException { 21 | Scanner leitor = new Scanner(System.in); 22 | int N = leitor.nextInt(); 23 | int fat = 1; 24 | 25 | for (int i = 1; i <= N; i++) { 26 | fat *= i; 27 | } 28 | 29 | System.out.println(fat); 30 | } 31 | } -------------------------------------------------------------------------------- /Java/Desafios numéricos em Java/SeisNumerosPares.java: -------------------------------------------------------------------------------- 1 | // Seis Números Pares 2 | 3 | /* 4 | Leia um valor inteiro X. Em seguida apresente os 6 valores ímpares consecutivos 5 | a partir de X, um valor por linha, inclusive o X se for o caso. 6 | 7 | - Entrada 8 | 9 | A entrada será um valor inteiro positivo. 10 | 11 | - Saída 12 | 13 | A saída será uma sequência de seis números ímpares. 14 | */ 15 | 16 | import java.io.IOException; 17 | import java.util.Scanner; 18 | 19 | public class Desafio { 20 | public static void main(String[] args) throws IOException { 21 | Scanner leitor = new Scanner(System.in); 22 | int x = leitor.nextInt(); 23 | int cont = 0; 24 | 25 | while (cont < 6) { 26 | if (x % 2 == 1) { 27 | System.out.println(x); 28 | cont++; 29 | } 30 | x++; 31 | } 32 | } 33 | } -------------------------------------------------------------------------------- /Java/Desafios para iniciantes em Java/HoHoHo.java: -------------------------------------------------------------------------------- 1 | // Ho Ho Ho 2 | 3 | /* 4 | Papai Noel está brincando com seus duendes para entretê-los durante a véspera 5 | do Natal. A brincadeira consiste nos elfos escreverem números em pedaços de 6 | papel e colocarem no gorro do Papai Noel. Após todos terminarem de colocar os 7 | números Noel sorteia um papel e aquele número representa quantos "Ho" o Noel 8 | deve falar. 9 | 10 | Seu trabalho é ajudar o Papai Noel montando um problema que mostre todos os 11 | "Ho" que ele deve falar dado o número sorteado. 12 | 13 | - Entrada 14 | 15 | A entrada é composta por um único inteiro N (0 < N ≤ 106) representando quantos 16 | "Ho" serão falados por Noel. 17 | 18 | - Saída 19 | 20 | A saída é composta por todos "Ho" que Papai Noel deve falar separados por um 21 | espaço. Após o último "Ho" deve ser apresentado um "!" encerrando o programa. 22 | */ 23 | 24 | import java.util.Scanner; 25 | 26 | public class Main { 27 | public static void main(String[] args) { 28 | Scanner entrada = new Scanner(System.in); 29 | int num = entrada.nextInt(); 30 | 31 | for (int i = 1; i < num; i++) { 32 | System.out.print("Ho "); 33 | } 34 | System.out.println("Ho!"); 35 | } 36 | } -------------------------------------------------------------------------------- /Java/Desafios para iniciantes em Java/Quadrante.java: -------------------------------------------------------------------------------- 1 | // Quadrante 2 | 3 | /* 4 | Desenvolva um programa para ler as coordenadas (M,N) de uma quantidade 5 | indeterminada de pontos no sistema cartesiano. Para cada ponto escrever o 6 | quadrante a que ele pertence. O algoritmo será encerrado quando pelo menos uma 7 | de duas coordenadas for NULA (nesta situação sem escrever mensagem alguma). 8 | 9 | - Entrada 10 | 11 | A entrada contém vários casos de teste. Cada caso de teste contém 2 valores 12 | inteiros. 13 | 14 | - Saída 15 | 16 | Para cada caso de teste mostre em qual quadrante do sistema cartesiano se 17 | encontra a coordenada lida, conforme o exemplo. 18 | */ 19 | 20 | import java.io.IOException; 21 | import java.util.Scanner; 22 | 23 | public class Quadrante { 24 | public static void main(String[] args) throws IOException { 25 | Scanner leitor = new Scanner(System.in); 26 | int X = leitor.nextInt(); 27 | int Y = leitor.nextInt(); 28 | 29 | while (X != 0 && Y != 0) { 30 | if (X > 0 && Y > 0) { 31 | System.out.println("primeiro"); 32 | } else if (X > 0 && Y < 0) { 33 | System.out.println("quarto"); 34 | } else if (X < 0 && Y < 0) { 35 | System.out.println("terceiro"); 36 | } else if (X < 0 && Y > 0) { 37 | System.out.println("segundo"); 38 | } 39 | 40 | X = leitor.nextInt(); 41 | Y = leitor.nextInt(); 42 | } 43 | } 44 | } -------------------------------------------------------------------------------- /Java/Fundamentos Aritméticos em Java/ConsumoMedioAutomovel.java: -------------------------------------------------------------------------------- 1 | // Consumo Médio do Automóvel 2 | 3 | /* Você deve calcular o consumo médio de um automóvel onde será informada a 4 | distância total percorrida (em Km) e o total de combustível consumido (em 5 | litros). 6 | 7 | - Entrada 8 | 9 | Você receberá dois valores: um valor inteiro X com a distância total percorrida 10 | (em Km, e um valor real Y que representa o total de combustível consumido, com 11 | um dígito após o ponto decimal. 12 | 13 | - Saída 14 | 15 | Exiba o valor que representa o consumo médio do automóvel (3 casas após a 16 | vírgula), incluindo no final a mensagem "km/l". */ 17 | 18 | import java.io.BufferedReader; 19 | import java.io.IOException; 20 | import java.io.InputStreamReader; 21 | import java.math.BigDecimal; 22 | import java.math.MathContext; 23 | 24 | public class ConsumoMedioAutomovel { 25 | public static void main(String[] args) throws IOException { 26 | BigDecimal km; 27 | BigDecimal combustivel; 28 | 29 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 30 | km = new BigDecimal(br.readLine()); 31 | combustivel = new BigDecimal(br.readLine()); 32 | BigDecimal comMedio = km.divide(combustivel, MathContext.DECIMAL32).setScale(3, BigDecimal.ROUND_HALF_EVEN); 33 | 34 | System.out.println("" + comMedio + " km/l"); 35 | } 36 | } -------------------------------------------------------------------------------- /Java/Fundamentos Aritméticos em Java/ExibindoNumerosPares.java: -------------------------------------------------------------------------------- 1 | // Exibindo Números Pares 2 | 3 | /* Crie um programa que leia um número e mostre os números pares até esse 4 | número, inclusive ele mesmo. 5 | 6 | - Entrada 7 | 8 | Você receberá 1 valor inteiro N, onde N > 0. 9 | 10 | - Saída 11 | 12 | Exiba todos os números pares até o valor de entrada, sendo um em cada linha. 13 | */ 14 | 15 | import java.io.BufferedReader; 16 | import java.io.IOException; 17 | import java.io.InputStreamReader; 18 | 19 | public class ExibindoNumerosPares { 20 | public static void main(String[] args) throws IOException { 21 | String entrada; 22 | 23 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 24 | entrada = br.readLine(); 25 | 26 | for (int i = 2; i <= Integer.parseInt(entrada); i++) { 27 | if (i % 2 == 0) { 28 | System.out.println(i); 29 | } 30 | } 31 | } 32 | } -------------------------------------------------------------------------------- /Java/Fundamentos Aritméticos em Java/QtdeNumerosPositivos.java: -------------------------------------------------------------------------------- 1 | // Quantidade de Números Positivos 2 | 3 | /* Crie um programa que leia 6 valores. Você poderá receber valores negativos 4 | e/ou positivos como entrada, devendo desconsiderar os valores nulos. Em 5 | seguida, apresente a quantidade de valores positivos digitados. 6 | 7 | - Entrada 8 | 9 | Você receberá seis valores, negativos e/ou positivos. 10 | 11 | - Saída 12 | 13 | Exiba uma mensagem dizendo quantos valores positivos foram lidos assim como é 14 | exibido abaixo no exemplo de saída. Não esqueça da mensagem "valores positivos" 15 | ao final. */ 16 | 17 | import java.io.BufferedReader; 18 | import java.io.IOException; 19 | import java.io.InputStreamReader; 20 | 21 | public class QtdeNumerosPositivos { 22 | public static void main(String[] args) throws IOException { 23 | String linha; 24 | Double n; 25 | int Pos, i; 26 | 27 | Pos=0; 28 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 29 | 30 | for (i=0; i < 6; i++) { 31 | linha = br.readLine(); 32 | n = Double.parseDouble(linha); 33 | if(n > 0.0)Pos++; 34 | } 35 | 36 | System.out.println("" + Pos + " valores positivos"); 37 | } 38 | } -------------------------------------------------------------------------------- /Java/Iniciando a programação em Java/DDD.java: -------------------------------------------------------------------------------- 1 | // DDD 2 | 3 | /* 4 | Leia um número inteiro que representa um código de DDD para discagem 5 | interurbana. Em seguida, informe à qual cidade o DDD pertence, considerando a 6 | tabela abaixo: 7 | 8 | Se a entrada for qualquer outro DDD que não esteja presente na tabela acima, o 9 | programa deverá informar: 10 | DDD nao cadastrado 11 | 12 | - Entrada 13 | 14 | A entrada consiste de um único valor inteiro. 15 | 16 | - Saída 17 | 18 | Imprima o nome da cidade correspondente ao DDD existente na entrada. Imprima 19 | DDD nao cadastrado caso não existir DDD correspondente ao número digitado. 20 | */ 21 | 22 | import java.io.IOException; 23 | import java.util.Scanner; 24 | 25 | public class Classe { 26 | public static void main(String[] args) throws IOException { 27 | Scanner leitor = new Scanner(System.in); 28 | int DDD = leitor.nextInt(); 29 | 30 | switch (DDD) { 31 | case 61: System.out.println("Brasilia"); break; 32 | case 71: System.out.println("Salvador"); break; 33 | case 11: System.out.println("Sao Paulo"); break; 34 | case 21: System.out.println("Rio de Janeiro"); break; 35 | case 32: System.out.println("Juiz de Fora"); break; 36 | case 19: System.out.println("Campinas"); break; 37 | case 27: System.out.println("Vitoria"); break; 38 | case 31: System.out.println("Belo Horizonte"); break; 39 | default: System.out.println("DDD nao cadastrado"); 40 | } 41 | } 42 | } -------------------------------------------------------------------------------- /Java/Iniciando a programação em Java/EntradaESaidaCPF.java: -------------------------------------------------------------------------------- 1 | // Entrada e Saída CPF 2 | 3 | /* 4 | Elabore um programa que possuas as características abaixo: 5 | 6 | 1. Leia os dados de um CPF no formato XXX.YYY.ZZZ-DD; 7 | 2. Imprima os quatro grupos numéricos, sendo um valor por linha. 8 | 9 | - Entrada 10 | 11 | A entrada consiste vários arquivos de teste e cada um possuindo uma linha com 12 | formato XXX.YYY.ZZZ-DD, onde XXX, YYY, ZZZ, DD são números inteiros. 13 | 14 | - Saída 15 | 16 | Para cada arquivo da entrada, tem que ter um arquivo de saída com quatro linhas, 17 | e em cada linha um número inteiro de acordo com procedimento 2 descrito no 18 | Desafio. Confira o exemplo abaixo: 19 | */ 20 | 21 | import java.util.Scanner; 22 | import java.util.Locale; 23 | 24 | public class Classe{ 25 | public static void main(String[] args) { 26 | Locale.setDefault(new Locale("en", "US")); 27 | Scanner sc = new Scanner(System.in); 28 | String[] cpf = new String[4]; 29 | cpf = sc.nextLine().split("-"); 30 | 31 | for(int i= 0; i < cpf.length; i++) { 32 | System.out.println(cpf[i].replace(".","\n")); 33 | } 34 | 35 | sc.close(); 36 | } 37 | } -------------------------------------------------------------------------------- /Java/Introdução a Programação com Java/EncaixaOuNaoI.java: -------------------------------------------------------------------------------- 1 | // Encaixa ou Não I 2 | 3 | /* 4 | Paulinho tem em suas mãos um pequeno problema. A professora lhe pediu que ele 5 | construísse um programa para verificar, à partir de dois valores inteiros A e 6 | B, se B corresponde aos últimos dígitos de A. 7 | 8 | - Entrada 9 | 10 | A entrada consiste de vários casos de teste. A primeira linha de entrada contém 11 | um inteiro N que indica a quantidade de casos de teste. Cada caso de teste 12 | consiste de dois inteiros A (1 ≤ A < 231 ) e B (1 ≤ B < 231) positivos. 13 | 14 | - Saída 15 | 16 | Para cada caso de entrada imprima uma mensagem indicando se o segundo valor 17 | encaixa no primeiro valor, conforme exemplo abaixo. 18 | */ 19 | 20 | import java.io.IOException; 21 | import java.util.Scanner; 22 | 23 | public class Desafio { 24 | public static void main(String[] args) throws IOException { 25 | Scanner leitor = new Scanner(System.in); 26 | int N = leitor.nextInt(); 27 | 28 | for (int i = 0; i < N; i++) { 29 | String A = leitor.next(); 30 | String B = leitor.next(); 31 | System.out.println((A.endsWith(B)) ? "encaixa" : "nao encaixa"); 32 | } 33 | } 34 | } -------------------------------------------------------------------------------- /Java/Introdução a Programação com Java/Media1.java: -------------------------------------------------------------------------------- 1 | // Média 1 2 | 3 | /* 4 | Leia 2 valores de ponto flutuante de dupla precisão A e B, que correspondem a 5 | 2 notas de um aluno. A seguir, calcule a média do aluno, sabendo que a nota A 6 | tem peso 3.5 e a nota B tem peso 7.5 (A soma dos pesos portanto é 11). Assuma 7 | que cada nota pode ir de 0 até 10.0, sempre com uma casa decimal. 8 | 9 | - Entrada 10 | 11 | O arquivo de entrada contém 2 valores com uma casa decimal cada um. 12 | 13 | - Saída 14 | 15 | Calcule e imprima a variável MEDIA conforme exemplo abaixo, com 5 dígitos após 16 | o ponto decimal e com um espaço em branco antes e depois da igualdade. Utilize 17 | variáveis de dupla precisão (double) e como todos os problemas, não esqueça de 18 | imprimir o fim de linha após o resultado, caso contrário, você receberá 19 | "Presentation Error". 20 | */ 21 | 22 | import java.util.Scanner; 23 | 24 | public class Media1 { 25 | public static void main(String[] args) { 26 | Scanner sc = new Scanner(System.in); 27 | double A, B, media; 28 | 29 | A = sc.nextDouble(); 30 | B = sc.nextDouble(); 31 | 32 | media = ( A * 3.5 + B * 7.5) / 11; 33 | 34 | System.out.printf("MEDIA = %.5f%n", media); 35 | sc.close(); 36 | } 37 | } -------------------------------------------------------------------------------- /Java/Introdução a Programação com Java/MultiplicacaoSimples.java: -------------------------------------------------------------------------------- 1 | // Multiplicação Simples 2 | 3 | /* Você receberá dois valores inteiros. Faça a leitura e em seguida calcule 4 | o produto entre estes dois valores. Atribua esta operação à variável PROD, 5 | mostrando está de acordo com a mensagem de saída esperada (exemplo abaixo). 6 | 7 | - Entrada 8 | 9 | A entrada contém 2 valores inteiros. 10 | 11 | - Saída 12 | 13 | Exiba a variável PROD conforme exemplo abaixo, tendo obrigatoriamente um 14 | espaço em branco antes e depois da igualdade. */ 15 | 16 | import java.io.BufferedReader; 17 | import java.io.InputStreamReader; 18 | import java.io.IOException; 19 | import java.util.StringTokenizer; 20 | 21 | public class MultiplicacaoSimples { 22 | public static void main(String[] args) throws IOException { 23 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 24 | StringTokenizer st = new StringTokenizer(br.readLine()); 25 | int a = Integer.parseInt(st.nextToken()); 26 | 27 | st = new StringTokenizer(br.readLine()); 28 | int b = Integer.parseInt(st.nextToken()); 29 | 30 | int total = a * b; 31 | System.out.println("PROD = " + total); 32 | } 33 | } 34 | 35 | // ou 36 | 37 | import java.util.Scanner; 38 | 39 | public class Main { 40 | public static void main(String[] args) { 41 | Scanner sc = new Scanner(System.in); 42 | int A, B, PROD; 43 | A = sc.nextInt(); 44 | B = sc.nextInt(); 45 | 46 | PROD = A * B; 47 | System.out.println("PROD = " + PROD); 48 | sc.close(); 49 | } 50 | } -------------------------------------------------------------------------------- /Java/Introdução a Programação com Java/Multiplos.java: -------------------------------------------------------------------------------- 1 | // Múltiplos 2 | 3 | /* 4 | Leia 2 valores inteiros (A e B). Após, o programa deve mostrar uma mensagem 5 | "Sao Multiplos" ou "Nao sao Multiplos", indicando se os valores lidos são 6 | múltiplos entre si. 7 | 8 | - Entrada 9 | 10 | A entrada contém valores inteiros. 11 | 12 | - Saída 13 | 14 | A saída deve conter uma das mensagens conforme descrito acima. 15 | */ 16 | 17 | import java.io.IOException; 18 | import java.util.Scanner; 19 | 20 | public class Classe { 21 | public static void main(String[] args) throws IOException { 22 | Scanner leitor = new Scanner(System.in); 23 | 24 | int A = leitor.nextInt(); 25 | int B = leitor.nextInt(); 26 | if (A % B == 0 || B % A == 0) { 27 | System.out.println("Sao Multiplos"); 28 | } else { 29 | System.out.println("Nao sao Multiplos"); 30 | } 31 | } 32 | } -------------------------------------------------------------------------------- /Java/Introdução a Programação com Java/SomaSimples.java: -------------------------------------------------------------------------------- 1 | // Soma Simples 2 | 3 | /* 4 | Leia dois valores inteiros identificados como variáveis A e B. Calcule a soma 5 | entre elas e chame essa variável de SOMA. 6 | A seguir escreva o valor desta variável. 7 | 8 | - Entrada 9 | 10 | O arquivo de entrada contém 2 valores inteiros. 11 | 12 | - Saída 13 | 14 | Imprima a variável SOMA com todas as letras maiúsculas, inserindo um espaço em 15 | branco antes e depois do símbolo de igualdade, seguido pelo valor 16 | correspondente à soma de A e B. 17 | */ 18 | 19 | import java.util.Scanner; 20 | 21 | public class SomaSimples { 22 | public static void main(String[] args) { 23 | Scanner ler = new Scanner(System.in); 24 | int A, B, soma = 0; 25 | 26 | A = ler.nextInt(); 27 | B = ler.nextInt(); 28 | 29 | soma = A + B; 30 | System.out.println( "SOMA = " + soma); 31 | } 32 | } -------------------------------------------------------------------------------- /Java/Introdução a Programação com Java/TempoDeJogo.java: -------------------------------------------------------------------------------- 1 | // Tempo de Jogo 2 | 3 | /* 4 | Tento como base a hora inicial e final de um jogo, calcule a duração do dele, 5 | sabendo que o mesmo pode começar em um dia e terminar em outro, tendo uma 6 | duração mínima de, 60 minutos e máxima de 24 horas. 7 | 8 | - Entrada 9 | 10 | A entrada contém dois valores inteiros representando a hora de início e a hora 11 | de fim do jogo. 12 | 13 | - Saída 14 | 15 | Apresente a duração do jogo conforme exemplo abaixo. 16 | */ 17 | 18 | import java.util.Scanner; 19 | import java.io.IOException; 20 | 21 | public class TempoDeJogo { 22 | public static void main(String[] args) { 23 | Scanner leitor = new Scanner(System.in); 24 | int hInicial = leitor.nextInt(); 25 | int hFinal = leitor.nextInt(); 26 | 27 | if (hInicial > hFinal) { 28 | System.out.println("O JOGO DUROU " + (24 - (hInicial - hFinal)) + " HORA(S)"); 29 | } else if (hFinal > hInicial) { 30 | System.out.println("O JOGO DUROU " + (hFinal - hInicial) + " HORA(S)"); 31 | } else { 32 | System.out.println("O JOGO DUROU 24 HORA(S)"); 33 | } 34 | } 35 | } -------------------------------------------------------------------------------- /Java/Introdução a Programação com Java/VisitaFeira.java: -------------------------------------------------------------------------------- 1 | // Visita na Feira 2 | 3 | /* Você está na feira com a sua sacola e parou em uma balança. O feirante lhe 4 | entregou pimentões amarelos e vermelhos. Agora iremos somar os pimentões 5 | amarelos e vermelhos para descobrir o total de pimentões na sacola. Você 6 | receberá 2 inteiros que devem ser lidos e armazenados nas variáveis A 7 | (pimentões amarelos) e B (pimentões vermelhos). Faça a soma de A e B 8 | atribuindo o seu resultado na variável X (total de pimentões). Apresente X 9 | como descrito na mensagem de exemplo abaixo. Não apresente outra mensagem 10 | além da mensagem especificada. 11 | 12 | - Entrada 13 | 14 | A entrada contém 2 valores inteiros, separados por um espaço. 15 | 16 | - Saída 17 | 18 | Imprimir a mensagem "X = " (sendo a letra X maiúscula) seguido pelo valor da 19 | variável X e pelo final de linha. Assegure que exista um espaço antes e depois 20 | do sinal de igualdade. */ 21 | 22 | import java.io.BufferedReader; 23 | import java.io.InputStreamReader; 24 | import java.io.IOException; 25 | import java.util.StringTokenizer; 26 | 27 | public class VisitaFeira { 28 | public static void main(String[] args) throws IOException { 29 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 30 | StringTokenizer st = new StringTokenizer(br.readLine()); 31 | 32 | int a = Integer.parseInt(st.nextToken()); 33 | int b = Integer.parseInt(st.nextToken()); 34 | 35 | int total = a + b; 36 | System.out.println("X = " + total); 37 | } 38 | } -------------------------------------------------------------------------------- /Java/Introdução a Programação em Java/ConversaoDeTempo.java: -------------------------------------------------------------------------------- 1 | // Conversão de Tempo 2 | 3 | /* 4 | Você terá o desafio de ler um valor inteiro, que é o tempo de duração em 5 | segundos de um determinado evento em uma loja, e informe-o expresso no formato 6 | horas:minutos:segundos. 7 | 8 | - Entrada 9 | 10 | O arquivo de entrada contém um valor inteiro N. 11 | 12 | - Saída 13 | 14 | Imprima o tempo lido no arquivo de entrada (segundos), convertido para 15 | horas:minutos:segundos, conforme exemplo fornecido. 16 | */ 17 | 18 | import java.util.Scanner; 19 | import java.io.IOException; 20 | 21 | public class Main { 22 | public static void main(String[] args) { 23 | Scanner input = new Scanner(System.in); 24 | int sec, min, hour, time, rest, rest2; 25 | 26 | time = input.nextInt(); 27 | 28 | if (time >= 3600) { 29 | rest = time % 3600; 30 | hour = (int)((time - rest) / 3600); 31 | rest2 = rest % 60; 32 | min = (int)((rest - rest2) / 60); 33 | sec = (int)(rest2); 34 | 35 | System.out.println(hour + ":" + min + ":" + sec); 36 | } else if (time >= 60) { 37 | rest = time % 60; 38 | min = (int)((time - rest) / 60); 39 | sec = (int)(rest); 40 | 41 | System.out.println("0:" + min + ":" + sec); 42 | } else if (time < 60) { 43 | sec = time; 44 | 45 | System.out.println("0:0:" + sec); 46 | } 47 | } 48 | } -------------------------------------------------------------------------------- /Java/Introdução a Programação em Java/Tuitando.java: -------------------------------------------------------------------------------- 1 | // Tuitando 2 | 3 | /* 4 | O microblog Twitter é conhecido por limitar as postagens em 140 caracteres. 5 | Conferir se um texto vai caber em um tuíte é sua tarefa. 6 | 7 | - Entrada 8 | 9 | A entrada é uma linha de texto T (1 ≤ |T| ≤ 500). 10 | 11 | - Saída 12 | 13 | A saída é dada em uma única linha. Ela deve ser "TWEET" (sem as aspas) se a 14 | linha de texto T tem até 140 caracteres. Se T tem mais de 140 caracteres, a 15 | saída deve ser "MUTE". 16 | */ 17 | 18 | import java.io.IOException; 19 | import java.util.Scanner; 20 | 21 | public class Problem { 22 | public static void main(String[] args) throws IOException { 23 | Scanner leitor = new Scanner(System.in); 24 | String T = leitor.nextLine(); 25 | System.out.println(T.length() > 140 ? "MUTE" : "TWEET"); 26 | } 27 | } -------------------------------------------------------------------------------- /Java/Primeiros desafios de código com Java/Mes.java: -------------------------------------------------------------------------------- 1 | // Mês 2 | 3 | /* 4 | 5 | */ 6 | 7 | import java.io.IOException; 8 | import java.util.Scanner; 9 | 10 | public class Problem { 11 | public static void main(String[] args) { 12 | Scanner input = new Scanner(System.in); 13 | int month; 14 | 15 | month = input.nextInt(); 16 | 17 | switch (month) { 18 | case 1: 19 | System.out.printf("January\n"); 20 | break; 21 | case 2: 22 | System.out.printf("February\n"); 23 | break; 24 | case 3: 25 | System.out.printf("March\n"); 26 | break; 27 | case 4: 28 | System.out.printf("April\n"); 29 | break; 30 | case 5: 31 | System.out.printf("May\n"); 32 | break; 33 | case 6: 34 | System.out.printf("June\n"); 35 | break; 36 | case 7: 37 | System.out.printf("July\n"); 38 | break; 39 | case 8: 40 | System.out.printf("August\n"); 41 | break; 42 | case 9: 43 | System.out.printf("September\n"); 44 | break; 45 | case 10: 46 | System.out.printf("October\n"); 47 | break; 48 | case 11: 49 | System.out.printf("November\n"); 50 | break; 51 | case 12: 52 | System.out.printf("December\n"); 53 | break; 54 | default: 55 | System.out.printf("Invalid input\n"); 56 | } 57 | } 58 | } -------------------------------------------------------------------------------- /Java/Primeiros desafios de código com Java/TesteDeSelecao1.java: -------------------------------------------------------------------------------- 1 | // Teste de Seleção 1 2 | 3 | /* 4 | Leia 4 valores inteiros A, B, C e D. Com base nisso, se o valor de B for maior 5 | do que de C e se D for maior do que A, e a soma de C com D for maior que a soma 6 | de A e B e se tanto C quanto D forem positivos e, ainda, se a variável A for 7 | par, escreva a mensagem "Valores aceitos", senão escrever "Valores nao aceitos". 8 | 9 | - Entrada 10 | 11 | Quatro números inteiros A, B, C e D. 12 | 13 | - Saída 14 | 15 | Imprima a mensagem corretamente esperada pela validação dos valores. 16 | */ 17 | 18 | import java.util.Scanner; 19 | 20 | public class Problem{ 21 | public static void main(String[] args) throws Exception { 22 | Scanner scan = new Scanner(System.in); 23 | 24 | int a = scan.nextInt(); 25 | int b = scan.nextInt(); 26 | int c = scan.nextInt(); 27 | int d = scan.nextInt(); 28 | 29 | if (b > c && d > a && (c + d) > (a + b) && c > 0 && d > 0 && a % 2 == 0) { 30 | System.out.println("Valores aceitos"); 31 | } else { 32 | System.out.println("Valores nao aceitos"); 33 | } 34 | } 35 | } -------------------------------------------------------------------------------- /Java/Primeiros desafios de código com Java/ValidacaoDeNota.java: -------------------------------------------------------------------------------- 1 | // Validação de Nota 2 | 3 | /* 4 | Para ajudar a calcular as notas referentes às duas avaliações dos alunos, uma 5 | professora pediu para que você desenvolva um programa que calcule e imprima a 6 | média semestral. Faça com que o algoritmo só aceite notas válidas (uma nota 7 | válida deve pertencer ao intervalo [0,10]). Cada nota deve ser validada 8 | separadamente. 9 | 10 | - Entrada 11 | 12 | A entrada contém vários valores reais, positivos ou negativos. O programa deve 13 | ser encerrado quando forem lidas duas notas válidas. 14 | 15 | - Saída 16 | 17 | Se uma nota inválida for lida, deve ser impressa a mensagem "nota invalida". 18 | Quando duas notas válidas forem lidas, deve ser impressa a mensagem "media = " 19 | seguido do valor do cálculo. O valor deve ser apresentado com duas casas após 20 | o ponto decimal. 21 | */ 22 | 23 | import java.util.Scanner; 24 | 25 | public class Problem { 26 | public static void main(String[] args) throws Exception { 27 | Scanner leitor = new Scanner(System.in); 28 | double somaDasNotas = 0; 29 | int contador = 0; 30 | 31 | do { 32 | double notaEntradaConsole = leitor.nextDouble(); 33 | 34 | if (notaEntradaConsole < 0 || notaEntradaConsole > 10) { 35 | System.out.println("nota invalida"); 36 | } else { 37 | contador++; 38 | somaDasNotas += notaEntradaConsole; 39 | } 40 | } while (contador < 2); 41 | 42 | System.out.printf("media = " + String.format("%.2f", somaDasNotas / 2)); 43 | } 44 | } -------------------------------------------------------------------------------- /Java/Primeiros passos com Java/Distancia.java: -------------------------------------------------------------------------------- 1 | // Distância 2 | 3 | /* 4 | Duas motos (X e Y) partem em uma mesma direção. A moto X sai com velocidade 5 | constante de 60 Km/h e a moto Y sai com velocidade constante de 90 Km/h. 6 | 7 | Em uma hora (60 minutos) a moto Y consegue se distanciar 30 quilômetros da moto 8 | X, ou seja, consegue se afastar um quilômetro a cada 2 minutos. 9 | 10 | O seu desafio é ler a distância (em Km) e calcular quanto tempo leva 11 | (em minutos) para a moto Y tomar essa distância da outra moto. 12 | 13 | - Entrada 14 | 15 | O arquivo de entrada contém um número inteiro K que representa a quantidade de 16 | quilômetro que que a moto Y deve estar da moto X. 17 | 18 | - Saída 19 | 20 | Imprima o tempo necessário para a moto Y ficar com a quantidade K de quilômetro 21 | da moto X, seguido da mensagem " minutos". 22 | */ 23 | 24 | import java.util.Scanner; 25 | 26 | public class Test { 27 | public static void main(String[] args) { 28 | int minutos; 29 | Scanner input = new Scanner(System.in); 30 | 31 | minutos = input.nextInt(); 32 | System.out.printf("%d minutos\n", 2 * minutos); 33 | } 34 | } -------------------------------------------------------------------------------- /Java/Primeiros passos com Java/DividindoXPorY.java: -------------------------------------------------------------------------------- 1 | // Dividindo X por Y 2 | 3 | /* 4 | Você terá o desafio de escrever um algoritmo que leia 2 números e imprima o 5 | resultado da divisão do primeiro pelo segundo. Caso não for possível, mostre a 6 | mensagem “divisao impossivel” para os valores em questão. 7 | 8 | - Entrada 9 | 10 | A entrada contém um número inteiro N. Este N será a quantidade de pares de 11 | valores inteiros (X e Y) que serão lidos em seguida. 12 | 13 | - Saída 14 | 15 | Para cada caso mostre o resultado da divisão com um dígito após o ponto 16 | decimal, ou “divisao impossivel” caso não seja possível efetuar o cálculo. 17 | */ 18 | 19 | import java.util.Scanner; 20 | 21 | public class Divisao { 22 | public static void main(String[] args) { 23 | Scanner input = new Scanner(System.in); 24 | int n = input.nextInt(); 25 | 26 | for (int i = 0; i < n; i++) { 27 | double x = input.nextDouble(); 28 | double y = input.nextDouble(); 29 | 30 | if (y == 0) { 31 | System.out.println("divisao impossivel"); 32 | } else { 33 | System.out.printf("%.1f\n", (double)(x/y)); 34 | } 35 | } 36 | } 37 | } -------------------------------------------------------------------------------- /Java/Primeiros passos com Java/SomaSimples.java: -------------------------------------------------------------------------------- 1 | // Soma Simples 2 | 3 | /* 4 | Leia dois valores inteiros identificados como variáveis A e B. Calcule a soma 5 | entre elas e chame essa variável de SOMA. 6 | A seguir escreva o valor desta variável. 7 | 8 | - Entrada 9 | 10 | O arquivo de entrada contém 2 valores inteiros. 11 | 12 | - Saída 13 | 14 | Imprima a variável SOMA com todas as letras maiúsculas, inserindo um espaço 15 | em branco antes e depois do símbolo de igualdade, seguido pelo valor 16 | correspondente à soma de A e B. 17 | */ 18 | 19 | import java.util.Scanner; 20 | 21 | public class SomaSimples { 22 | public static void main(String[] args) { 23 | Scanner ler = new Scanner(System.in); 24 | int A, B, soma = 0; 25 | 26 | A = ler.nextInt(); 27 | B = ler.nextInt(); 28 | 29 | soma = A + B; 30 | System.out.println( "SOMA = " + soma); 31 | } 32 | } -------------------------------------------------------------------------------- /Java/Primeiros passos em Java/Diferenca.java: -------------------------------------------------------------------------------- 1 | // Diferença 2 | 3 | /* 4 | Leia quatro valores inteiros A, B, C e D. A seguir, calcule e mostre a 5 | diferença do produto de A e B pelo produto de C e D segundo a fórmula: 6 | DIFERENCA = (A * B - C * D). 7 | 8 | - Entrada 9 | 10 | O arquivo de entrada contém 4 valores inteiros. 11 | 12 | - Saída 13 | 14 | Imprima a mensagem DIFERENCA com todas as letras maiúsculas, conforme exemplo 15 | abaixo, com um espaço em branco antes e depois da igualdade. 16 | */ 17 | 18 | import java.io.IOException; 19 | import java.util.Scanner; 20 | 21 | public class Desafio { 22 | public static void main(String[] args) throws IOException { 23 | Scanner leitor = new Scanner(System.in); 24 | int A = leitor.nextInt(); 25 | int B = leitor.nextInt(); 26 | int C = leitor.nextInt(); 27 | int D = leitor.nextInt(); 28 | 29 | System.out.println("DIFERENCA = " + (A * B - C * D)); 30 | } 31 | } -------------------------------------------------------------------------------- /Java/Primeiros passos em Java/Divisores.java: -------------------------------------------------------------------------------- 1 | // Divisores I 2 | 3 | /* 4 | Ler um número inteiro N e calcular todos os seus divisores. 5 | 6 | - Entrada 7 | 8 | O arquivo de entrada contém um valor inteiro. 9 | 10 | - Saída 11 | 12 | Escreva todos os divisores positivos de N, um valor por linha. 13 | */ 14 | 15 | import java.io.IOException; 16 | import java.util.Scanner; 17 | 18 | public class Divisores { 19 | public static void main(String[] args) throws IOException { 20 | Scanner leitor = new Scanner(System.in); 21 | int N = leitor.nextInt(); 22 | 23 | for (int i = 1; i <= N; i++) { 24 | if (N % i == 0) 25 | System.out.println(i); 26 | } 27 | leitor.close(); 28 | } 29 | } -------------------------------------------------------------------------------- /Java/Primeiros passos em Java/ParesEntreCincoNumeros.java: -------------------------------------------------------------------------------- 1 | // Pares entre Cinco Números 2 | 3 | /* 4 | Faça um programa que leia 5 valores inteiros. Conte quantos destes valores 5 | digitados são pares e mostre esta informação. 6 | 7 | - Entrada 8 | 9 | O arquivo de entrada contém 5 valores inteiros quaisquer. 10 | 11 | - Saída 12 | 13 | Imprima a mensagem conforme o exemplo fornecido, indicando a quantidade de 14 | valores pares lidos. 15 | */ 16 | 17 | import java.util.Scanner; 18 | 19 | public class Problem { 20 | public static void main(String[] args) throws Exception { 21 | Scanner scan = new Scanner(System.in); 22 | int count = 0; 23 | 24 | for(int i = 0; i < 5; i++) { 25 | int n = scan.nextInt(); 26 | 27 | if (n % 2 == 0) { 28 | count++; 29 | } 30 | } 31 | 32 | 33 | System.out.printf("%d valores pares\n", count); 34 | } 35 | } -------------------------------------------------------------------------------- /Java/Resolvendo Desafios Intermediários em Java/SenhaFixa.java: -------------------------------------------------------------------------------- 1 | // Senha Fixa 2 | 3 | /* 4 | Escreva um programa que repita a leitura de uma senha até que ela seja válida. 5 | Para cada leitura de senha incorreta informada, escrever a mensagem "Senha 6 | Invalida". Quando a senha for informada corretamente deve ser impressa a 7 | mensagem "Acesso Permitido" e o algoritmo encerrado. Considere que a senha 8 | correta é o valor 2002. 9 | 10 | - Entrada 11 | 12 | A entrada é composta por vários casos de testes contendo valores inteiros. 13 | 14 | - Saída 15 | 16 | Para cada valor lido mostre a mensagem correspondente à descrição do problema. 17 | */ 18 | 19 | import java.io.IOException; 20 | import java.util.Scanner; 21 | 22 | public class Teste { 23 | public static void main(String[] args) throws IOException { 24 | Scanner leitor = new Scanner(System.in); 25 | int senha = leitor.nextInt(); 26 | 27 | while (senha != 2002) { 28 | System.out.println("Senha Invalida"); 29 | senha = leitor.nextInt(); 30 | } 31 | System.out.println("Acesso Permitido"); 32 | } 33 | } -------------------------------------------------------------------------------- /Java/Resolvendo Desafios em Java/PreenchimentoVetorIII.java: -------------------------------------------------------------------------------- 1 | // Preenchimento de Vetor III 2 | 3 | /* 4 | Leia um valor X. Coloque este valor na primeira posição de um vetor N[100]. 5 | Em cada posição subsequente de N (1 até 99), coloque a metade do valor 6 | armazenado na posição anterior, conforme o exemplo abaixo. Imprima o vetor N. 7 | 8 | - Entrada 9 | 10 | A entrada contem um valor de dupla precisão com 4 casas decimais. 11 | 12 | - Saída 13 | 14 | Para cada posição do vetor N, escreva "N[i] = Y", onde i é a posição do vetor 15 | e Y é o valor armazenado naquela posição. Cada valor do vetor deve ser 16 | apresentado com 4 casas decimais. 17 | */ 18 | 19 | import java.io.IOException; 20 | import java.util.Scanner; 21 | import java.math.BigDecimal; 22 | import java.math.RoundingMode; 23 | import java.text.DecimalFormat; 24 | import java.util.Locale; 25 | 26 | public class PreenchimentoVetorIII { 27 | public static void main(String[] args) { 28 | Locale.setDefault(Locale.US); 29 | Scanner leitor = new Scanner(System.in); 30 | double X = 0; 31 | 32 | X = leitor.nextDouble(); 33 | BigDecimal[] N = new BigDecimal[100]; 34 | N[0] = new BigDecimal(X); 35 | 36 | for (int i = 1; i < 100; ++i) { 37 | N[i] = N[i - 1].divide(new BigDecimal(2)); 38 | } 39 | 40 | leitor.close(); 41 | DecimalFormat decFormat = new DecimalFormat("0.0000"); 42 | 43 | for (int i = 0; i < 100; ++i) { 44 | System.out.println("N[" + i + "] = " + decFormat.format(N[i])); 45 | } 46 | } 47 | } -------------------------------------------------------------------------------- /Java/Resolvendo Desafios médios em Java/CrescenteEDecrescente.java: -------------------------------------------------------------------------------- 1 | // Crescente e Decrescente 2 | 3 | /* 4 | Leia uma quantidade indeterminada de duplas de valores inteiros X e Y. Para 5 | cada X e Y, escreva uma mensagem para indicar se tais valores foram digitados 6 | em ordem crescente ou decrescente. 7 | 8 | - Entrada 9 | 10 | A entrada é composta por vários casos de teste. Cada caso contém dois valores 11 | inteiros: X e Y. A leitura deve ser encerrada caso sejam fornecidos os mesmos 12 | valores para X e Y. 13 | 14 | - Saída 15 | 16 | Caso os valores tenham sido digitados na ordem crescente, imprima “Crescente”. 17 | No contrário, “Decrescente”. 18 | */ 19 | 20 | import java.io.IOException; 21 | import java.util.Scanner; 22 | 23 | public class Teste { 24 | public static void main(String[] args) throws IOException { 25 | Scanner leitor = new Scanner(System.in); 26 | int X = leitor.nextInt(); 27 | int Y = leitor.nextInt(); 28 | 29 | while (X != Y) { 30 | if (X > Y) System.out.println("Decrescente"); 31 | else System.out.println("Crescente"); 32 | X = leitor.nextInt(); 33 | Y = leitor.nextInt(); 34 | } 35 | } 36 | } -------------------------------------------------------------------------------- /Java/Solucionando problemas básicos em Java/NumerosImpares.java: -------------------------------------------------------------------------------- 1 | // Números Ímpares 2 | 3 | /* 4 | Leia um valor inteiro X (1 <= X <= 1000). Em seguida mostre os ímpares de 1 até 5 | X, um valor por linha, inclusive o X, se for o caso. 6 | 7 | - Entrada 8 | 9 | O arquivo de entrada contém 1 valor inteiro qualquer. 10 | 11 | - Saída 12 | 13 | Imprima todos os valores ímpares de 1 até X, inclusive X, se for o caso. 14 | */ 15 | 16 | import java.util.Scanner; 17 | 18 | public class NumerosImpares { 19 | public static void main(String[] args) { 20 | Scanner entrada = new Scanner(System.in); 21 | int num = entrada.nextInt(); 22 | 23 | for (int i = 0; i <= num; i++) { 24 | if (i % 2 == 1) { 25 | System.out.println(i); 26 | } 27 | } 28 | } 29 | 30 | } -------------------------------------------------------------------------------- /Java/Solução de problemas básicos em Java/ExibindoNumerosPares.java: -------------------------------------------------------------------------------- 1 | // Exibindo Números Pares 2 | 3 | /* Crie um programa que leia um número e mostre os números pares até esse 4 | número, inclusive ele mesmo. 5 | 6 | - Entrada 7 | 8 | Você receberá 1 valor inteiro N, onde N > 0. 9 | 10 | - Saída 11 | 12 | Exiba todos os números pares até o valor de entrada, sendo um em cada linha. 13 | */ 14 | 15 | import java.io.BufferedReader; 16 | import java.io.IOException; 17 | import java.io.InputStreamReader; 18 | 19 | public class ExibindoNumerosPares { 20 | public static void main(String[] args) throws IOException { 21 | String entrada; 22 | BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 23 | entrada = br.readLine(); 24 | 25 | for (int i = 2; i <= Integer.parseInt(entrada); i++) { 26 | if (i % 2 == 0) { 27 | System.out.println(i); 28 | } 29 | } 30 | } 31 | } -------------------------------------------------------------------------------- /Java/Solução de problemas básicos em Java/IdadeEmDias.java: -------------------------------------------------------------------------------- 1 | // Idade em Dias 2 | 3 | /* Você terá o desafio de ler um valor inteiro correspondente à idade de uma 4 | pessoa em dias e informe-a em anos, meses e dias 5 | 6 | Obs.: apenas para facilitar o cálculo, considere todo ano com 365 dias e todo 7 | mês com 30 dias. Nos casos de teste nunca haverá uma situação que permite 12 8 | meses e alguns dias, como 360, 363 ou 364. 9 | 10 | - Entrada 11 | 12 | O arquivo de entrada contém um valor inteiro. 13 | 14 | - Saída 15 | 16 | Imprima a saída conforme exemplo fornecido. */ 17 | 18 | import java.util.Scanner; 19 | 20 | public class IdadeEmDias { 21 | public static void main(String[] args) { 22 | Scanner input = new Scanner(System.in); 23 | 24 | int idadeDias = input.nextInt(); 25 | int anos = idadeDias / 365; 26 | int meses = ((idadeDias % 365) / 30); 27 | int dias = ((idadeDias % 365) % 30); 28 | 29 | System.out.println(anos + " ano(s)"); 30 | System.out.println(meses + " mes(es)"); 31 | System.out.println(dias + " dia(s)"); 32 | 33 | input.close(); 34 | } 35 | } -------------------------------------------------------------------------------- /JavaScript/Busca e Laços de Repetição/degustacao-de-vinho.js: -------------------------------------------------------------------------------- 1 | // Degustação de vinho 2 | 3 | /* Degustação de vinho às escuras é a habilidade de identificar um vinho usando 4 | apenas seus sentidos do olfato e paladar. 5 | 6 | Durante uma competição de degustação, uma garrafa de vinho é aberta e dividia 7 | em taças para que os cinco competidores possam provar. Eles podem cheiras, 8 | saborear e avaliar a bebida para conseguir identificar qual o tipo do vinho, 9 | sendo: (1) Cabernet; (2) Merlot; (3) Pinot Noir. No final, as respostas são 10 | verificadas para determinar o número de suposições corretas. 11 | 12 | Dado o qual foi o tipo do vinho e as respostas fornecidas, determine o número 13 | de participantes que receberam a resposta correta. 14 | 15 | - Entrada 16 | 17 | A primeira linha contém um inteiro T representando o tipo de vinho (1 ≤ T ≤ 4). 18 | A segunda linha contém cinco inteiros A, B, C, D e E, que indica a resposta 19 | dada por cada competidor (1 ≤ A, B, C, D, E ≤ 4). 20 | 21 | - Saída 22 | 23 | A saída contém um inteiro representando o número de concorrentes que obtiveram 24 | a resposta correta. */ 25 | 26 | let wineNumber = gets(); 27 | let wineTesters = gets().split(' '); 28 | let correctAnswers = 0; 29 | 30 | let correctAnswersList = wineTesters.filter(correctAnswers => correctAnswers.includes(wineNumber)); 31 | correctAnswers = correctAnswersList.length; 32 | 33 | console.log(correctAnswers); -------------------------------------------------------------------------------- /JavaScript/Busca e Laços de Repetição/pink-e-cerebro.js: -------------------------------------------------------------------------------- 1 | // Pink e Cérebro 2 | 3 | /* Pink e Cérebro dividem um apartamento e estão juntos 24h por dia desde o 4 | começo da pandemia. Para passar o temp, Pink cria problemas matemáticos para 5 | Cérebro resolver, o último deles foi uma lista de números com a seguinte 6 | pergunta: quantos números da lista são múltiplos de 2, 3, 4 e 5? 7 | 8 | Apesar de parecer simples, porém, quando a lista contém muitos números, Cérebro 9 | se confunde e acaba errando alguns cálculos. 10 | 11 | Ajude Cérebro a resolver o desadio de Pink. 12 | 13 | - Entrada 14 | 15 | A primeira linha da entrada consiste em um inteiro N (1 ≤ N ≤1000), 16 | representando a quantidade de números na lista de Pink. 17 | 18 | A segunda linha contém N inteiros Li (1 ≤ Li ≤ 100), representando os números 19 | da lista de Pink. 20 | 21 | - Saída 22 | 23 | Imprima a quantidade de números múltiplos de 2, 3, 4 e 5 presentes na lista. 24 | Observe a formatação da saída nos exemplos, pois ela deve ser seguida 25 | rigorosamente. */ 26 | 27 | let n = gets(); 28 | let lis = gets().split(' '); 29 | let increment = 0; 30 | 31 | for (let mlt = 0; mlt <= 3; mlt++) { 32 | lis.forEach(li => { 33 | if (li % (mlt + 2) == 0) { 34 | increment++; 35 | } 36 | }) 37 | 38 | console.log(`${increment} Multiplo(s) de ${mlt + 2}`) 39 | increment = 0; 40 | } -------------------------------------------------------------------------------- /JavaScript/Desafio Aritmético em JavaScript/NomeNoFormulario.js: -------------------------------------------------------------------------------- 1 | // Nome no Formulário 2 | 3 | /* 4 | Preencher formulários é uma tarefa simples. Mas é preciso conferir se o espaço 5 | reservado para os dados é suficiente. 6 | 7 | Sua tarefa é, dada uma linha de texto, indicar se ele cabe ou não cabe em um 8 | formulário com 80 caracteres. 9 | 10 | - Entrada 11 | 12 | A entrada é uma linha de texto L (1 ≤ |L| ≤ 500). 13 | 14 | - Saída 15 | 16 | A saída é dada em uma única linha. Ela deve ser "YES" (sem as aspas) se a 17 | linha de texto L tem até 80 caracteres. Se L tem mais de 80 caracteres, a 18 | saída deve ser "NO". 19 | */ 20 | 21 | let nome = gets(); 22 | console.log(nome.length > 80 ? "NO" : "YES"); -------------------------------------------------------------------------------- /JavaScript/Desafio Aritmético em JavaScript/PositivosEMedia.js: -------------------------------------------------------------------------------- 1 | // Positivos e Média 2 | 3 | /* 4 | Leia 6 valores. Em seguida, mostre quantos destes valores digitados foram 5 | positivos. Na próxima linha, deve-se mostrar a média de todos os valores 6 | positivos digitados, com um dígito após o ponto decimal. 7 | 8 | - Entrada 9 | 10 | A entrada contém 6 números que podem ser valores inteiros ou de ponto flutuante. 11 | Pelo menos um destes números será positivo. 12 | 13 | - Saída 14 | 15 | O primeiro valor de saída é a quantidade de valores positivos. A próxima linha 16 | deve mostrar a média dos valores positivos digitados. 17 | */ 18 | 19 | let total = 0; 20 | let i = 0; 21 | let valor = 0; 22 | let valortotal = 0; 23 | 24 | while (i <= 6) { 25 | valor = parseFloat(gets()); 26 | 27 | if (valor >= 0) { 28 | total = total + 1; 29 | valortotal += valor; 30 | } 31 | 32 | i = i + 1; 33 | } 34 | 35 | media = valortotal / total; 36 | const calc = (media - parseInt(media)).toFixed(1) == 0.3 ? parseInt(media) + 0.2 : media.toFixed(1); 37 | console.log(total + " valores positivos"); 38 | console.log(calc); -------------------------------------------------------------------------------- /JavaScript/Desafios Aritméticos em JavaScript/fibonacci-facil.js: -------------------------------------------------------------------------------- 1 | // Fibonacci Fácil 2 | 3 | /* 4 | A seguinte sequência de números 0 1 1 2 3 5 8 13 21... é conhecida como série 5 | de Fibonacci. Nessa sequência, cada número, depois dos 2 primeiros, é igual à 6 | soma dos 2 anteriores. Escreva um algoritmo que leia um inteiro N (N < 46) e 7 | mostre os N primeiros números dessa série. 8 | 9 | • Entrada 10 | 11 | O arquivo de entrada contém um valor inteiro N (0 < N < 46). 12 | 13 | • Saída 14 | 15 | Os valores devem ser mostrados na mesma linha, separados por um espaço em 16 | branco. Não deve haver espaço após o último valor. 17 | */ 18 | 19 | const input = parseInt(gets()); 20 | 21 | const fib = n => { 22 | if (n <= 1) { 23 | return [0, 1]; 24 | } else { 25 | const s = fib(n-1); 26 | s.push(s[s.length - 1] + s[s.length - 2]); 27 | return s; 28 | } 29 | }; 30 | 31 | if (input === 1){ 32 | console.log('0') 33 | } 34 | else if (input > 0 && input < 46){ 35 | const index = Number(input) - 1; 36 | const sequence = fib(index).join(" "); 37 | console.log(sequence); 38 | } -------------------------------------------------------------------------------- /JavaScript/Desafios Aritméticos em JavaScript/preenchimento-vetor-I.js: -------------------------------------------------------------------------------- 1 | // Preenchimento de Vetor I 2 | 3 | /* 4 | Você recebeu o desafio de ler um valor e criar um programa que coloque o valor 5 | lido na primeira posição de um vetor N[10]. Em cada posição subsequente, 6 | coloque o dobro do valor da posição anterior. Por exemplo, se o valor lido for 7 | 1, os valores do vetor devem ser 1,2,4,8 e assim sucessivamente. Mostre o vetor 8 | em seguida. 9 | 10 | • Entrada 11 | 12 | A entrada contém um valor inteiro (V<=50). 13 | 14 | • Saída 15 | 16 | Para cada posição do vetor, escreva "N[i] = X", onde i é a posição do vetor e 17 | X é o valor armazenado na posição i. O primeiro número do vetor N (N[0]) irá 18 | receber o valor de V. 19 | */ 20 | 21 | const input = gets(); 22 | let a = input; 23 | 24 | for (let cont = 0; cont < 10; cont++) { 25 | console.log(`N[${cont}] = ${a}`); 26 | a = a * 2; 27 | } -------------------------------------------------------------------------------- /JavaScript/Desafios Aritméticos em JavaScript/substituicao-vetor-I.js: -------------------------------------------------------------------------------- 1 | // Substituição em Vetor I 2 | 3 | /* 4 | Você recebeu o desafio de ler um valor e criar um programa que coloque o valor 5 | lido na primeira posição de um vetor N[10]. Em cada posição subsequente, 6 | coloque o dobro do valor da posição anterior. Por exemplo, se o valor lido for 7 | 1, os valores do vetor devem ser 1,2,4,8 e assim sucessivamente. Mostre o vetor 8 | em seguida. 9 | 10 | • Entrada 11 | 12 | A entrada contém um valor inteiro (V<=50). 13 | 14 | • Saída 15 | 16 | Para cada posição do vetor, escreva "N[i] = X", onde i é a posição do vetor e 17 | X é o valor armazenado na posição i. O primeiro número do vetor N (N[0]) irá 18 | receber o valor de V. 19 | */ 20 | 21 | function vetorI() { 22 | for (let i = 0; i < 10; i++) { 23 | let X = parseInt(gets()); 24 | 25 | if (X <= 0 ) { 26 | X = 1; 27 | } 28 | 29 | console.log(`X[${i}] = ${X}`); 30 | } 31 | } 32 | vetorI(); -------------------------------------------------------------------------------- /JavaScript/Desafios Aritméticos em JavaScript/teorema-da-divisao-euclidiana.js: -------------------------------------------------------------------------------- 1 | // Teorema da Divisão Euclidiana 2 | 3 | /* Você recebeu desafio de desenvolver um programa que calcule o quociente e o 4 | resto da divisão de dois números inteiros. Não se esqueça que o quociente e o 5 | resto da divisão de um inteiro a por um inteiro não-nulo b são respectivamente 6 | os únicos inteiros q e r tais que: 7 | 8 | 0 ≤ r < |b| 9 | Se r < 0: r = r - |b| 10 | a = b × q + r 11 | q = ( a - r ) / b 12 | 13 | Caso você não saiba, o teorema que garante a existência e a unicidade dos 14 | inteiros q e r é conhecido como ‘Teorema da Divisão Euclidiana’ ou ‘Algoritmo 15 | da Divisão’. 16 | ** |b| (Módulo / Valor absoluto): É o valor representado de forma positiva; 17 | 18 | - Entrada 19 | 20 | A entrada é composta por dois números inteiros a e b (-1.000 ≤ a, b < 1.000). 21 | 22 | - Saída 23 | 24 | Imprima o quociente q seguido pelo resto r da divisão de a por b, considerando 25 | as regras apresentadas a cima. */ 26 | 27 | let numbers = gets('-7 -3').split(" "); 28 | let a = parseInt(numbers[0]); 29 | let b = parseInt(numbers[1]); 30 | 31 | let r = a % b < 0 ? Math.abs(b) + a % b : a % b; 32 | let q = (a - r) / b 33 | 34 | console.log(q, r); 35 | -------------------------------------------------------------------------------- /JavaScript/Desafios Iniciais JavaScript/Intervalo.js: -------------------------------------------------------------------------------- 1 | // Intervalo 2 | 3 | /* 4 | Faça um programa que leia um valor qualquer e apresente uma mensagem dizendo 5 | em qual dos seguintes intervalos ([0,25], (25,50], (50,75], (75,100]) este 6 | valor se encontra. Caso o valor não esteja em nenhum destes intervalos, deverá 7 | ser impressa a mensagem: “Fora de intervalo”. 8 | 9 | O símbolo ( representa "maior que". Por exemplo: 10 | [0,25] indica valores entre 0 e 25.0000, inclusive eles. 11 | (25,50] indica valores maiores que 25 Ex: 25.00001 até o valor 50.0000000 12 | 13 | - Entrada 14 | 15 | O arquivo de entrada contém um número com ponto flutuante qualquer. 16 | 17 | - Saída 18 | 19 | A saída deve ser uma mensagem conforme exemplo abaixo. 20 | */ 21 | 22 | let X = parseFloat(gets()); 23 | 24 | if (X>=0 && X<=25) { 25 | print("Intervalo [0,25]" ); 26 | } else if (X > 25 && X <= 50) { 27 | print("Intervalo (25,50]"); 28 | } else if (X > 50 && X <= 75 ) { 29 | print("Intervalo (50,75]"); 30 | } else if (X <= 100) { 31 | print("Intervalo (75,100]"); 32 | } else { 33 | print("Fora de intervalo"); 34 | } -------------------------------------------------------------------------------- /JavaScript/Desafios Iniciais JavaScript/Tabuada.js: -------------------------------------------------------------------------------- 1 | // Tabuada 2 | 3 | /* 4 | Leia 1 valor inteiro N (2 < N < 1000). A seguir, mostre a tabuada de N: 5 | 6 | 1 x N = N 2 x N = 2N ... 10 x N = 10N 7 | 8 | - Entrada 9 | 10 | A entrada contém um valor inteiro N (2 < N < 1000). 11 | 12 | - Saída 13 | 14 | Imprima a tabuada de N, conforme o exemplo fornecido. 15 | */ 16 | 17 | let N = gets(); 18 | 19 | print("1 x " + N + " = " + (N * 1)); 20 | print("2 x " + N + " = " + (N * 2)); 21 | print("3 x " + N + " = " + (N * 3)); 22 | print("4 x " + N + " = " + (N * 4)); 23 | print("5 x " + N + " = " + (N * 5)); 24 | print("6 x " + N + " = " + (N * 6)); 25 | print("7 x " + N + " = " + (N * 7)); 26 | print("8 x " + N + " = " + (N * 8)); 27 | print("9 x " + N + " = " + (N * 9)); 28 | print("10 x " + N + " = " + (N * 10)); -------------------------------------------------------------------------------- /JavaScript/Desafios Lógicos/brinquedos-do-papai-noel.js: -------------------------------------------------------------------------------- 1 | // Brinquedos do Papai Noel 2 | 3 | /* Papai Noel todo ano pede ajuda aos elfos para coletar todas as cartinhas 4 | das crianças e saber com o quê presenteá-las. Porém, não são todas as crianças 5 | que enviam as suas cartinhas e, como ele não quer deixar ninguém de fora, 6 | decidiu que vai presentear mesmo quem não enviou a cartinha. Pensando em um 7 | gosto geral, decidiu dar um carrinho de brinquedo para os meninos, e uma 8 | boneca para as meninas. 9 | 10 | - Entrada 11 | 12 | A primeira linha da entrada possui um inteiro N (0 < N ≤ 1000), que 13 | representa o número de crianças que não enviaram sua cartinha para o Papai 14 | Noel. As próximas N linhas consistem em duas strings, a primeira é o nome da 15 | criança, e a segunda é uma letra, que pode ser ‘M’, para dizer que é um 16 | menino, ou ‘F’ se for uma menina. 17 | 18 | - Saída 19 | 20 | A saída consiste em 2 linhas. A primeira linha deve conter o número de 21 | carrinhos que o Papai Noel deve fazer, seguido pela palavra “carrinhos”, e 22 | na segunda linha, o número de bonecas seguido pela palavra “bonecas”. */ 23 | 24 | let kids = gets(); 25 | let girls = 0; 26 | let boys = 0; 27 | 28 | for (let i = 0; i < kids; i++) { 29 | let nameGender = gets().split(" "); 30 | let name = nameGender[0]; 31 | let gender = nameGender[1]; 32 | 33 | if (gender === 'F') { 34 | girls++ 35 | } 36 | 37 | if (gender === 'M') { 38 | boys++ 39 | } 40 | } 41 | 42 | console.log(boys + " carrinhos") 43 | console.log(girls + " bonecas") -------------------------------------------------------------------------------- /JavaScript/Desafios Médios JavaScript/PoligonosRegularesSimples.js: -------------------------------------------------------------------------------- 1 | // Polígonos Regulares Simples 2 | 3 | /* 4 | Na geometria Euclidiana, um polígono regular é um polígono em que todos os 5 | ângulos são iguais e todos os lados tem o mesmo comprimento. Um polígono 6 | simples é aquele cujos segmentos de reta não se interceptam. Abaixo pode-se ver 7 | vários mosaicos feitos por polígonos regulares. 8 | 9 | vide imagem em assets 10 | 11 | Você deve escrever um programa que, dados o número e o comprimento dos lados 12 | de um polígono regular, mostre seu perímetro. 13 | 14 | - Entrada 15 | 16 | A entrada tem dois inteiros positivos: N e L, que são, respectivamente, o 17 | número de lados e o comprimento de cada lado de um polígono regular 18 | (3 ≤ N ≤ 1000000 and 1 ≤ L ≤ 4000). 19 | 20 | - Saída 21 | 22 | A saída é o perímetro P do polígono regular em uma única linha. 23 | */ 24 | 25 | let lines = gets().split("\n"); 26 | let line = lines.shift().split(' '); 27 | 28 | const N = line[0] 29 | const L = line[1] 30 | const P = Number(N) * Number(L) 31 | 32 | print(P); -------------------------------------------------------------------------------- /JavaScript/Desafios avançados de código em JavaScript/Diferenca.js: -------------------------------------------------------------------------------- 1 | // Diferença 2 | 3 | /* 4 | Leia quatro valores inteiros A, B, C e D. A seguir, calcule e mostre a 5 | diferença do produto de A e B pelo produto de C e D segundo a fórmula: 6 | DIFERENCA = (A * B - C * D). 7 | 8 | - Entrada 9 | 10 | O arquivo de entrada contém 4 valores inteiros. 11 | 12 | - Saída 13 | 14 | Imprima a mensagem DIFERENCA com todas as letras maiúsculas, conforme exemplo 15 | abaixo, com um espaço em branco antes e depois da igualdade. 16 | */ 17 | 18 | var A = gets(); 19 | var B = gets(); 20 | var C = gets(); 21 | var D = gets(); 22 | 23 | var DIFERENCA = (A * B - C * D); 24 | console.log("DIFERENCA = " + DIFERENCA); -------------------------------------------------------------------------------- /JavaScript/Fundamentos Aritméticos em JavaScript/analise-de-numeros.js: -------------------------------------------------------------------------------- 1 | // Análise de Números 2 | 3 | /* Você deve fazer a leitura de 5 valores inteiros. Em seguida mostre quantos 4 | valores informados são pares, quantos valores informados são ímpares, quantos 5 | valores informados são positivos e quantos valores informados são negativos. 6 | 7 | - Entrada 8 | 9 | Você receberá 5 valores inteiros. 10 | 11 | - Saída 12 | 13 | Exiba a mensagem conforme o exemplo de saída abaixo, sendo uma mensagem por 14 | linha e não esquecendo o final de linha após cada uma. */ 15 | 16 | let a = parseInt(gets()); 17 | let b = parseInt(gets()); 18 | let c = parseInt(gets()); 19 | let d = parseInt(gets()); 20 | let e = parseInt(gets()); 21 | let valores = [a, b, c, d, e]; 22 | let pares = 0; 23 | let impares = 0; 24 | 25 | for (valor of valores) { 26 | if (valor % 2 == 0) { 27 | pares++; 28 | } else { 29 | impares++; 30 | } 31 | } 32 | 33 | let positivos = valores.filter(valor => valor > 0).length; 34 | let negativos = valores.filter(valor => valor < 0).length; 35 | 36 | console.log(pares + " valor(es) par(es)"); 37 | console.log(impares + " valor(es) impar(es)"); 38 | console.log(positivos + " valor(es) positivo(s)"); 39 | console.log(negativos + " valor(es) negativo(s)"); -------------------------------------------------------------------------------- /JavaScript/Fundamentos Aritméticos em JavaScript/consumo-medio-do-automovel.js: -------------------------------------------------------------------------------- 1 | // Consumo Médio do Automóvel 2 | 3 | /* Você deve calcular o consumo médio de um automóvel onde será informada a 4 | distância total percorrida (em Km) e o total de combustível consumido(em litros). 5 | 6 | - Entrada 7 | 8 | Você receberá dois valores: um valor inteiro X com a distância total percorrida 9 | (em Km, e um valor real Y que representa o total de combustível consumido, com 10 | um dígito após o ponto decimal. 11 | 12 | - Saída 13 | 14 | Exiba o valor que representa o consumo médio do automóvel (3 casas após a 15 | vírgula), incluindo no final a mensagem "km/l". */ 16 | 17 | let X = parseInt(gets()); 18 | let Y = parseFloat(gets()); 19 | let consumoMedio = parseFloat(X / Y).toFixed(3); 20 | 21 | console.log(consumoMedio + " km/l"); -------------------------------------------------------------------------------- /JavaScript/Fundamentos Aritméticos em JavaScript/contagem-de-cedulas.js: -------------------------------------------------------------------------------- 1 | // Contagem de Cédulas 2 | 3 | /* Faça a leitura de um valor inteiro. Em seguida, calcule o menor número de 4 | notas possíveis (cédulas) onde o valor pode ser decomposto. As notas que você 5 | deve considerar são de 100, 50, 20, 10, 5, 2 e 1. Na sequência mostre o valor 6 | lido e a relação de notas necessárias. 7 | 8 | - Entrada 9 | 10 | Você receberá um valor inteiro N (0 < N < 1000000). 11 | 12 | - Saída 13 | 14 | Exiba o valor lido e a quantidade mínima de notas de cada tipo necessárias, 15 | seguindo o exemplo de saída abaixo. Após cada linha deve ser imprimido o fim 16 | de linha. */ 17 | 18 | let notas = [100, 50, 20, 10, 5, 2, 1]; 19 | let nnotas = [0, 0, 0, 0, 0, 0, 0]; 20 | let quantia = parseInt(gets()); 21 | let resto = quantia; 22 | 23 | while (resto >= 1) { 24 | nota = notas.findIndex(value => value <= resto); 25 | nnotas[nota] = Math.trunc(resto / notas[nota]); 26 | resto = resto % notas[nota]; 27 | } 28 | 29 | console.log(quantia); 30 | console.log(nnotas[0] + " nota(s) de R$ 100,00"); 31 | console.log(nnotas[1] + " nota(s) de R$ 50,00"); 32 | console.log(nnotas[2] + " nota(s) de R$ 20,00"); 33 | console.log(nnotas[3] + " nota(s) de R$ 10,00"); 34 | console.log(nnotas[4] + " nota(s) de R$ 5,00"); 35 | console.log(nnotas[5] + " nota(s) de R$ 2,00"); 36 | console.log(nnotas[6] + " nota(s) de R$ 1,00"); -------------------------------------------------------------------------------- /JavaScript/Fundamentos Aritméticos em JavaScript/exibindo-numeros-pares.js: -------------------------------------------------------------------------------- 1 | // Exibindo Números Pares 2 | 3 | /* Crie um programa que leia um número e mostre os números pares até esse 4 | número, inclusive ele mesmo. 5 | 6 | - Entrada 7 | 8 | Você receberá 1 valor inteiro N, onde N > 0. 9 | 10 | - Saída 11 | 12 | Exiba todos os números pares até o valor de entrada, sendo um em cada linha. */ 13 | 14 | let numero = gets(); 15 | let par = 2; 16 | 17 | while (par <= numero) { 18 | console.log(par); 19 | par = par + 2; 20 | } -------------------------------------------------------------------------------- /JavaScript/Fundamentos Aritméticos em JavaScript/quantidade-de-numeros-positivos.js: -------------------------------------------------------------------------------- 1 | // Quantidade de Números Positivos 2 | 3 | /* Crie um programa que leia 6 valores. Você poderá receber valores negativos 4 | e/ou positivos como entrada, devendo desconsiderar os valores nulos. Em 5 | seguida, apresente a quantidade de valores positivos digitados. 6 | 7 | - Entrada 8 | 9 | Você receberá seis valores, negativos e/ou positivos. 10 | 11 | - Saída 12 | 13 | Exiba uma mensagem dizendo quantos valores positivos foram lidos assim como é 14 | exibido abaixo no exemplo de saída. Não esqueça da mensagem "valores positivos" 15 | ao final. */ 16 | 17 | var n1 = parseFloat(gets()); 18 | var n2 = parseFloat(gets()); 19 | var n3 = parseFloat(gets()); 20 | var n4 = parseFloat(gets()); 21 | var n5 = parseFloat(gets()); 22 | var n6 = parseFloat(gets()); 23 | var i = 0; 24 | 25 | if (n1 > 0) { 26 | i++ 27 | } 28 | 29 | if (n2 > 0) { 30 | i++ 31 | } 32 | 33 | if (n3 > 0) { 34 | i++ 35 | } 36 | 37 | if (n4 > 0) { 38 | i++ 39 | } 40 | 41 | if (n5 > 0) { 42 | i++ 43 | } 44 | 45 | if (n6 > 0) { 46 | i++ 47 | } 48 | 49 | console.log(i + " valores positivos"); -------------------------------------------------------------------------------- /JavaScript/Introdução a Busca e Substituição em JavaScript/ordenacao-de-palavras-por-tamanho.js: -------------------------------------------------------------------------------- 1 | // Ordenação de palavras por tamanho 2 | 3 | /* Crie um algoritmo para ordenar um conjunto de palavras pelo seu tamanho. Seu 4 | programa deve receber um conjunto de palavras e retornar este mesmo conjunto 5 | ordenado pelo tamanho das palavras decrescente, se o tamanho das palavras for 6 | igual, deve-se ordernar por ordem alfabética. 7 | 8 | - Entrada 9 | 10 | A primeira linha da entrada possui um único inteiro N, que indica o número de 11 | casos de teste. Cada caso de teste poderá conter de 1 a 50 palavras inclusive, 12 | e cada uma das palavras poderá conter entre 1 e 50 caracteres inclusive. Os 13 | caracteres poderão ser espaços, letras, ou números. 14 | 15 | - Saída 16 | 17 | A saída deve conter o conjunto de palavras da entrada ordenado pelo tamanho das 18 | palavras e caso o tamanho das palavras for igual, deve-se ordernar por ordem 19 | alfabética.. Um espaço em branco deve ser impresso entre duas palavras. */ 20 | 21 | let size = gets(); 22 | let line = ""; 23 | let worlds = []; 24 | let newLine = ""; 25 | 26 | if (size <= 50) { 27 | for (i = 0; i < size; i++) { 28 | line = gets(); 29 | words = line.split(" "); 30 | words.sort((a, b) => b.length - a.length || a.localeCompare(b)); 31 | newLine = words.join(" "); 32 | console.log(newLine); 33 | } 34 | } -------------------------------------------------------------------------------- /JavaScript/Introdução a Busca e Substituição em JavaScript/validador-de-senhas-com-requisitos.js: -------------------------------------------------------------------------------- 1 | // Validador de senhas com requisitos 2 | 3 | /* Pedro e Fernando são os desenvolvedores em uma stratup e vão desenvolver o 4 | novo sistema de cadastro, e pediram a sua ajuda. Sua task é fazer o código que 5 | valide as senhas que são cadastradas, para isso você deve atentar aos requisitos 6 | a seguir: 7 | - A senha deve conter, no mínimo, uma letra maiúscula, uma letra minúscula e 8 | um número; 9 | - A mesma não pode ter nenhum caractere de pontuação, acentuação ou espaço; 10 | - Além disso, a senha pode ter de 6 a 32 caracteres. 11 | 12 | - Entrada 13 | 14 | A entrada contém vários casos de teste e termina com final de arquivo. Cada 15 | linha tem uma string S, correspondente a senha que é inserida pelo usuário no 16 | momento do cadastro. 17 | 18 | - Saída 19 | 20 | A saída contém uma linha, que pode ser “Senha valida.”, caso a senha tenha 21 | cada item dos requisitos solicitados anteriormente, ou “Senha invalida.”, se 22 | um ou mais requisitos não forem atendidos. */ 23 | 24 | function validadorDeSenha(senha) { 25 | return /^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[a-zA-Z])(?!.*[_])\w{6,32}$/.test(senha) 26 | } 27 | 28 | let senha = ""; 29 | 30 | do { 31 | senha = gets(); 32 | if (senha !== "") { 33 | let valido = validadorDeSenha(senha); 34 | console.log("Senha " + (valido ? "valida." : "invalida.")); 35 | } 36 | } while (senha !== ""); -------------------------------------------------------------------------------- /JavaScript/Introdução a Programação com JavaScript/folha-de-pagamento.js: -------------------------------------------------------------------------------- 1 | // Folha de Pagamento 2 | 3 | /* Precisamos saber quanto uma determinada empresa deve pagar para seus 4 | colaboradores, porém temos apenas a quantidade de horas trabalhadas e o valor 5 | hora. Escreva um programa que leia o número de um colaborador, seu número de 6 | horas trabalhadas, o valor que recebe por hora e calcula o salário desse 7 | colaborador. Em seguida, apresente o número e o salário do colaborador, com 8 | duas casas decimais. 9 | 10 | - Entrada 11 | 12 | Você receberá 2 números inteiros e 1 número com duas casas decimais, 13 | representando o número, quantidade de horas trabalhadas e o valor que o 14 | funcionário recebe por hora trabalhada. 15 | 16 | - Saída 17 | 18 | Exiba o número e o salário do colaborador, conforme exemplo abaixo, com um 19 | espaço em branco antes e depois da igualdade. No caso do salário, também deve 20 | haver um espaço em branco após o $. */ 21 | 22 | let valor1 = parseInt(gets()); 23 | let valor2 = parseInt(gets()); 24 | let valor3 = parseFloat(gets()); 25 | 26 | let salary = parseFloat(valor2 * valor3).toFixed(2); 27 | 28 | console.log("NUMBER = " + valor1); 29 | console.log("SALARY = U$ " + salary); -------------------------------------------------------------------------------- /JavaScript/Introdução a Programação com JavaScript/multiplicacao-simples.js: -------------------------------------------------------------------------------- 1 | // Multiplicação Simples 2 | 3 | /* Você receberá dois valores inteiros. Faça a leitura e em seguida calcule o 4 | produto entre estes dois valores. Atribua esta operação à variável PROD, 5 | mostrando está de acordo com a mensagem de saída esperada (exemplo abaixo). 6 | 7 | - Entrada 8 | 9 | A entrada contém 2 valores inteiros. 10 | 11 | - Saída 12 | 13 | Exiba a variável PROD conforme exemplo abaixo, tendo obrigatoriamente um 14 | espaço em branco antes e depois da igualdade. */ 15 | 16 | let valor1 = parseInt(gets()); 17 | let valor2 = parseInt(gets()); 18 | let total = 0; 19 | 20 | total = valor1 * valor2; 21 | 22 | console.log("PROD = " + total); -------------------------------------------------------------------------------- /JavaScript/Introdução a Programação com JavaScript/visita-na-feira.js: -------------------------------------------------------------------------------- 1 | // Visita na Feira 2 | 3 | /* Você está na feira com a sua sacola e parou em uma balança. O feirante lhe 4 | entregou pimentões amarelos e vermelhos. Agora iremos somar os pimentões 5 | amarelos e vermelhos para descobrir o total de pimentões na sacola. Você 6 | receberá 2 inteiros que devem ser lidos e armazenados nas variáveis A 7 | (pimentões amarelos) e B (pimentões vermelhos). Faça a soma de A e B 8 | atribuindo o seu resultado na variável X (total de pimentões). Apresente X 9 | como descrito na mensagem de exemplo abaixo. Não apresente outra mensagem 10 | além da mensagem especificada. 11 | 12 | - Entrada 13 | 14 | A entrada contém 2 valores inteiros, separados por um espaço. 15 | 16 | - Saída 17 | 18 | Imprimir a mensagem "X = " (sendo a letra X maiúscula) seguido pelo valor 19 | da variável X e pelo final de linha. Assegure que exista um espaço antes e 20 | depois do sinal de igualdade. */ 21 | 22 | let line = gets().split(" "); 23 | let A = parseInt(line[0]); 24 | let B = parseInt(line[1]); 25 | let total = 0; 26 | 27 | total = A + B; 28 | 29 | console.log("X = " + total); -------------------------------------------------------------------------------- /JavaScript/Ordenação e Filtros em JavaScript/ordenando-numeros-pares-e-impares.js: -------------------------------------------------------------------------------- 1 | // Ordenando Números Pares e Ímpares 2 | 3 | /* Crie um programa onde você receberá valores inteiros não negativos como 4 | entrada. 5 | 6 | Ordene estes valores de acordo com o seguinte critério: 7 | 8 | - Primeiro os Pares 9 | - Depois os Ímpares 10 | - Você deve exibir os pares em ordem crescente e na sequência os ímpares em 11 | ordem decrescente. 12 | 13 | - Entrada 14 | 15 | A primeira linha de entrada contém um único inteiro positivo N (1 < N < 10000) 16 | Este é o número de linhas de entrada que vem logo a seguir. As próximas N 17 | linhas terão, cada uma delas, um valor inteiro não negativo. 18 | 19 | - Saída 20 | 21 | Exiba todos os valores lidos na entrada segundo a ordem apresentada acima. Cada 22 | número deve ser impresso em uma linha, conforme exemplo de saída abaixo. 23 | */ 24 | 25 | const linhas = parseInt(gets()); 26 | let entrada = []; 27 | 28 | for (let i = 0; i < linhas; i++) { 29 | entrada = [...entrada, gets()]; 30 | } 31 | 32 | entrada = entrada.sort((a, b) => a - b); 33 | const pares = entrada 34 | .filter(n => n % 2 === 0); 35 | const impares = entrada 36 | .filter(n => n % 2 === 1) 37 | .reverse(); 38 | const saida = [...pares, ...impares]; 39 | saida.map((n) => console.log(n)); -------------------------------------------------------------------------------- /JavaScript/Ordenação, filtros e Desafios/compras-no-supermercado.js: -------------------------------------------------------------------------------- 1 | // Compras no Supermercado 2 | 3 | /* Pedro trabalha sempre até tarde todos os dias, com isso tem pouco tempo 4 | para as tarefas doméstica. Para economizar tempo ele faz a lista de compras 5 | do supermercado em um aplicativo e costuma anotar cada item na mesma hora que 6 | percebe a falta dele em casa. 7 | 8 | O problema é que o aplicativo não exclui itens duplicados, como Pedro anota o 9 | mesmo item mais de uma vez e a lista acaba ficando extensa. Sua tarefa é 10 | melhorar o aplicativo de notas desenvolvendo um código que exclua os itens 11 | duplicados da lista de compras e que os ordene alfabeticamente. 12 | 13 | - Entrada 14 | 15 | A primeira linha de entrada contém um inteiro N (N < 100) com a quantidade de 16 | casos de teste que vem a seguir, ou melhor, a quantidade de listas de compras 17 | para organizar. Cada lista de compra consiste de uma única linha que contém de 18 | 1 a 1000 itens ou palavras compostas apenas de letras minúsculas (de 1 a 20 19 | letras), sem acentos e separadas por um espaço. 20 | 21 | - Saída 22 | 23 | A saída contém N linhas, cada uma representando uma lista de compra, sem os 24 | itens repetidos e em ordem alfabética. */ 25 | 26 | const nCasos = parseInt(gets()); 27 | let saida = []; 28 | 29 | for (let i = 0; i < nCasos; i++) { 30 | let comprasUnicas = new Set(gets().split(' ').sort()) 31 | 32 | saida[i] = Array.from(comprasUnicas).join(' ') 33 | } 34 | 35 | saida.map((lista) => console.log(lista)) 36 | -------------------------------------------------------------------------------- /JavaScript/Ordenação, filtros e Desafios/comunicacao-em-piralandia.js: -------------------------------------------------------------------------------- 1 | // Comunicação em Piralândia 2 | 3 | /* Os cientistas brasileiros descobriram um exoplaneta a 1 bilhão de anos luz 4 | da terra. Ele foi carinhosamente batizado de Piralândia, uma homenagem a cidade 5 | de Piracicaba, onde moram os cientistas. Após algum tempo observando esse 6 | planeta, os cientistas puderam ver que nele haviam habitantes e, além disso, 7 | esses habitantes estavam tentando fazer contato com os cientistas através de 8 | uma comunicação numérica. 9 | Só que a numeração que encontraram estava invertida e como muitas delas foram 10 | descobertas, os cientistas chamaram você para conseguir automatizar esse 11 | processo. Logo, dado um número grande, sua tarefa é imprimir esse número 12 | invertido. 13 | 14 | - Entrada 15 | 16 | O arquivo contém apenas uma linha de teste que é o número encontrado 17 | (0 < n < 9999999999). 18 | 19 | Obs.: Perceba que o número lido é muito alto para armazenar em uma variável do 20 | tipo int, logo você irá precisar utilizar o tipo long, que para a leitura e 21 | impressão em C, você deve utilizar o %llu. 22 | 23 | - Saída 24 | 25 | Imprimir o número lido invertido. Não esqueça de imprimir a quebra de linha 26 | (\n) no final, caso contrário você receberá (Presentation Error). */ 27 | 28 | var numeros = gets().split(""); 29 | numeros.reverse(); 30 | 31 | console.log(numeros.join("")); 32 | -------------------------------------------------------------------------------- /JavaScript/Ordenação, filtros e Desafios/encontre-a-maior-substring.js: -------------------------------------------------------------------------------- 1 | // Encontre a maior substring 2 | 3 | /* Encontre a maior substring comum entre as duas strings informadas. A 4 | substring pode ser qualquer parte da string, inclusive ela toda. Se não houver 5 | subsequência comum, a saída deve ser “0”. A comparação é case sensitive 6 | ('x' != 'X'). 7 | 8 | - Entrada 9 | 10 | A entrada contém vários casos de teste. Cada caso de teste é composto por duas 11 | linhas, cada uma contendo uma string. Ambas strings de entrada contém entre 1 12 | e 50 caracteres ('A'-'Z','a'-'z' ou espaço ' '), inclusive, ou no mínimo uma 13 | letra ('A'-'Z','a'-'z'). 14 | 15 | - Saída 16 | 17 | O tamanho da maior subsequência comum entre as duas Strings. */ 18 | 19 | let string1 = gets(); 20 | let string2 = gets(); 21 | 22 | while (string1 !== "") { 23 | if (string1.length >= string2.length) { 24 | countChar(string2, string1); 25 | } else { 26 | countChar(string1, string2); 27 | } 28 | string1 = gets(); 29 | string2 = gets(); 30 | } 31 | 32 | function countChar(menorString, maiorString) { 33 | let count = 0; 34 | 35 | for (let i = 0; i <= maiorString.length; i++) { 36 | for (let j = 0; j < maiorString.length; j++) { 37 | let subString = maiorString.substring(i, j); 38 | 39 | if (menorString.includes(subString) && subString.length > count) { 40 | count = subString.length; 41 | } 42 | } 43 | } 44 | console.log(count); 45 | } -------------------------------------------------------------------------------- /JavaScript/Ordenação, filtros e Desafios/menor-e-posicao.js: -------------------------------------------------------------------------------- 1 | // Menor e Posição 2 | 3 | /* Desenvolva um código que leia um valor E. Este E será o tamanho de um vetor 4 | X[E]. A seguir, leia cada um dos valores de X, encontre o menor elemento deste 5 | vetor e a sua posição dentro do vetor, mostrando esta informação. 6 | 7 | - Entrada 8 | 9 | A primeira linha de entrada contém um único inteiro E (1 < E < 1000), indicando 10 | o número de elementos que deverão ser lidos em seguida para o vetor X[E] de 11 | inteiros. A segunda linha contém cada um dos E valores, separados por um espaço. 12 | 13 | - Saída 14 | 15 | A primeira linha apresenta a mensagem “Menor valor:” seguida de um espaço e 16 | do menor valor lido na entrada. A segunda linha apresenta a mensagem “Posicao:” 17 | seguido de um espaço e da posição do vetor na qual se encontra o menor valor 18 | lido, lembrando que o vetor inicia na posição zero. */ 19 | 20 | let qnt = parseInt(gets()) 21 | let entrada = gets() 22 | let trimada = entrada.replace(/\s/g,',').trim().split(','); 23 | var min = trimada[0] 24 | var posicao = 0 25 | 26 | for (let i = 1; i < qnt; i++) { 27 | if (parseFloat(min) > parseFloat(trimada[i])) { 28 | min = trimada[i] 29 | posicao = i 30 | } 31 | } 32 | 33 | console.log("Menor valor:", min) 34 | console.log("Posicao:", posicao) 35 | -------------------------------------------------------------------------------- /JavaScript/Praticando Programação com JavaScript/distancia.js: -------------------------------------------------------------------------------- 1 | // Distância 2 | 3 | /* Duas motos (X e Y) partem em uma mesma direção. A moto X sai com velocidade 4 | constante de 60 Km/h e a moto Y sai com velocidade constante de 90 Km/h. 5 | Em uma hora (60 minutos) a moto Y consegue se distanciar 30 quilômetros da moto 6 | X, ou seja, consegue se afastar um quilômetro a cada 2 minutos. 7 | O seu desafio é ler a distância (em Km) e calcular quanto tempo leva 8 | (em minutos) para a moto Y tomar essa distância da outra moto. 9 | 10 | - Entrada 11 | 12 | O arquivo de entrada contém um número inteiro K que representa a quantidade de 13 | quilômetro que que a moto Y deve estar da moto X. 14 | 15 | - Saída 16 | 17 | Imprima o tempo necessário para a moto Y ficar com a quantidade K de quilômetro 18 | da moto X, seguido da mensagem " minutos". */ 19 | 20 | let quilometros = parseInt(gets()); 21 | let minutos = quilometros * 2; 22 | 23 | console.log(minutos + " minutos"); 24 | -------------------------------------------------------------------------------- /JavaScript/Praticando Programação com JavaScript/dividindo-X-por-Y.js: -------------------------------------------------------------------------------- 1 | // Dividindo X por Y 2 | 3 | /* Você terá o desafio de escrever um algoritmo que leia 2 números e imprima 4 | o resultado da divisão do primeiro pelo segundo. Caso não for possível mostre 5 | a mensagem “divisao impossivel” para os valores em questão. 6 | 7 | - Entrada 8 | 9 | A entrada contém um número inteiro N. Este N será a quantidade de pares de 10 | valores inteiros (X e Y) que serão lidos em seguida. 11 | 12 | - Saída 13 | 14 | Para cada caso mostre o resultado da divisão com um dígito após o ponto 15 | decimal, ou “divisao impossivel” caso não seja possível efetuar o cálculo. 16 | */ 17 | 18 | let limit = parseInt(gets()); 19 | 20 | for (let i = 0; i < limit; i++) { 21 | let line = gets().split(" "); 22 | let X = parseInt(line[0]); 23 | let Y = parseInt(line[1]); 24 | 25 | if (Y == 0) { 26 | console.log("divisao impossivel"); 27 | } else { 28 | let divisao = parseFloat(X / Y).toFixed(1); 29 | 30 | console.log(divisao); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /JavaScript/Problemas Aritméticos/calculo-de-viagem.js: -------------------------------------------------------------------------------- 1 | // Cálculo de viagem 2 | 3 | /* Rubens quer calcular e mostrar a quantidade de litros de combustível gastos 4 | em uma viagem de carro, sendo que seu carro faz 12 KM/L. Como ele não sabe 5 | fazer um programa que o auxilie nessa missão, ele te pede ajuda. Para efetuar 6 | o cálculo, deve-se fornecer o tempo gasto em horas na viagem e a velocidade 7 | média durante a mesma em km/h. Assim, você conseguirá passar para Rubens qual 8 | a distância percorrida e, em seguida, calcular quantos litros serão necessários 9 | para a viagem que ele quer fazer. Mostre o valor com 3 casas decimais após o 10 | ponto. 11 | 12 | - Entrada 13 | 14 | O arquivo de entrada contém dois inteiros. O primeiro é o tempo gasto na 15 | viagem em horas e o segundo é a velocidade média durante a mesma em km/h. 16 | 17 | - Saída 18 | 19 | Imprima a quantidade de litros necessária para realizar a viagem, com três 20 | dígitos após o ponto decimal */ 21 | 22 | let line = gets().split(" "); 23 | let H = parseInt(line[0]); 24 | let P = parseInt(line[1]); 25 | 26 | let media = (H*P)/12; 27 | let mediaFinal = media.toFixed(3); 28 | 29 | console.log(" " + mediaFinal); -------------------------------------------------------------------------------- /JavaScript/Problemas Aritméticos/soma-simples.js: -------------------------------------------------------------------------------- 1 | // Soma Simples 2 | 3 | /* Leia dois valores inteiros identificados como variáveis A e B. Calcule a 4 | soma entre elas e chame essa variável de SOMA. 5 | A seguir escreva o valor desta variável. 6 | 7 | - Entrada 8 | 9 | O arquivo de entrada contém 2 valores inteiros. 10 | 11 | - Saída 12 | 13 | Imprima a variável SOMA com todas as letras maiúsculas, inserindo um espaço 14 | em branco antes e depois do símbolo de igualdade, seguido pelo valor 15 | correspondente à soma de A e B. */ 16 | 17 | var A = parseInt(gets()); 18 | var B = parseInt(gets()); 19 | 20 | let soma = (A + B); 21 | 22 | console.log("SOMA = " + soma); -------------------------------------------------------------------------------- /JavaScript/Programando com JS/QuadradoPares.js: -------------------------------------------------------------------------------- 1 | // Quadrado de Pares 2 | 3 | /* 4 | Leia um valor inteiro N. Apresente o quadrado de cada um dos valores pares, de 1 5 | até N, inclusive N, se for o caso. 6 | 7 | - Entrada 8 | 9 | A entrada contém um valor inteiro N (5 < N < 2000). 10 | 11 | - Saída 12 | 13 | Imprima o quadrado de cada um dos valores pares, de 1 até N, conforme o exemplo 14 | abaixo. 15 | 16 | Tome cuidado! Algumas linguagens tem por padrão apresentarem como saída 1e+006 ao 17 | invés de 1000000 o que ocasionará resposta errada. Neste caso, configure a precisão 18 | adequadamente para que isso não ocorra. 19 | */ 20 | 21 | let lines = gets().split('\n'); 22 | var N = parseInt(lines.shift()); 23 | 24 | for (let i = 1; i <= N; i++) { 25 | if (i % 2 == 0) 26 | 27 | console.log(i + '^2 = ' + (i * i)); 28 | } 29 | -------------------------------------------------------------------------------- /JavaScript/Programando com JS/Resto2.js: -------------------------------------------------------------------------------- 1 | // Resto 2 2 | 3 | /* 4 | Leia um valor inteiro N. Apresente todos os números entre 1 e 10000 que divididos 5 | por N dão resto igual a 2. 6 | 7 | - Entrada 8 | 9 | A entrada contém um valor inteiro N (N < 10000). 10 | 11 | - Saída 12 | 13 | Imprima todos valores que quando divididos por N dão resto = 2, um por linha. 14 | */ 15 | 16 | let lines = gets().split('\n'); 17 | let N = parseInt(lines.shift()); 18 | 19 | for (let i = 1; i < 10000; i++) { 20 | if (i % N == 2) 21 | 22 | console.log(i); 23 | } 24 | -------------------------------------------------------------------------------- /JavaScript/Programando com JavaScript - Iniciante/NumerosImpares.js: -------------------------------------------------------------------------------- 1 | // Números Ímpares 2 | 3 | /* 4 | Leia um valor inteiro X (1 <= X <= 1000). Em seguida mostre os ímpares de 1 até X, 5 | um valor por linha, inclusive o X, se for o caso. 6 | 7 | - Entrada 8 | 9 | O arquivo de entrada contém 1 valor inteiro qualquer. 10 | 11 | - Saída 12 | 13 | Imprima todos os valores ímpares de 1 até X, inclusive X, se for o caso. 14 | */ 15 | 16 | let lines = gets().split('\n') 17 | let N = parseInt(lines.shift()); 18 | 19 | for (let i = 1; i <= N; i++) { 20 | if (i % 2 != 0) console.log(i); 21 | } -------------------------------------------------------------------------------- /JavaScript/Resolvendo Algoritmos com JavaScript/combinacao-de-strings.js: -------------------------------------------------------------------------------- 1 | // Combinação de strings 2 | 3 | /* Crie um algoritmo que receba dois inputs que sejam strings e combine-as 4 | alternando as letras de cada string. 5 | 6 | Deve começar pela primeira letra da primeira string, seguido pela primeira 7 | letra da segunda string, em seguida pela segunda letra da primeira string e 8 | continuar dessa forma sucessivamente. 9 | 10 | As letras restantes da cadeia mais longa devem ser adicionadas ao fim da 11 | string resultante e retornada. 12 | 13 | - Entrada 14 | 15 | A entrada contém vários casos de teste. A primeira linha contém um inteiro N 16 | que indica a quantidade de casos de teste que vem a seguir. Cada caso de teste 17 | é composto por uma linha que contém duas cadeias de caracteres, cada cadeia de 18 | caracteres contém entre 1 e 50 caracteres inclusive. 19 | 20 | - Saída 21 | 22 | Combine as duas cadeias de caracteres da entrada como mostrado no exemplo 23 | abaixo e exiba a cadeia resultante. */ 24 | 25 | const nCases = parseInt(gets()); 26 | let output; 27 | 28 | for (let i = 1; i <= nCases; i++) { 29 | output = ''; 30 | [strA, strB] = gets().split(' '); 31 | 32 | const smallestLength = Math.min(strA.length, strB.length); 33 | 34 | for (let j = 0; j < smallestLength; j++) output += `${strA[j]}${strB[j]}`; 35 | 36 | output += strA.length > strB.length 37 | ? strA.substring(smallestLength) 38 | : strB.substring(smallestLength); 39 | 40 | console.log(output); 41 | } -------------------------------------------------------------------------------- /JavaScript/Resolvendo Algoritmos/tipo-de-combustivel.js: -------------------------------------------------------------------------------- 1 | // Tipo de Combustível 2 | 3 | /* Você recebeu desafio para determinar qual dos produtos é o preferêncial dos 4 | clientes de um posto de abastecimento de combustível. Para isso você deve 5 | escrever um algoritmo para ler o tipo de combustível abastecido (codificado 6 | da seguinte forma: 1.Álcool 2.Gasolina 3.Diesel 4.Fim). Caso o usuário 7 | informe um código inválido (fora da faixa de 1 a 4) deve ser solicitado um 8 | novo código (até que seja válido). O programa será encerrado quando o código 9 | informado for o número 4. 10 | 11 | Entrada 12 | A entrada contém apenas valores inteiros e positivos. 13 | 14 | Saída 15 | Deve ser escrito a mensagem: "MUITO OBRIGADO" e a quantidade de clientes que 16 | abasteceram cada tipo de combustível, conforme exemplo. */ 17 | 18 | let alcool = 0; 19 | let gasolina = 0; 20 | let diesel = 0; 21 | let X = 0; 22 | 23 | while (X !== 4) { 24 | X = parseInt(gets()); 25 | if (X === 1) { 26 | alcool++; 27 | } else if (X === 2) { 28 | gasolina++; 29 | } else if (X === 3) { 30 | diesel++; 31 | } 32 | } 33 | 34 | console.log("MUITO OBRIGADO"); 35 | console.log("Alcool: " + alcool); 36 | console.log("Gasolina: " + gasolina); 37 | console.log("Diesel: " + diesel); -------------------------------------------------------------------------------- /JavaScript/Resolvendo Desafios Básicos em JavaScript/Multiplos.js: -------------------------------------------------------------------------------- 1 | // Múltiplos 2 | 3 | /* 4 | Leia 2 valores inteiros (A e B). Após, o programa deve mostrar uma mensagem "Sao 5 | Multiplos" ou "Nao sao Multiplos", indicando se os valores lidos são múltiplos 6 | entre si. 7 | 8 | - Entrada 9 | 10 | A entrada contém valores inteiros. 11 | 12 | - Saída 13 | 14 | A saída deve conter uma das mensagens conforme descrito acima. 15 | */ 16 | 17 | let lines = gets().split("\n"); 18 | let line = lines.shift().split(" "); 19 | let A = parseInt(line[0]); 20 | let B = parseInt(line[1]); 21 | 22 | if (A % B == 0 || B % A == 0) 23 | print("Sao Multiplos"); 24 | else 25 | print("Nao sao Multiplos"); 26 | -------------------------------------------------------------------------------- /JavaScript/Resolvendo Desafios Básicos em JavaScript/TesteSeleção1.js: -------------------------------------------------------------------------------- 1 | // Teste de Seleção 1 2 | 3 | /* 4 | Leia 4 valores inteiros A, B, C e D. Com base nisso, se o valor de B for maior do 5 | que de C e se D for maior do que A, e a soma de C com D for maior que a soma de A e 6 | B e se tanto C quanto D forem positivos e, ainda, se a variável A for par, escreva 7 | a mensagem "Valores aceitos", senão escrever "Valores nao aceitos". 8 | 9 | - Entrada 10 | 11 | Quatro números inteiros A, B, C e D. 12 | 13 | - Saída 14 | 15 | Imprima a mensagem corretamente esperada pela validação dos valores. 16 | */ 17 | 18 | x = gets().split(" "); 19 | a = parseInt(x[0]); 20 | b = parseInt(x[1]); 21 | c = parseInt(x[2]); 22 | d = parseInt(x[3]); 23 | 24 | if (b > c && d > a && (c + d) > (a + b) && c > 0 && d > 0 && a % 2 == 0) { 25 | print("Valores aceitos"); 26 | } else { 27 | print("Valores nao aceitos"); 28 | } 29 | -------------------------------------------------------------------------------- /JavaScript/Resolvendo Desafios Intermediários em JavaScript/GuilhermeSuasPipas.js: -------------------------------------------------------------------------------- 1 | // Guilherme e suas Pipas 2 | 3 | /* 4 | Guilherme adora brincar com pipas, pipas de várias cores, formas e tamanhos. Ele 5 | tem percebido que para as pipas possuírem maior estabilidade, e dessa forma voarem 6 | mais alto, elas devem possuir um barbante bem esticado ligando todos os pares de 7 | pontas não vizinhas. 8 | 9 | Apesar de ser uma criança bastante criativa e astuta, Guilherme não sabe como 10 | determinar a quantidade de barbantes que ele terá que utilizar para tornar uma pipa 11 | de n lados, estável. Você pode ajudá-lo?. 12 | 13 | - Entrada 14 | 15 | A entrada será composta por uma única linha, que contém um inteiro 3 ≤ n ≤ 105, 16 | representando o número de lados da pipa. 17 | 18 | - Saída 19 | 20 | Imprima um número inteiro, que será a quantidade de barbantes que Guilherme terá 21 | que utilizar para tornar a pipa de n lados estável. 22 | */ 23 | 24 | let lines = gets().split("\n"); 25 | let N = parseInt(lines.shift()); 26 | let resposta = ((N - 3) * N) / 2; 27 | 28 | print(resposta); 29 | -------------------------------------------------------------------------------- /JavaScript/Resolvendo Desafios Intermediários em JavaScript/Triangulo.js: -------------------------------------------------------------------------------- 1 | // Triângulo 2 | 3 | /* 4 | Leia 3 valores reais (A, B e C) e verifique se eles formam ou não um triângulo. 5 | Em caso positivo, calcule o perímetro do triângulo (soma de todos os lados) e 6 | apresente a mensagem: 7 | 8 | Perimetro = XX.X 9 | 10 | Em caso negativo, calcule a área do trapézio que tem A e B como base e C como 11 | altura, mostrando a mensagem: 12 | 13 | Area = XX.X 14 | 15 | Fórmula da área de um trapézio: AREA = ((A + B) x C) / 2 16 | 17 | - Entrada 18 | 19 | A entrada contém três valores reais. 20 | 21 | - Saída 22 | 23 | O resultado deve ser apresentado com uma casa decimal. 24 | */ 25 | 26 | let lines = gets().split('\n') 27 | 28 | let line = lines.shift().split(" "); 29 | let A = parseFloat(line[0]); 30 | let B = parseFloat(line[1]); 31 | let C = parseFloat(line[2]); 32 | let maior; 33 | let soma; 34 | let triangulo; 35 | 36 | if (A > B && A > C) maior = A; 37 | else if (B > C) maior = B; 38 | else maior = C; 39 | 40 | if (maior == A) soma = B + C; 41 | else if (maior == B) soma = A + C; 42 | else soma = B + A; 43 | 44 | if (soma > maior) triangulo = true; 45 | else triangulo = false; 46 | 47 | if (triangulo) { 48 | p = A + B + C; 49 | console.log("Perimetro = ", p.toFixed(1)); 50 | } else { 51 | area = (((A + B) * C) / 2) + .0; 52 | console.log("Area = ", area.toFixed(1)); 53 | } 54 | -------------------------------------------------------------------------------- /JavaScript/Resolvendo desafios em JavaScript/Xadrez.js: -------------------------------------------------------------------------------- 1 | // Xadrez 2 | 3 | /* 4 | No tabuleiro de xadrez, a casa na linha 1, coluna 1 (canto superior esquerdo) é 5 | sempre branca e as cores das casas se alternam entre branca e preta, formando o 6 | formato tão conhecido como xadrez. Dessa forma, como o tabuleiro tradicional tem 7 | oito linhas e oito colunas, a casa na linha 8, coluna 8 (canto inferior direito) 8 | será também branca. Porém, neste problema, queremos ser capazes de predizer a cor 9 | independente do número de linhas e colunas, sendo: L linhas e C colunas. No exemplo 10 | da figura, para L = 6 e C = 9, a casa no canto inferior direito será preta, uma 11 | simples previsão matemática, não? 12 | 13 | vide imagem em assets/xadrez.png 14 | 15 | Entrada 16 | A primeira linha da entrada contém um inteiro L (1 ≤ L ≤ 1000) indicando o número 17 | de linhas do tabuleiro. 18 | A segunda linha da entrada contém um inteiro C (1 ≤ C ≤ 1000) representando o 19 | número de colunas. 20 | 21 | Saída 22 | Imprima uma linha na saída. A linha deve conter um inteiro, representando a cor da 23 | casa no canto inferior direito do tabuleiro, e para identificar, considere o 24 | inteiro 1 para a cor branca e 0 para a cor preta. 25 | */ 26 | 27 | let lines = gets().split("\n"); 28 | var l = parseInt(lines[0]); 29 | var c = parseInt(lines[1]); 30 | 31 | if (l % 2 === 0) 32 | if (c % 2 === 0) print(1); 33 | else print(0); 34 | else if (l % 2 === 0) print(0); 35 | else print(1); 36 | -------------------------------------------------------------------------------- /JavaScript/Solução de Problemas Cotidianos/conversao-de-tempo.js: -------------------------------------------------------------------------------- 1 | // Conversão de Tempo 2 | 3 | /* Você terá o desafio de ler um valor inteiro, que é o tempo de duração em 4 | segundos de um determinado evento em uma loja, e informe-o expresso no formato 5 | horas:minutos:segundos. 6 | 7 | - Entrada 8 | 9 | O arquivo de entrada contém um valor inteiro N. 10 | 11 | - Saída 12 | 13 | Imprima o tempo lido no arquivo de entrada (segundos), convertido para 14 | horas:minutos:segundos, conforme exemplo fornecido. */ 15 | 16 | let tempo; 17 | let horas, minutos, segundos; 18 | 19 | tempo = parseInt(gets()); 20 | 21 | if (tempo >= 3600) { 22 | let rest = tempo % 3600; 23 | 24 | horas = parseInt((tempo - rest) / 3600); 25 | let rest2 = rest % 60; 26 | 27 | minutos = parseInt((rest - rest2) / 60); 28 | segundos = parseInt(rest2); 29 | console.log(horas + ":" + minutos + ":" + segundos); 30 | } else if (tempo >= 60) { 31 | let rest = tempo % 60; 32 | 33 | minutos = parseInt((tempo - rest) / 60); 34 | segundos = parseInt(rest); 35 | console.log("0:" + minutos + ":" + segundos); 36 | } else if (tempo < 60) { 37 | segundos = tempo; 38 | 39 | console.log("0:0:" + segundos); 40 | } -------------------------------------------------------------------------------- /JavaScript/Solução de Problemas Cotidianos/idade-em-dias.js: -------------------------------------------------------------------------------- 1 | // Idade em Dias 2 | 3 | /* Você terá o desafio de ler um valor inteiro correspondente à idade de uma 4 | pessoa em dias e informe-a em anos, meses e dias 5 | 6 | Obs.: apenas para facilitar o cálculo, considere todo ano com 365 dias e todo 7 | mês com 30 dias. Nos casos de teste nunca haverá uma situação que permite 12 8 | meses e alguns dias, como 360, 363 ou 364. 9 | 10 | - Entrada 11 | 12 | O arquivo de entrada contém um valor inteiro. 13 | 14 | - Saída 15 | 16 | Imprima a saída conforme exemplo fornecido. */ 17 | 18 | let totalDeDias = parseInt(gets()); 19 | let meses = parseInt((totalDeDias%365) / 30); 20 | let anos = parseInt(totalDeDias / 365); 21 | let dias = parseInt((totalDeDias%365)%30); 22 | 23 | console.log(anos + " ano(s)"); 24 | console.log(meses + " mes(es)"); 25 | console.log(dias + " dia(s)"); -------------------------------------------------------------------------------- /JavaScript/Solução de Problemas Cotidianos/tempo-do-dobby.js: -------------------------------------------------------------------------------- 1 | // Tempo do Dobby 2 | 3 | /* Para dar conta de toda a fabricação dos presentes de Natal, por várias 4 | vezes os elfos precisam ficar até tarde trabalhando para que tudo possa ser 5 | terminado a tempo. 6 | 7 | Para melhor gerenciar seus cronogramas, os elfos estipularam quantos minutos 8 | são necessários para fabricar cada presente. 9 | 10 | Já está quase no final do expediente, e um dos elfos pediu sua ajuda. 11 | 12 | Faltam N minutos para a hora de ir embora, e restam dois presentes para o elfo 13 | Dobby fabricar. Ajude-o a descobrir se ele conseguirá fabricar os dois ainda 14 | hoje, ou se deve deixar o trabalho para amanhã. 15 | 16 | - Entrada 17 | 18 | Cada caso de teste inicia com um inteiro N, indicando quantos minutos faltam 19 | para o final do expediente (2 <= N <= 100). 20 | 21 | Em seguida haverá dois inteiros A e B, indicando quantos minutos são 22 | necessários para fabricar os dois presentes que Dobby precisa fabricar 23 | (1 <= A, B <= 100). 24 | 25 | - Saída 26 | 27 | Imprima uma linha, contendo a frase "Farei hoje!" caso seja possível fabricar 28 | os dois presentes antes do final do expediente, ou "Deixa para amanha!" caso 29 | contrário. */ 30 | 31 | let N = parseInt(gets()); 32 | let inteirotemp = gets(); 33 | let line = inteirotemp.split(' ') 34 | let A = parseInt(line[0]); 35 | let B = parseInt(line[1]); 36 | 37 | let calc = (A + B); 38 | 39 | if (calc > N) { 40 | console.log("Deixa para amanha!"); 41 | } else { 42 | console.log("Farei hoje!"); 43 | } -------------------------------------------------------------------------------- /JavaScript/Solução de Problemas Essenciais/validacao-de-nota.js: -------------------------------------------------------------------------------- 1 | // Validação de Nota 2 | 3 | /* Para ajudar a calcular as notas referentes às duas avaliações dos alunos, 4 | uma professora pediu para que você desenvolva um programa que calcule e imprima 5 | a média semestral. Faça com que o algoritmo só aceite notas válidas (uma nota 6 | válida deve pertencer ao intervalo [0,10]). Cada nota deve ser validada 7 | separadamente. 8 | 9 | -Entrada 10 | 11 | A entrada contém vários valores reais, positivos ou negativos. O programa deve 12 | ser encerrado quando forem lidas duas notas válidas. 13 | 14 | - Saída 15 | 16 | Se uma nota inválida for lida, deve ser impressa a mensagem "nota invalida". 17 | Quando duas notas válidas forem lidas, deve ser impressa a mensagem "media = " 18 | seguido do valor do cálculo. O valor deve ser apresentado com duas casas após 19 | o ponto decimal */ 20 | 21 | let qtdeNotasValidas = 0; 22 | let notas = []; 23 | let cont = 0; 24 | 25 | while(qtdeNotasValidas < 2) { 26 | cont++; 27 | const nota = parseFloat(gets()); 28 | 29 | if (!nota) break; 30 | 31 | if (nota >= 0 && nota <= 10) { 32 | notas.push(nota) 33 | qtdeNotasValidas++; 34 | } else { 35 | console.log('nota invalida') 36 | } 37 | } 38 | const arraySum = arr => arr.reduce((acc, current) => acc + current) 39 | const arrayMedia = arr => arraySum(arr) / arr.length 40 | 41 | console.log("media = " + arrayMedia(notas).toFixed(2)) -------------------------------------------------------------------------------- /JavaScript/Solução de Problemas com JavaScript/contagem-repetida-de-numeros.js: -------------------------------------------------------------------------------- 1 | // Contagem repetida de números 2 | 3 | /* Neste desafio sua tarefa será ler vários números e em seguida dizer quantas 4 | vezes cada número aparece, ou seja, deve-se escrever cada um dos valores 5 | distintos que aparecem na entrada por ordem crescente de valor. 6 | 7 | - Entrada 8 | 9 | A primeira linha de entrada contem um único inteiro N, que indica a quantidade 10 | de valores que serão lidos para X (1 ≤ N ≤ 2000) logo em seguida. Com certeza 11 | cada número não aparecerá mais do que 20 vezes na entrada de dados. 12 | 13 | - Saída 14 | 15 | Imprima a saída de acordo com o exemplo fornecido abaixo, indicando quantas 16 | vezes cada um deles aparece na entrada por ordem crescente de valor. */ 17 | 18 | const nCases = parseInt(gets()); 19 | let input = 0 20 | let numbers = [] 21 | 22 | for (let i = 1; i <= nCases; i++) { 23 | input = parseInt(gets()); 24 | 25 | if ((input < 1 || input > 2000)) { 26 | continue; 27 | } 28 | numbers = [...numbers, input]; 29 | } 30 | 31 | const distinctNumbers = Array.from(new Set(numbers)) 32 | .sort((a, b) => a - b) 33 | .map(v => ([v, 0])) 34 | 35 | let countNumberMap = new Map(distinctNumbers) 36 | 37 | numbers.forEach(n => { 38 | countNumberMap.set(n, countNumberMap.get(n) + 1) 39 | }) 40 | 41 | for (const [number, times] of countNumberMap) { 42 | console.log(`${number} aparece ${times} vez(es)`) 43 | } -------------------------------------------------------------------------------- /JavaScript/Solução de Problemas/pedro-bento-e-o-mundo-de-oz.js: -------------------------------------------------------------------------------- 1 | // Pedro Bento e o Mundo de OZ 2 | 3 | /* No jogo, O Mundo de Oz, Pedro Bento é o líder do Tribunal, por causa disso 4 | ele é uma das pessoas mais importantes do mundo, no jogo. Além disso, Pedro 5 | Bento possui um grande tesouro, o qual possui diversos tipos de jóias. 6 | Pedro Bento está muito curioso para saber quantos tipos de jóias diferentes 7 | seu tesouro possui. 8 | 9 | Sabendo que você é o melhor programador do mundo, Pedro Bento te contratou para 10 | verificar quantos tipos de jóias distintas ele tem em seu tesouro. 11 | 12 | - Entrada 13 | 14 | A entrada consiste de várias linhas e cada uma contém uma string que descreve 15 | uma das jóias de Pedro Bento. Essa string é composta apenas dos caracteres 16 | '(' e ')', a soma do tamanho de todas as strings não excede 106. 17 | 18 | - Saída 19 | 20 | Imprima quantos tipos de jóias distintas Pedro Bento possui. */ 21 | 22 | let jewels = []; 23 | 24 | while(true) { 25 | let input = gets(); 26 | 27 | if(!input) { 28 | break; 29 | } 30 | let find = jewels.find(el => el == input); 31 | 32 | if(!find) { 33 | jewels.push(input); 34 | } 35 | } 36 | 37 | console.log(jewels.length); 38 | -------------------------------------------------------------------------------- /JavaScript/Solução de Problemas/quadrado-e-ao-cubo.js: -------------------------------------------------------------------------------- 1 | // Quadrado e ao Cubo 2 | 3 | /* Você terá o desafio de escrever um programa que leia um valor inteiro N 4 | (1 < N < 1000). Este N é a quantidade de linhas de saída que serão 5 | apresentadas na execução do programa. 6 | 7 | - Entrada 8 | 9 | O arquivo de entrada contém um número inteiro positivo N. 10 | 11 | - Saída 12 | 13 | Imprima a saída conforme o exemplo fornecido. */ 14 | 15 | let N = parseInt(gets()); 16 | let a, b; 17 | 18 | for (let i = 1; i <= N; i++) { 19 | a = i * i 20 | b = i * i * i 21 | 22 | console.log(i, a, b) 23 | } 24 | -------------------------------------------------------------------------------- /JavaScript/Solução de problemas básicos em JavaScript/blobs.js: -------------------------------------------------------------------------------- 1 | // Blobs 2 | 3 | /* 4 | No planeta Alpha vive a criatura Blobs, que come precisamente 1/2 de seu 5 | suprimento de comida disponível todos os dias. Escreva um algoritmo que leia 6 | a capacidade inicial de suprimento de comida (em Kg), e calcule quantos dias 7 | passarão antes que Blobs coma todo esse suprimento até restar um quilo ou menos. 8 | 9 | - Entrada 10 | 11 | A primeira linha de entrada contem um único inteiro N (1 ≤ N ≤ 1000), indicando 12 | o número de casos de teste. As N linhas seguintes contém um valor de ponto 13 | flutuante C (1 ≤ C ≤ 1000) correspondente à quantidade de comida disponível 14 | para Blobs. 15 | 16 | - Saída 17 | 18 | Para cada caso de teste, imprima uma linha contendo o número de dias que Blobs 19 | irá demorar para comer todo seu suprimento de comida, seguido da palavra "dias". 20 | */ 21 | 22 | let casoDeTeste = parseInt(gets()); 23 | 24 | function calcularDias(qtdComida) { 25 | if (qtdComida <= 1.0) { 26 | return 0; 27 | } 28 | const comeComida = qtdComida / 2.0; 29 | 30 | return 1 + calcularDias(comeComida); 31 | } 32 | 33 | while (casoDeTeste-- > 0) { 34 | const qtdComida = parseFloat(gets()); 35 | const diasFinais = calcularDias(qtdComida); 36 | 37 | console.log(diasFinais, 'dias'); 38 | } -------------------------------------------------------------------------------- /Kotlin/Desafios Matemáticos em Kotlin/ConsumoMedioAutomóvel.kt: -------------------------------------------------------------------------------- 1 | // Consumo Médio do Automóvel 2 | 3 | /* 4 | Você deve calcular o consumo médio de um automóvel onde será informada a 5 | distância total percorrida (em Km) e o total de combustível consumido (em 6 | litros). 7 | 8 | - Entrada 9 | 10 | Você receberá dois valores: um valor inteiro X com a distância total percorrida 11 | (em Km), e um valor real Y que representa o total de combustível consumido, 12 | com um dígito após o ponto decimal. 13 | 14 | - Saída 15 | 16 | Exiba o valor que representa o consumo médio do automóvel (3 casas após a 17 | vírgula), incluindo no final a mensagem "km/l". 18 | */ 19 | 20 | import java.util.Scanner; 21 | 22 | fun main(args: Array) { 23 | val leitor = Scanner(System.`in`); 24 | val x: Int = leitor.nextInt(); 25 | val y = leitor.nextFloat(); 26 | val media = x.div(y); 27 | 28 | println(String.format("%.3f km/l", media)); 29 | } -------------------------------------------------------------------------------- /Kotlin/Introdução a programação com Kotlin/ConversaoDeTempo.kt: -------------------------------------------------------------------------------- 1 | // Conversão de Tempo 2 | 3 | /* 4 | Você terá o desafio de ler um valor inteiro, que é o tempo de duração em 5 | segundos de um determinado evento em uma loja, e informe-o expresso no formato 6 | horas:minutos:segundos. 7 | 8 | • Entrada 9 | 10 | O arquivo de entrada contém um valor inteiro N. 11 | 12 | • Saída 13 | 14 | Imprima o tempo lido no arquivo de entrada (segundos), convertido para 15 | horas:minutos:segundos, conforme exemplo fornecido. 16 | */ 17 | 18 | import java.util.* 19 | 20 | fun main(args: Array){ 21 | val time = readLine()!!.toInt() 22 | val hour = (time / 3600) 23 | val minutes = (time % 3600) / 60 24 | val seconds = (time % 3600) % 60 25 | 26 | println("$hour:$minutes:$seconds") 27 | } -------------------------------------------------------------------------------- /Kotlin/Introdução a programação com Kotlin/IdadeEmDias.kt: -------------------------------------------------------------------------------- 1 | // Idade em Dias 2 | 3 | /* 4 | Você terá o desafio de ler um valor inteiro correspondente à idade de uma 5 | pessoa em dias e informe-a em anos, meses e dias 6 | Obs.: apenas para facilitar o cálculo, considere todo ano com 365 dias e todo 7 | mês com 30 dias. Nos casos de teste nunca haverá uma situação que permite 12 8 | meses e alguns dias, como 360, 363 ou 364. 9 | 10 | • Entrada 11 | 12 | O arquivo de entrada contém um valor inteiro. 13 | 14 | • Saída 15 | 16 | Imprima a saída conforme exemplo fornecido. 17 | */ 18 | 19 | import java.util.* 20 | 21 | fun main(args: Array) { 22 | val scanner = Scanner(System.`in`) 23 | val entrada: Int = scanner.nextInt() 24 | val anos = entrada / 365 25 | var dias = entrada - (365 * anos) 26 | var meses = 0 27 | 28 | if (dias > 30) { 29 | meses = dias / 30 30 | dias -= (30 * meses) 31 | } 32 | 33 | if (dias == 30) { 34 | meses = 1 35 | dias = 0 36 | } 37 | 38 | println("${anos} ano(s)") 39 | println("${meses} mes(es)") 40 | println("${dias} dia(s)") 41 | } -------------------------------------------------------------------------------- /Kotlin/Introdução a programação em Kotlin/NumerosImpares.kt: -------------------------------------------------------------------------------- 1 | // Números Ímpares 2 | 3 | /* 4 | Leia um valor inteiro X (1 <= X <= 1000). Em seguida mostre os ímpares de 1 até 5 | X, um valor por linha, inclusive o X, se for o caso. 6 | 7 | - Entrada 8 | 9 | O arquivo de entrada contém 1 valor inteiro qualquer. 10 | 11 | - Saída 12 | 13 | Imprima todos os valores ímpares de 1 até X, inclusive X, se for o caso. 14 | */ 15 | 16 | fun main(args: Array) { 17 | for (i in 1.rangeTo(readLine()!!.toInt()).step(2)) 18 | 19 | println(i) 20 | } -------------------------------------------------------------------------------- /Kotlin/Introdução a programação em Kotlin/QuadradoCubo.kt: -------------------------------------------------------------------------------- 1 | // Quadrado e ao Cubo 2 | 3 | /* 4 | Você terá o desafio de escrever um programa que leia um valor inteiro N 5 | (1 < N < 1000). Este N é a quantidade de linhas de saída que serão apresentadas 6 | na execução do programa. 7 | 8 | - Entrada 9 | 10 | O arquivo de entrada contém um número inteiro positivo N. 11 | 12 | - Saída 13 | 14 | Imprima a saída conforme o exemplo fornecido. 15 | */ 16 | 17 | fun main(args: Array) { 18 | var r = 0 19 | 20 | for (i in 1..readLine()!!.toInt()) { 21 | println("${i * 1} ${i * 1 * i} ${i * i * i}") 22 | r += 0 23 | } 24 | } -------------------------------------------------------------------------------- /Kotlin/Introdução a programação em Kotlin/SomaSimples.kt: -------------------------------------------------------------------------------- 1 | // Soma Simples 2 | 3 | /* 4 | Leia dois valores inteiros identificados como variáveis A e B. Calcule a soma 5 | entre elas e chame essa variável de SOMA. 6 | A seguir escreva o valor desta variável. 7 | 8 | - Entrada 9 | 10 | O arquivo de entrada contém 2 valores inteiros. 11 | 12 | - Saída 13 | 14 | Imprima a variável SOMA com todas as letras maiúsculas, inserindo um espaço em 15 | branco antes e depois do símbolo de igualdade, seguido pelo valor correspondente 16 | à soma de A e B. 17 | */ 18 | 19 | import java.util.Scanner 20 | 21 | fun main(args: Array) { 22 | val input = Scanner(System.`in`) 23 | val a = input.nextInt() 24 | val b = input.nextInt() 25 | println("SOMA = "+ (a + b)) 26 | } -------------------------------------------------------------------------------- /Kotlin/Praticando Aritmética em Kotlin/ExibindoNumerosPares.kt: -------------------------------------------------------------------------------- 1 | // Exibindo Números Pares 2 | 3 | /* 4 | Crie um programa que leia um número e mostre os números pares até esse número, 5 | inclusive ele mesmo. 6 | 7 | • Entrada 8 | 9 | Você receberá 1 valor inteiro N, onde N > 0. 10 | 11 | • Saída 12 | 13 | Exiba todos os números pares até o valor de entrada, sendo um em cada linha. 14 | */ 15 | 16 | fun main(args: Array) { 17 | for (i in 2.rangeTo(readLine()!!.toInt()).step(2)) { 18 | println(i) 19 | } 20 | } -------------------------------------------------------------------------------- /Kotlin/Praticando Aritmética em Kotlin/PreenchimentoVetorI.kt: -------------------------------------------------------------------------------- 1 | // Preenchimento Vetor I 2 | 3 | /* 4 | Você recebeu o desafio de ler um valor e criar um programa que coloque o valor 5 | lido na primeira posição de um vetor N[10]. Em cada posição subsequente, 6 | coloque o dobro do valor da posição anterior. Por exemplo, se o valor lido for 7 | 1, os valores do vetor devem ser 1,2,4,8 e assim sucessivamente. Mostre o 8 | vetor em seguida. 9 | 10 | • Entrada 11 | 12 | A entrada contém um valor inteiro (V<=50). 13 | 14 | • Saída 15 | 16 | Para cada posição do vetor, escreva "N[i] = X", onde i é a posição do vetor e 17 | X é o valor armazenado na posição i. O primeiro número do vetor N (N[0]) irá 18 | receber o valor de V. 19 | 20 | */ 21 | 22 | fun main(args: Array) { 23 | val v = readLine()!!.toInt() 24 | val a = IntArray(10).toMutableList() 25 | 26 | for(i in 0 until a.size) { 27 | a[i] = if(i == 0) v 28 | else a[i-1] * 2 29 | } 30 | 31 | for (k in 0 until a.size) { 32 | println("N[$k] = ${a[k]}") 33 | } 34 | } -------------------------------------------------------------------------------- /Kotlin/Praticando Aritmética em Kotlin/SubstituicaoVetorI.kt: -------------------------------------------------------------------------------- 1 | // Substituição em Vetor I 2 | 3 | /* 4 | Faça um programa que leia um vetor X[10]. Substitua a seguir, todos os valores 5 | nulos e negativos do vetor X por 1. Em seguida mostre o vetor X. 6 | 7 | • Entrada 8 | A entrada contém 10 valores inteiros, podendo ser positivos ou negativos. 9 | 10 | • Saída 11 | 12 | Para cada posição do vetor, escreva "X[i] = x", onde i é a posição do vetor e 13 | x é o valor armazenado naquela posição. 14 | */ 15 | 16 | fun main(args: Array) { 17 | val list = IntArray(10) {readLine()!!.toInt()} 18 | 19 | for (x in list.indices) { 20 | if (list[x] <=0) list[x] = 1 21 | } 22 | 23 | for (i in list.indices) println("X[$i] = ${list[i]}") 24 | } -------------------------------------------------------------------------------- /Kotlin/Praticando programação com Kotlin/Distancia.kt: -------------------------------------------------------------------------------- 1 | // Distância 2 | 3 | /* 4 | Duas motos (X e Y) partem em uma mesma direção. A moto X sai com velocidade 5 | constante de 60 Km/h e a moto Y sai com velocidade constante de 90 Km/h. 6 | 7 | Em uma hora (60 minutos) a moto Y consegue se distanciar 30 quilômetros da moto 8 | X, ou seja, consegue se afastar um quilômetro a cada 2 minutos. 9 | 10 | O seu desafio é ler a distância (em Km) e calcular quanto tempo leva (em 11 | minutos) para a moto Y tomar essa distância da outra moto. 12 | 13 | - Entrada 14 | 15 | O arquivo de entrada contém um número inteiro K que representa a quantidade de 16 | quilômetro que que a moto Y deve estar da moto X. 17 | 18 | - Saída 19 | 20 | Imprima o tempo necessário para a moto Y ficar com a quantidade K de quilômetro 21 | da moto X, seguido da mensagem " minutos". 22 | */ 23 | 24 | import java.util.Scanner 25 | 26 | fun main(args: Array) { 27 | val dist = readLine()!!.toInt() 28 | val total = (60 * dist) / 30 29 | 30 | println("${total} minutos") 31 | } -------------------------------------------------------------------------------- /Kotlin/Praticando programação em Kotlin/BobConduite.kt: -------------------------------------------------------------------------------- 1 | // Bob Conduite 2 | 3 | /* 4 | Você tem em mãos dois cabos circulares de energia. O primeiro cabo tem raio R1 5 | e o segundo raio R2. Você precisa comprar um conduite circular (veja a imagem 6 | abaixo que ilustra um conduite) de maneira a passar os dois cabos por dentro 7 | dele: 8 | 9 | Qual o menor raio do conduite que você deve comprar? Em outras palavras, dado 10 | dois círculos, qual o raio do menor círculo que possa englobar ambos os dois? 11 | 12 | - Entrada 13 | 14 | Na primeira linha teremos um inteiro T (T ≤ 10000), indicando o número de casos 15 | de teste. 16 | 17 | Na única linha de cada caso teremos dois números inteiros R1 e R2, indicando 18 | os respectivos raios. Os inteiros serão positivos e todas as contas caberão em 19 | um inteiro normal de 32 bits. 20 | 21 | - Saída 22 | 23 | Em cada caso, imprima o menor raio possível em uma única linha 24 | */ 25 | import java.util.Scanner 26 | 27 | fun main() { 28 | val inteiros = mutableListOf() 29 | var soma:Int 30 | 31 | for (i in 1..readLine()!!.toInt()) { 32 | val list = readLine()!!.split(" ").map { it.toInt() } 33 | 34 | if (list.size == 2){ 35 | soma = list[0] + list[1] 36 | inteiros.add(soma) 37 | } 38 | } 39 | 40 | for (i in inteiros){ 41 | println(i) 42 | } 43 | } -------------------------------------------------------------------------------- /Kotlin/Primeiros passos em Kotlin/MediaUm.kt: -------------------------------------------------------------------------------- 1 | // Média 1 2 | 3 | /* 4 | Leia 2 valores de ponto flutuante de dupla precisão A e B, que correspondem a 5 | 2 notas de um aluno. A seguir, calcule a média do aluno, sabendo que a nota A 6 | tem peso 3.5 e a nota B tem peso 7.5 (A soma dos pesos portanto é 11). Assuma 7 | que cada nota pode ir de 0 até 10.0, sempre com uma casa decimal. 8 | 9 | - Entrada 10 | 11 | O arquivo de entrada contém 2 valores com uma casa decimal cada um. 12 | 13 | - Saída 14 | 15 | Calcule e imprima a variável MEDIA conforme exemplo abaixo, com 5 dígitos após 16 | o ponto decimal e com um espaço em branco antes e depois da igualdade. Utilize 17 | variáveis de dupla precisão (double) e como todos os problemas, não esqueça de 18 | imprimir o fim de linha após o resultado, caso contrário, você receberá 19 | "Presentation Error". 20 | */ 21 | 22 | import java.util.Scanner 23 | 24 | fun main(args: Array) { 25 | var reader = Scanner(System.`in`) 26 | var a = reader.nextDouble() 27 | var b = reader.nextDouble() 28 | var weightA = 3.5 29 | var weightB = 7.5 30 | 31 | var totalWeight = weightA + weightB 32 | var m = (a * weightA + b * weightB) / totalWeight 33 | var r = "%.5f".format(m) 34 | 35 | println("MEDIA = ${r}") 36 | } -------------------------------------------------------------------------------- /Kotlin/Primeiros passos em Kotlin/MultiplicacaoSimples.kt: -------------------------------------------------------------------------------- 1 | // Multiplicação Simples 2 | 3 | /* 4 | Você receberá dois valores inteiros. Faça a leitura e em seguida calcule o 5 | produto entre estes dois valores. Atribua esta operação à variável PROD, 6 | mostrando esta de acordo com a mensagem de saída esperada (exemplo abaixo). 7 | 8 | - Entrada 9 | 10 | A entrada contém 2 valores inteiros. 11 | 12 | - Saída 13 | 14 | Exiba a variável PROD conforme exemplo abaixo, tendo obrigatoriamente um espaço 15 | em branco antes e depois da igualdade. 16 | */ 17 | 18 | fun main(args: Array) { 19 | val a = readLine()!!.toInt() 20 | val b = readLine()!!.toInt() 21 | 22 | println("PROD = ${a * b}") 23 | } -------------------------------------------------------------------------------- /Kotlin/Primeiros passos em Kotlin/SequenciaLogica.kt: -------------------------------------------------------------------------------- 1 | // Sequência Lógica 2 | 3 | /* 4 | Desenvolva um programa capaz de ler um valor inteiro N. N * 2 linhas de saída 5 | vão ser apresentadas na execução do programa, seguindo a lógica do exemplo mais 6 | abaixo. Para os valores com mais de seis dígitos, todos os dígitos devem ser 7 | apresentados. 8 | 9 | • Entrada 10 | 11 | O arquivo de entrada contém um número inteiro positivo N (1 < N < 1000). 12 | 13 | • Saída 14 | 15 | Imprima a saída conforme o exemplo fornecido. 16 | */ 17 | 18 | import kotlin.math.pow 19 | 20 | fun main() { 21 | val n = 1..(readLine() ?: return).toInt() 22 | 23 | n.forEach {n1-> 24 | val n2 = (n1.toDouble().pow(2)).toInt() 25 | val n3 = (n1.toDouble().pow(3)).toInt() 26 | println("$n1 $n2 $n3") 27 | println("$n1 ${n2+1} ${n3+1}") 28 | } 29 | } -------------------------------------------------------------------------------- /Kotlin/Solucionando desafios em Kotlin/AcimaDiagonalPrincipal.kt: -------------------------------------------------------------------------------- 1 | // Acima da Diagonal Principal 2 | 3 | /* 4 | Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e 5 | uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média 6 | considerando somente aqueles elementos que estão acima da diagonal principal 7 | da matriz, conforme ilustrado abaixo (área verde). 8 | 9 | vide arquivo assets acima-diagonal-principal.png 10 | 11 | • Entrada 12 | 13 | A primeira linha de entrada contém um único caractere Maiúsculo O ('S' ou 'M'), 14 | indicando a operação (Soma ou Média) que deverá ser realizada com os elementos 15 | da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz. 16 | 17 | • Saída 18 | 19 | Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto 20 | decimal. 21 | */ 22 | 23 | fun main(args: Array) { 24 | var sum = 0.0 25 | val t = readLine()!! 26 | val m = Array(12) { DoubleArray(12) } 27 | 28 | for (i in m.indices) { 29 | for (j in m.indices) { 30 | m[i][j] = readLine()!!.toDouble() 31 | if (j>i) sum += m[i][j] 32 | } 33 | } 34 | 35 | if (t == "S"){ 36 | println(sum.format(1)) 37 | } 38 | 39 | if (t == "M"){ 40 | sum /= 66.0 41 | println(sum.format(1)) 42 | } 43 | } 44 | 45 | private fun Double.format(digits: Int) = "%.${digits}f".format(this).replace(',','.') -------------------------------------------------------------------------------- /Kotlin/Solucionando desafios em Kotlin/AnaliseDeNumeros.kt: -------------------------------------------------------------------------------- 1 | // Análise de Números 2 | 3 | /* 4 | Você deve fazer a leitura de 5 valores inteiros. Em seguida mostre quantos 5 | valores informados são pares, quantos valores informados são ímpares, quantos 6 | valores informados são positivos e quantos valores informados são negativos. 7 | 8 | - Entrada 9 | 10 | Você receberá 5 valores inteiros. 11 | 12 | - Saída 13 | 14 | Exiba a mensagem conforme o exemplo de saída abaixo, sendo uma mensagem por 15 | linha e não esquecendo o final de linha após cada uma. 16 | */ 17 | 18 | fun main(args: Array) { 19 | val inteiros = mutableListOf() 20 | var positivos = mutableListOf() 21 | var negativos = mutableListOf() 22 | var pares = mutableListOf() 23 | var impares = mutableListOf() 24 | 25 | for (i in 1..5) {inteiros.add(readLine()!!.toInt())} 26 | inteiros.forEach {if (it % 2 == 0) {pares.add(it)}} 27 | inteiros.forEach {if (it % 2 != 0) {impares.add(it)}} 28 | inteiros.forEach {if (it > 0) {positivos.add(it)}} 29 | inteiros.forEach {if (it < 0) {negativos.add(it)}} 30 | 31 | println("${pares.size} valor(es) par(es)") 32 | println("${impares.size} valor(es) impar(es)") 33 | println("${positivos.size} valor(es) positivo(s)") 34 | println("${negativos.size} valor(es) negativo(s)") 35 | } -------------------------------------------------------------------------------- /Kotlin/Solucionando desafios em Kotlin/FibonacciFacil.kt: -------------------------------------------------------------------------------- 1 | // Fibonacci Fácil 2 | 3 | /* 4 | A seguinte sequência de números 0 1 1 2 3 5 8 13 21... é conhecida como série 5 | de Fibonacci. Nessa sequência, cada número, depois dos 2 primeiros, é igual à 6 | soma dos 2 anteriores. Escreva um algoritmo que leia um inteiro N (N < 46) e 7 | mostre os N primeiros números dessa série. 8 | 9 | - Entrada 10 | 11 | O arquivo de entrada contém um valor inteiro N (0 < N < 46). 12 | 13 | - Saída 14 | 15 | Os valores devem ser mostrados na mesma linha, separados por um espaço em 16 | branco. Não deve haver espaço após o último valor. 17 | */ 18 | 19 | fun main(args: Array) { 20 | val n = readLine()!!.toInt() 21 | fibo(n) 22 | } 23 | 24 | val fibo:(Int) -> Unit = { numero-> 25 | var a = 1 26 | var b = 0 27 | var soma: Int 28 | val lista:MutableList = mutableListOf("0") 29 | lista.add(" ") 30 | 31 | for (i in 0 until numero-1){ 32 | lista.add(a.toString()) 33 | lista.add(" ") 34 | 35 | soma = a 36 | a += b 37 | b = soma 38 | } 39 | lista.forEach { numeros-> print(numeros) } 40 | } -------------------------------------------------------------------------------- /Kotlin/Solucionando desafios em Kotlin/TesteDeSelecaoUm.kt: -------------------------------------------------------------------------------- 1 | // Teste de Seleção 1 2 | 3 | /* 4 | Leia 4 valores inteiros A, B, C e D. Com base nisso, se o valor de B for maior 5 | do que de C e se D for maior do que A, e a soma de C com D for maior que a soma 6 | de A e B e se tanto C quanto D forem positivos e, ainda, se a variável A for 7 | par, escreva a mensagem "Valores aceitos", senão escrever "Valores nao aceitos". 8 | 9 | - Entrada 10 | 11 | Quatro números inteiros A, B, C e D. 12 | 13 | - Saída 14 | 15 | Imprima a mensagem corretamente esperada pela validação dos valores. 16 | */ 17 | 18 | fun main(args: Array) { 19 | val input = readLine()!! 20 | val a = input.split(" ")[0].toInt() 21 | val b = input.split(" ")[1].toInt() 22 | val c = input.split(" ")[2].toInt() 23 | val d = input.split(" ")[3].toInt() 24 | 25 | if (b > c && d > a && (c + d) > (a + b) && c > 0 && d > 0 && a % 2 ==0) { 26 | println("Valores aceitos") 27 | } else { 28 | println("Valores nao aceitos") 29 | } 30 | } -------------------------------------------------------------------------------- /Kotlin/Solucionando desafios em Kotlin/Triangulo.kt: -------------------------------------------------------------------------------- 1 | // Triângulo 2 | 3 | /* 4 | Leia 3 valores reais (A, B e C) e verifique se eles formam ou não um triângulo. 5 | Em caso positivo, calcule o perímetro do triângulo e apresente a mensagem: 6 | Perimetro = XX.X 7 | 8 | Em caso negativo, calcule a área do trapézio que tem A e B como base e C como 9 | altura, mostrando a mensagem 10 | Area = XX.X 11 | 12 | - Entrada 13 | 14 | A entrada contém três valores reais. 15 | 16 | - Saída 17 | 18 | O resultado deve ser apresentado com uma casa decimal. 19 | */ 20 | 21 | fun main(args: Array) { 22 | fun Double.format(digits: Long) = "%.${digits}f".format(this).replace(',','.') 23 | val (a, b, c) = readLine()!!.split(" ").map {it.toDouble()} 24 | 25 | val p = (a + b + c).format(1) 26 | val r = (((a + b) * c / 2)).format(1) 27 | 28 | if (a < (b + c) && b < (a + c) && c < (a + b)) println("Perimetro = $p") 29 | else println("Area = $r") 30 | } -------------------------------------------------------------------------------- /Kotlin/Solucionando problemas em Kotlin/AreaCirculo.kt: -------------------------------------------------------------------------------- 1 | // Área do Círculo 2 | 3 | /* 4 | A fórmula para calcular a área de uma circunferência é: area = π . raio2. 5 | Considerando para este problema que π = 3.14159: 6 | 7 | - Efetue o cálculo da área, elevando o valor de raio ao quadrado e multiplicando 8 | por π. 9 | 10 | - Entrada 11 | 12 | A entrada contém um valor de ponto flutuante (dupla precisão), no caso, a 13 | variável raio. 14 | 15 | - Saída 16 | 17 | Apresentar a mensagem "A=" seguido pelo valor da variável area, conforme exemplo 18 | abaixo, com 4 casas após o ponto decimal. Utilize variáveis de dupla precisão 19 | (double). Como todos os problemas, não esqueça de imprimir o fim de linha após 20 | o resultado, caso contrário, você receberá "Presentation Error". 21 | */ 22 | import java.math.BigDecimal 23 | import java.math.RoundingMode 24 | import kotlin.math.pow 25 | 26 | fun main(args: Array) { 27 | val raio = readLine()!!.toDouble() 28 | val pi = 3.14159 29 | val area = pi * (raio*raio) 30 | val resultado = BigDecimal(area).setScale(4, RoundingMode.HALF_EVEN) 31 | 32 | println("A=$resultado") 33 | } -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Pleiterson Amorim 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Python/Desafios matemáticos em Python/PreenchimentoVetorIII.py: -------------------------------------------------------------------------------- 1 | # Preenchimento de Vetor III 2 | 3 | # Leia um valor X. Coloque este valor na primeira posição de um vetor N[100]. 4 | # Em cada posição subsequente de N (1 até 99), coloque a metade do valor 5 | # armazenado na posição anterior, conforme o exemplo abaixo. Imprima o vetor N. 6 | 7 | # • Entrada 8 | 9 | # A entrada contém um valor de dupla precisão com 4 casas decimais. 10 | 11 | # • Saída 12 | 13 | # Para cada posição do vetor N, escreva "N[i] = Y", onde i é a posição do vetor 14 | # e Y é o valor armazenado naquela posição. Cada valor do vetor deve ser 15 | # apresentado com 4 casas decimais. 16 | 17 | x = float(input()) 18 | 19 | for i in range(0,100): 20 | print("N[{}] = ".format(i), end="") 21 | print('{0:.4f}'.format(x)) 22 | x /= 2 -------------------------------------------------------------------------------- /Python/Desafios matemáticos em Python/TempoJogoMinutos.py: -------------------------------------------------------------------------------- 1 | # Tempo de Jogo com Minutos 2 | 3 | # Leia a hora inicial, minuto inicial, hora final e minuto final de um jogo. A 4 | # seguir calcule a duração do jogo. 5 | # Obs.: O jogo tem duração mínima de um (1) minuto e duração máxima de 24 horas. 6 | 7 | # • Entrada 8 | 9 | # Quatro números inteiros representando a hora de início e fim do jogo. 10 | 11 | # • Saída 12 | 13 | # Mostre a seguinte mensagem: “O JOGO DUROU XXX HORA(S) E YYY MINUTO(S)”. 14 | 15 | hi, mi, hf, mf = map(int, input().split()) 16 | 17 | h = hf - hi 18 | m = mf - mi 19 | 20 | if m >= 60: 21 | m -= 60 22 | h += 1 23 | elif m < 0: 24 | m += 60 25 | h -= 1 26 | 27 | if h > 24 or (h == 24 and m > 0): 28 | h -= 24 29 | elif h < 0: 30 | h += 24 31 | 32 | if h == 0 and m == 0: 33 | h = 24 34 | 35 | if hf - hi >= 24 and hf >= 24: 36 | h = hf - hi 37 | 38 | print(f"O JOGO DUROU {h} HORA(S) E {m} MINUTO(S)") -------------------------------------------------------------------------------- /Python/Resolvendo algoritmos com Python/ARespostaTheon.py: -------------------------------------------------------------------------------- 1 | # A Resposta de Theon 2 | 3 | # Ramsay: "(...) você vence se conseguir adivinhar quem eu sou e por que estou 4 | # torturando você." 5 | # Theon deve pensar rápido e adivinhar quem é seu algoz! Entretanto, Ramsay já 6 | # decidiu o que ele irá fazer depois que Theon der sua resposta. 7 | # Theon pode dizer que seu algoz é alguma dentre N pessoas. Considere que as 8 | # pessoas são numeradas de 1 a N. Se Theon responder que seu algoz é a pessoa 9 | # i, Ramsay irá atingi-lo Ti vezes. 10 | # Sua tarefa é ajudar Theon a determinar qual deve ser sua resposta de forma a 11 | # minimizar o número de vezes que ele será atingido. 12 | 13 | # • Entrada 14 | 15 | # A primeira linha contém um inteiro N (1 ≤ N ≤ 100). A segunda linha contém N 16 | # inteiros T1, T2, ..., TN (0 ≤ Ti ≤ 20). 17 | 18 | # • Saída 19 | 20 | # Imprima uma linha contendo o número da pessoa que Theon deve dizer ser seu 21 | # algoz. Se existe mais de uma resposta possível, imprima a menor. 22 | 23 | import sys 24 | 25 | N = int(input()) 26 | pessoas = sys.stdin.readline().split() 27 | lowest_pos = 0 28 | 29 | for i in range(N): 30 | if i == 0: 31 | lowest = pessoas[i] 32 | continue 33 | if pessoas[i] < lowest: 34 | lowest = pessoas[i] 35 | lowest_pos = i 36 | 37 | print(lowest_pos + 1) -------------------------------------------------------------------------------- /Python/Resolvendo algoritmos com Python/ExibindoNumerosPares.py: -------------------------------------------------------------------------------- 1 | # Exibindo Números Pares 2 | 3 | # Crie um programa que leia um número e mostre os números pares até esse 4 | # número, inclusive ele mesmo. 5 | 6 | # • Entrada 7 | 8 | # Você receberá 1 valor inteiro N, onde N > 0. 9 | 10 | # • Saída 11 | 12 | # Exiba todos os números pares até o valor de entrada, sendo um em cada linha. 13 | 14 | import sys 15 | 16 | a = int(sys.stdin.readline()) 17 | 18 | for i in range(2, a + 2, 2): 19 | if (i % 2 == 0) and (i <= a): 20 | print(i) -------------------------------------------------------------------------------- /Python/Resolvendo algoritmos com Python/FibonacciFacil.py: -------------------------------------------------------------------------------- 1 | # Fibonacci Fácil 2 | 3 | # A seguinte sequência de números 0 1 1 2 3 5 8 13 21... é conhecida como série 4 | # de Fibonacci. Nessa sequência, cada número, depois dos 2 primeiros, é igual 5 | # à soma dos 2 anteriores. Escreva um algoritmo que leia um inteiro N (N < 46) 6 | # e mostre os N primeiros números dessa série. 7 | 8 | # • Entrada 9 | 10 | # O arquivo de entrada contém um valor inteiro N (0 < N < 46). 11 | 12 | # • Saída 13 | 14 | # Os valores devem ser mostrados na mesma linha, separados por um espaço em 15 | # branco. Não deve haver espaço após o último valor. 16 | 17 | n = int(input()) 18 | fib1 = 0 19 | fib2 = 1 20 | n = n - 1 21 | fib_list = [fib1] 22 | 23 | for i in range(0,n): 24 | soma = fib1 + fib2 25 | fib1 = fib2 26 | fib2 = soma 27 | fib_list.append(fib1) 28 | 29 | fib_string = (' '.join(str(x) for x in fib_list)) 30 | print(fib_string) -------------------------------------------------------------------------------- /Python/Solucionando Desafios em Python/FolhaPagamento.py: -------------------------------------------------------------------------------- 1 | # Folha de Pagamento 2 | 3 | # Precisamos saber quanto uma determinada empresa deve pagar para seus 4 | # colaboradores, porém temos apenas a quantidade de horas trabalhadas e o valor 5 | # hora. Escreva um programa que leia o número de um colaborador, seu número de 6 | # horas trabalhadas, o valor que recebe por hora e calcula o salário desse 7 | # colaborador. Em seguida, apresente o número e o salário do colaborador, com 8 | # duas casas decimais. 9 | 10 | # - Entrada 11 | 12 | # Você receberá 2 números inteiros e 1 número com duas casas decimais, 13 | # representando o número, quantidade de horas trabalhadas e o valor que o 14 | # funcionário recebe por hora trabalhada. 15 | 16 | # - Saída 17 | 18 | # Exiba o número e o salário do colaborador, conforme exemplo abaixo, com um 19 | # espaço em branco antes e depois da igualdade. No caso do salário, também deve 20 | # haver um espaço em branco após o $. 21 | 22 | emp_no = int(input()) 23 | worked_hours = int(input()) 24 | receives_per_worked_hour = float(input()) 25 | salary = receives_per_worked_hour * worked_hours 26 | 27 | print(f"NUMBER = {emp_no}") 28 | print(f"SALARY = U$ {salary:.2f}") -------------------------------------------------------------------------------- /Python/Soluções Aritméticas em Python/PreenchimentoVetorI.py: -------------------------------------------------------------------------------- 1 | # Preenchimento de Vetor I 2 | 3 | # Você recebeu o desafio de ler um valor e criar um programa que coloque o valor 4 | # lido na primeira posição de um vetor N[10]. Em cada posição subsequente, 5 | # coloque o dobro do valor da posição anterior. Por exemplo, se o valor lido 6 | # for 1, os valores do vetor devem ser 1,2,4,8 e assim sucessivamente. Mostre 7 | # o vetor em seguida. 8 | 9 | # - Entrada 10 | 11 | # A entrada contém um valor inteiro (V<=50). 12 | 13 | # - Saída 14 | 15 | # Para cada posição do vetor, escreva "N[i] = X", onde i é a posição do vetor e 16 | # X é o valor armazenado na posição i. O primeiro número do vetor N (N[0]) irá 17 | # receber o valor de V. 18 | 19 | N = [0,0,0,0,0,0,0,0,0,0] 20 | x = int(input()) 21 | 22 | for i in range(len(N)): 23 | N[i] = x 24 | x = x * 2 25 | print('N[{}] = {}'.format(i, N[i])) -------------------------------------------------------------------------------- /Python/Soluções Aritméticas em Python/triangulo.py: -------------------------------------------------------------------------------- 1 | # Triângulo 2 | 3 | # Leia 3 valores reais (A, B e C) e verifique se eles formam ou não um triângulo. 4 | # Em caso positivo, calcule o perímetro do triângulo e apresente a mensagem: 5 | # Perimetro = XX.X 6 | 7 | # Em caso negativo, calcule a área do trapézio que tem A e B como base e C como 8 | # altura, mostrando a mensagem 9 | # Area = XX.X 10 | 11 | # - Entrada 12 | 13 | # A entrada contém três valores reais. 14 | 15 | # - Saída 16 | 17 | # O resultado deve ser apresentado com uma casa decimal. 18 | 19 | a = [float(x) for x in input().split()] 20 | 21 | if a[0] + a[1] > a[2] and a[0] + a[2] > a[1] and a[1] + a[2] > a[0]: 22 | print(f"Perimetro = {sum(a):.1f}") 23 | else: 24 | print(f"Area = {((a[0] + a[1]) * a[2]) / 2:.1f}") -------------------------------------------------------------------------------- /Ruby/Praticando com desafios intermediários em Ruby/EncaixaOuNao.rb: -------------------------------------------------------------------------------- 1 | # Encaixa ou Não? 2 | 3 | # Paulinho tem em suas mãos um novo problema. Agora a sua professora lhe pediu 4 | # que construísse um programa para verificar, à partir de dois valores muito 5 | # grandes A e B, se B corresponde aos últimos dígitos de A. 6 | 7 | # - Entrada 8 | 9 | # A entrada consiste de vários casos de teste. A primeira linha de entrada contém 10 | # um inteiro N que indica a quantidade de casos de teste. Cada caso de teste 11 | # consiste de dois valores A e B maiores que zero, cada um deles podendo ter até 12 | # 1000 dígitos. 13 | 14 | # - Saída 15 | 16 | # Para cada caso de entrada imprima uma mensagem indicando se o segundo valor 17 | # encaixa no primeiro valor, confome exemplo abaixo. 18 | 19 | if __FILE__ == $0 20 | quantidade = (gets.strip).to_i - 1 21 | 22 | for elemento in 0..quantidade 23 | valores = ((STDIN.gets).strip).split(" ") 24 | break if valores.size != 2 25 | first, last = valores[0].to_s, valores[1].to_s 26 | 27 | if (first.length > 0 and last.length > 0) and (first.length <= 1000 and last.length <= 1000) 28 | if first[(first.length - last.length).abs..(first.length - 1)] == last then puts "encaixa" else puts "nao encaixa" end 29 | end 30 | end 31 | end -------------------------------------------------------------------------------- /Ruby/Praticando com desafios intermediários em Ruby/FibonacciFacil.rb: -------------------------------------------------------------------------------- 1 | # Fibonacci Fácil 2 | 3 | # A seguinte sequência de números 0 1 1 2 3 5 8 13 21... é conhecida como série 4 | # de Fibonacci. Nessa sequência, cada número, depois dos 2 primeiros, é igual à 5 | # soma dos 2 anteriores. Escreva um algoritmo que leia um inteiro N (N < 46) e 6 | # mostre os N primeiros números dessa série. 7 | 8 | # - Entrada 9 | 10 | # O arquivo de entrada contém um valor inteiro N (0 < N < 46). 11 | 12 | # - Saída 13 | 14 | # Os valores devem ser mostrados na mesma linha, separados por um espaço em 15 | # branco. Não deve haver espaço após o último valor. 16 | 17 | n = gets.strip.to_i 18 | resultado = "" 19 | soma = 0 20 | ant = 0 21 | prox = 1 22 | 23 | 0.upto(n-1) do |num| 24 | 25 | if num == 0 || num == 1 26 | resultado << num.to_s << " " 27 | else 28 | soma = ant + prox 29 | ant = prox 30 | prox = soma 31 | resultado << soma.to_s << " " 32 | end 33 | end 34 | 35 | puts resultado.strip -------------------------------------------------------------------------------- /Ruby/Praticando com desafios intermediários em Ruby/SequenciaLogica.rb: -------------------------------------------------------------------------------- 1 | # Sequência Lógica 2 | 3 | # Desenvolva um programa capaz de ler um valor inteiro N. N * 2 linhas de saída 4 | # vão ser apresentadas na execução do programa, seguindo a lógica do exemplo mais 5 | # abaixo. Para os valores com mais de seis dígitos, todos os dígitos devem 6 | # ser apresentados. 7 | 8 | # - Entrada 9 | 10 | # O arquivo de entrada contém um número inteiro positivo N (1 < N < 1000). 11 | 12 | # - Saída 13 | 14 | # Imprima a saída conforme o exemplo fornecido. 15 | 16 | number_times = gets.strip.to_i 17 | 18 | 1.upto(number_times) do |number| 19 | puts "#{number} #{number ** 2} #{number ** 3}" 20 | puts "#{number} #{number ** 2 + 1} #{number ** 3 + 1}" 21 | end -------------------------------------------------------------------------------- /Ruby/Praticando com desafios intermediários em Ruby/TipoDeCombustivel.rb: -------------------------------------------------------------------------------- 1 | # Tipo de Combustível 2 | 3 | # Você recebeu desafio para determinar qual dos produtos é o preferêncial dos 4 | # clientes de um posto de abastecimento de combustível. Para isso você deve 5 | # escrever um algoritmo para ler o tipo de combustível abastecido (codificado 6 | # da seguinte forma: 1.Álcool 2.Gasolina 3.Diesel 4.Fim). Caso o usuário 7 | # informe um código inválido (fora da faixa de 1 a 4) deve ser solicitado um 8 | # novo código (até que seja válido). O programa será encerrado quando o código 9 | # informado for o número 4. 10 | 11 | # Entrada 12 | # A entrada contém apenas valores inteiros e positivos. 13 | 14 | # Saída 15 | # Deve ser escrito a mensagem: "MUITO OBRIGADO" e a quantidade de clientes que 16 | # abasteceram cada tipo de combustível, conforme exemplo. 17 | 18 | option = 0 19 | alcohol = 0 20 | fuel = 0 21 | diesel = 0 22 | 23 | while option != 4 24 | option = gets.strip.to_i 25 | case option 26 | when 1 then alcohol += 1 27 | when 2 then fuel += 1 28 | when 3 then diesel += 1 29 | when 4 then puts "MUITO OBRIGADO" 30 | end 31 | end 32 | 33 | puts "Alcool: #{alcohol}" 34 | puts "Gasolina: #{fuel}" 35 | puts "Diesel: #{diesel}" -------------------------------------------------------------------------------- /Ruby/Solucionando desafios matemáticos em Ruby/AcimaDaDiagonalPrincipal.rb: -------------------------------------------------------------------------------- 1 | # Acima da Diagonal Principal 2 | 3 | # Leia um caractere maiúsculo, que indica uma operação que deve ser realizada e 4 | # uma matriz M[12][12]. Em seguida, calcule e mostre a soma ou a média 5 | # considerando somente aqueles elementos que estão acima da diagonal principal da 6 | # matriz, conforme ilustrado abaixo (área verde). 7 | 8 | # - Entrada 9 | 10 | # A primeira linha de entrada contem um único caractere Maiúsculo O ('S' ou 'M'), 11 | # indicando a operação (Soma ou Média) que deverá ser realizada com os elementos 12 | # da matriz. Seguem os 144 valores de ponto flutuante que compõem a matriz. 13 | 14 | # - Saída 15 | 16 | # Imprima o resultado solicitado (a soma ou média), com 1 casa após o ponto 17 | # decimal. 18 | 19 | O = gets.chomp.upcase 20 | M = Array.new 21 | sum = 0.0 22 | count = 0 23 | 24 | (1..12).each_with_index do |v1, k1| 25 | row = Array.new 26 | (1..12).each_with_index do |v2, k2| 27 | value = gets.chomp.to_f 28 | row << value 29 | if k2 > k1 30 | sum += value 31 | count += 1 32 | end 33 | end 34 | M << row 35 | end 36 | 37 | case O 38 | when 'S' then 39 | puts sum 40 | when 'M' then 41 | media = sum / count 42 | puts media.round(1) 43 | end -------------------------------------------------------------------------------- /Ruby/Solucionando desafios matemáticos em Ruby/FibonacciEmVetor.rb: -------------------------------------------------------------------------------- 1 | # Fibonacci em Vetor 2 | 3 | # Nesse desafio você terá que desenvolver um programa que leia um valor e 4 | # apresente o número de Fibonacci correspondente a este valor lido. Lembre que os 5 | # 2 primeiros elementos da série de Fibonacci são 0 e 1 e cada próximo termo é a 6 | # soma dos 2 anteriores a ele. Todos os valores de Fibonacci calculados neste 7 | # problema devem caber em um inteiro de 64 bits sem sinal. 8 | 9 | # - Entrada 10 | 11 | # A primeira linha da entrada contém um inteiro T, indicando o número de casos de 12 | # teste. Cada caso de teste contém um único inteiro N (0 ≤ N ≤ 60), 13 | # correspondente ao enésimo termo da série de Fibonacci. 14 | 15 | # - Saída 16 | 17 | # Para cada caso de teste da entrada, imprima a mensagem "Fib(N) = X", onde X é 18 | # o N-ésimo termo da série de Fibonacci. 19 | 20 | def fibonacci(n) 21 | vector = [0,1] 22 | 23 | index = 2 24 | while index < n + 1 25 | a = vector[index-2] 26 | p = vector[index-1] 27 | vector[index] = a + p 28 | index += 1 29 | end 30 | vector[n] 31 | end 32 | 33 | t = gets.strip.to_i 34 | output = "" 35 | 36 | t.times do 37 | n = gets.strip.to_i 38 | value = fibonacci(n) 39 | output << "Fib(#{n}) = #{value}\n" 40 | end 41 | 42 | puts output -------------------------------------------------------------------------------- /Ruby/Solucionando desafios matemáticos em Ruby/SubstituicaoEmVetorI.rb: -------------------------------------------------------------------------------- 1 | # Substituição em Vetor I 2 | 3 | # Faça um programa que leia um vetor X[10]. Substitua a seguir, todos os valores 4 | # nulos e negativos do vetor X por 1. Em seguida mostre o vetor X. 5 | 6 | # - Entrada 7 | 8 | # A entrada contém 10 valores inteiros, podendo ser positivos ou negativos. 9 | 10 | # - Saída 11 | 12 | # Para cada posição do vetor, escreva "X[i] = x", onde i é a posição do vetor e 13 | # x é o valor armazenado naquela posição. 14 | 15 | x = [] 16 | 17 | 10.times do 18 | number = gets.strip.to_i 19 | number = 1 if number <= 0 20 | x.push(number) 21 | end 22 | 23 | x.each_with_index do |item, index| 24 | puts "X[#{index}] = #{item}" 25 | end -------------------------------------------------------------------------------- /Ruby/Solucionando problemas básicos em Ruby/DDD.rb: -------------------------------------------------------------------------------- 1 | # DDD 2 | 3 | # Leia um número inteiro que representa um código de DDD para discagem 4 | # interurbana. Em seguida, informe à qual cidade o DDD pertence, considerando a 5 | # tabela abaixo: 6 | 7 | # Se a entrada for qualquer outro DDD que não esteja presente na tabela acima, o 8 | # programa deverá informar: 9 | # DDD nao cadastrado 10 | 11 | # - Entrada 12 | 13 | # A entrada consiste de um único valor inteiro. 14 | 15 | # - Saída 16 | 17 | # Imprima o nome da cidade correspondente ao DDD existente na entrada. Imprima 18 | # DDD nao cadastrado caso não existir DDD correspondente ao número digitado. 19 | 20 | codigo = gets.strip.to_i 21 | 22 | case codigo 23 | when 61 then puts "Brasilia" 24 | when 71 then puts "Salvador" 25 | when 11 then puts "Sao Paulo" 26 | when 21 then puts "Rio de Janeiro" 27 | when 32 then puts "Juiz de Fora" 28 | when 19 then puts "Campinas" 29 | when 27 then puts "Vitoria" 30 | when 31 then puts "Belo Horizonte" 31 | 32 | else puts "DDD nao cadastrado" 33 | end -------------------------------------------------------------------------------- /Ruby/Solucionando problemas básicos em Ruby/IdadeEmDias.rb: -------------------------------------------------------------------------------- 1 | # Idade em Dias 2 | 3 | # Você terá o desafio de ler um valor inteiro correspondente à idade de uma 4 | # pessoa em dias e informe-a em anos, meses e dias 5 | 6 | # Obs.: apenas para facilitar o cálculo, considere todo ano com 365 dias e todo 7 | # mês com 30 dias. Nos casos de teste nunca haverá uma situação que permite 12 8 | # meses e alguns dias, como 360, 363 ou 364. 9 | 10 | # - Entrada 11 | 12 | # O arquivo de entrada contém um valor inteiro. 13 | 14 | # - Saída 15 | 16 | # Imprima a saída conforme exemplo fornecido. 17 | 18 | idade_dias = gets.strip.to_i 19 | 20 | idade_anos = idade_dias / 365; 21 | idade_meses = ((idade_dias % 365) / 30); 22 | idade_dias = ((idade_dias % 365) % 30); 23 | 24 | puts "#{idade_anos} ano(s)" 25 | puts "#{idade_meses} mes(es)" 26 | puts "#{idade_dias} dia(s)" -------------------------------------------------------------------------------- /Ruby/Solucionando problemas básicos em Ruby/ParOuImpar.rb: -------------------------------------------------------------------------------- 1 | # Par ou Ímpar 2 | 3 | # Leia um valor inteiro N. Este valor será a quantidade de valores que serão 4 | # lidos em seguida. Para cada valor lido, mostre uma mensagem em inglês dizendo 5 | # se este valor lido é par (EVEN), ímpar (ODD), positivo (POSITIVE) ou negativo 6 | # (NEGATIVE). No caso do valor ser igual a zero (0), embora a descrição correta 7 | # seja (EVEN NULL), pois por definição zero é par, seu programa deverá 8 | # imprimir apenas NULL. 9 | 10 | # - Entrada 11 | 12 | # A primeira linha da entrada contém um valor inteiro N(N < 10000) que indica o 13 | # número de casos de teste. Cada caso de teste a seguir é um valor inteiro 14 | # X (-107 < X <107). 15 | 16 | # - Saída 17 | 18 | # Para cada caso, imprima uma mensagem correspondente, de acordo com o exemplo 19 | # abaixo. Todas as letras deverão ser maiúsculas e sempre deverá haver um espaço 20 | # entre duas palavras impressas na mesma linha. 21 | 22 | ntimes = gets.strip.to_i 23 | out = "" 24 | 25 | ntimes.times do |num| 26 | num = gets.strip.to_i 27 | 28 | if num == 0 29 | out << "NULL\n" 30 | elsif num > 0 && num % 2 == 0 31 | out << "EVEN POSITIVE\n" 32 | elsif num > 0 && num % 2 != 0 33 | out << "ODD POSITIVE\n" 34 | elsif num < 0 && num % 2 == 0 35 | out << "EVEN NEGATIVE\n" 36 | else 37 | out << "ODD NEGATIVE\n" 38 | end 39 | end 40 | 41 | puts out -------------------------------------------------------------------------------- /assets/abaixo-diagonal-principal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/abaixo-diagonal-principal.png -------------------------------------------------------------------------------- /assets/abaixo-diagonal-secundaria.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/abaixo-diagonal-secundaria.png -------------------------------------------------------------------------------- /assets/acima-diagonal-principal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/acima-diagonal-principal.png -------------------------------------------------------------------------------- /assets/acima-diagonal-secundaria.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/acima-diagonal-secundaria.png -------------------------------------------------------------------------------- /assets/animal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/animal.png -------------------------------------------------------------------------------- /assets/area-direita.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/area-direita.png -------------------------------------------------------------------------------- /assets/area-esquerda.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/area-esquerda.png -------------------------------------------------------------------------------- /assets/area-inferior.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/area-inferior.png -------------------------------------------------------------------------------- /assets/area-superior.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/area-superior.png -------------------------------------------------------------------------------- /assets/banner.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/banner.png -------------------------------------------------------------------------------- /assets/batmain.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/batmain.jpg -------------------------------------------------------------------------------- /assets/bob-conduite.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/bob-conduite.jpg -------------------------------------------------------------------------------- /assets/coluna-matriz.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/coluna-matriz.png -------------------------------------------------------------------------------- /assets/conversao-simples-base.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/conversao-simples-base.gif -------------------------------------------------------------------------------- /assets/coordenadas-de-um-ponto.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/coordenadas-de-um-ponto.png -------------------------------------------------------------------------------- /assets/csharp.svg: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /assets/ddd.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/ddd.png -------------------------------------------------------------------------------- /assets/fases-da-lua.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/fases-da-lua.png -------------------------------------------------------------------------------- /assets/figurinhas.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/figurinhas.jpg -------------------------------------------------------------------------------- /assets/java.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /assets/javascript.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /assets/kotlin.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /assets/mudanca.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/mudanca.png -------------------------------------------------------------------------------- /assets/notas-prova.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/notas-prova.png -------------------------------------------------------------------------------- /assets/o-maior.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/o-maior.png -------------------------------------------------------------------------------- /assets/poligonos-regulares-simples.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/poligonos-regulares-simples.jpg -------------------------------------------------------------------------------- /assets/taxa-imposto-renda.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/taxa-imposto-renda.png -------------------------------------------------------------------------------- /assets/xadrez.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/xadrez.png -------------------------------------------------------------------------------- /assets/xenlongao.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Pleiterson/desafios-bootcamps-dio/0dbf1237ad25c1b844421d33649efc729dd9a33d/assets/xenlongao.png --------------------------------------------------------------------------------