<|start_filename|>Desafios/Java/1. Ordenação e Filtros em Java/3. Uniformes de Final de Ano/YearEndUniform.java<|end_filename|>
/**
 * Uniformes de Final de Ano
 *
 * Desafio:
 * - O professor Girafales organizou a confecção de um uniforme para as 
 * turmas da escola para comemorar o final do ano. Após algumas conversas, 
 * ficou decidido com os alunos que eles poderiam escolher a cor do uniforme 
 * entre branco ou vermelho. Assim sendo, Girafales precisa de sua ajuda para 
 * organizar as listas de quem quer o uniforme em cada uma das turmas, relacionando 
 * estas camisetas pela cor, tamanho (P, M ou G) e por último pelo nome.
 * 
 * Entrada:
 * - Cada caso de teste inicia com um valor N, (1 ≤ N ≤ 60) inteiro e positivo, que 
 * indica a quantidade de uniformes a serem feitas para aquela turma. As próximas N*2 
 * linhas contém informações de cada um dos uniformes (serão duas linhas de informação 
 * para cada uniforme). A primeira linha irá conter o nome do estudante e a segunda linha 
 * irá conter a cor do uniforme ("branco" ou "vermelho") seguido por um espaço e pelo tamanho 
 * do uniforme "P" "M" ou "G". A entrada termina quando o valor de N for igual a zero (0) e 
 * esta valor não deverá ser processado.
 * 
 * Saída:
 * - Para cada caso de entrada deverão ser impressas as informações ordenadas pela 
 * cor em ordem ascendente, seguido pelos tamanhos em ordem descendente e por último 
 * por ordem ascendente de nome, conforme o exemplo abaixo.
 */

import java.io.IOException;
import java.util.*;

public class YearEndUniform 
{  
  private String name;
  private String uniformSize;
  private String uniformColor;

  public String getUniformColor() 
  {  
    return this.uniformColor;  
  }

  public void setUniformColor(String uniformColor) 
  {  
    this.uniformColor = uniformColor;
  }

  public String getName() 
  {  
    return this.name;
  }

  public void setName(String name) 
  {
    this.name = name;
  }

  public String getUniformSize() 
  {
    return this.uniformSize;
  }

  public void setUniformSize(String uniformSize) 
  {
    this.uniformSize = uniformSize;
  }

  public YearEndUniform(String name, String uniformColor, String uniformSize) 
  {
    this.name = name;
    this.uniformColor = uniformColor;
    this.uniformSize = uniformSize;
  }

  public void printStudentInfos() 
  {
      System.out.println(this.uniformColor + " " + uniformSize + " " + name);
  }
  
  public static void main(String[] args) throws IOException 
  {  
    Scanner scanner = new Scanner(System.in);
    int N = scanner.nextInt(); 
    scanner.nextLine();
    ArrayList<YearEndUniform> arrayUniforms= new ArrayList<>(N);
    String name, uniformDetails, uniformColor, uniformSize;

    for(int i = 0; i < N; i++) 
    {  
      name = scanner.nextLine(); 
      uniformDetails = scanner.nextLine();  
      uniformColor = uniformDetails.split(" ")[0];
      uniformSize= uniformDetails.split(" ")[1];
      arrayUniforms.add(new YearEndUniform(name, uniformColor, uniformSize));
    }

    scanner.close();
    Collections.sort(arrayUniforms, new UniformComparator());

    for(var item : arrayUniforms) 
    {  
      item.printStudentInfos(); 
    }
  }

  static class UniformComparator implements Comparator<YearEndUniform> 
  {  
    @Override
    public int compare(YearEndUniform student0, YearEndUniform student1) 
    {  
      int res = student0.uniformColor.compareTo(student1.uniformColor);
    
      if(res == 0) 
      {
        res = student0.uniformSize.compareTo(student1.uniformSize);
        
        if(res == 0) 
        {  
          res = student0.name.compareTo(student1.name);
        } else {
          res = -res;
        }
      }
      return res;
    }
  }
}

<|start_filename|>Desafios/JavaScript/7. Introdução a Programação com JavaScript/1. Visita na Feira/solucao.js<|end_filename|>
/**
 * 1/3 - Visita na Feira
 * 
 * Desafio
 *      Você está na feira com a sua sacola e parou em uma banca. O feirante 
 * lhe entregou pimentões amarelos e vermelhos. Agora iremos somar os pimetões 
 * amarelos e vermelhos para descobrir o total de pimentões na sacola.  Você 
 * receberá 2 inteiros que devem ser lidos e armazenados nas variáveis A (pimentões 
 * amarelos) e B (pimentões vermelhos). Faça a soma de A e B atribuindo o seu 
 * resultado na variável X (total de pimentões). Apresente X como descrito na mensagem 
 * de exemplo abaixo. Não apresente outra mensagem além da mensagem especificada.
 * 
 * Entrada
 *      A entrada contém 2 valores inteiros, separados por um espaço.
 * 
 * Saída
 *      Imprimir a mensagem "X = " (sendo a letra X maiúscula) seguido pelo valor da 
 * variável X e pelo final de linha. Assegure que exista um espaço antes e depois do 
 * sinal de igualdade.
 */

let line = gets().split(" ");

let A = parseInt(line[0]);
let B = parseInt(line[1]);
let X = A + B

let total = X;

console.log("X = " + total);

<|start_filename|>Desafios/JavaScript/1. Introdução a Programação/1.2. Distância/solucao.js<|end_filename|>
 /**
  * Distância
  *
  * Desafio:
  * - Duas motos (X e Y) partem em uma mesma direção. A moto X sai com velocidade 
  * constante de 60 Km/h e a moto Y sai com velocidade constante de 90 Km/h.
  *
  * - Em uma hora (60 minutos) a moto Y consegue se distanciar 30 quilômetros da moto X, 
  * ou seja, consegue se afastar um quilômetro a cada 2 minutos.
  * 
  * - O seu desafio é ler a distância (em Km) e calcular quanto tempo leva (em minutos) 
  * para a moto Y tomar essa distância da outra moto.
  * 
  * Entrada:
  * - O arquivo de entrada contém um número inteiro K que representa a quantidade de 
  * quilômetro que que a moto Y deve estar da moto X.
  * 
  * Saída:
  * - Imprima o tempo necessário para a moto Y ficar com a quantidade K de quilômetro 
  * da moto X, seguido da mensagem " minutos".
  */

 let quilometros = parseInt(gets());
 let minutos = quilometros * 2;  
 
 console.log(minutos + " minutos");

<|start_filename|>Desafios/JavaScript/6. Desenvolvimento de problemas avançados em JavaScript/3. Compras no Supermercado/solucao.js<|end_filename|>
/**
 * 3/3 - Compras no Supermercado
 * 
 * Desafio
 *      Pedro trabalha sempre até tarde todos os dias, com isso tem pouco tempo tempo 
 * para as tarefas domésticas. Para economizar tempo ele faz a lista de compras do 
 * supermercado em um aplicativo e costuma anotar cada item na mesma hora que percebe 
 * a falta dele em casa.
 * 
 *      O problema é que o aplicativo não exclui itens duplicados, como Pedro anota o 
 * mesmo item mais de uma vez e a lista acaba ficando extensa. Sua tarefa é melhorar 
 * o aplicativo de notas desenvolvendo um código que exclua os itens duplicados da lista 
 * de compras e que os ordene alfabeticamente.
 * 
 * Entrada
 *      A primeira linha de entrada contém um inteiro N (N < 100) com a quantidade de 
 * casos de teste que vem a seguir, ou melhor, a quantidade de listas de compras para 
 * organizar. Cada lista de compra consiste de uma única linha que contém de 1 a 1000 
 * itens ou palavras compostas apenas de letras minúsculas (de 1 a 20 letras), sem acentos 
 * e separadas por um espaço.
 * 
 * Saída
 *      A saída contém N linhas, cada uma representando uma lista de compra, sem os itens 
 * repetidos e em ordem alfabética.
 */

let num = parseInt(gets());
let index = 0;

let listas = Array(num);
let listaSet = Array(num);

while (index < num ) {
    listas[index] = gets().split(" ");
    index++;
}

listas.map((i,d) => listaSet[d] = new Set(i));
listaSet.map((i,d) => listas[d] = [...i]);

listas.forEach(i => i.sort());
listas.forEach(i => console.log(i.join(" ")));

<|start_filename|>Desafios/C Sharp/5. Solução de Problemas em C#/3. Aumento de Salário/solucao.cs<|end_filename|>
/**
 Desafio
    A empresa ABC resolveu conceder um aumento de salários a seus 
 funcionários de acordo com a tabela abaixo:

 Salário            |       Percentual de Reajuste
 0 - 400.00         |       15%
 400.01 - 800.00    |       12%
 800.01 - 1200.00   |       10%
 1200.01 - 2000.00  |       7%
 Acima de 2000.00   |       4%

    Leia o salário do funcionário e calcule e mostre o novo salário, 
 bem como o valor de reajuste ganho e o índice reajustado, em percentual.

 Entrada
    A entrada contém apenas um valor de ponto flutuante, que pode ser maior 
 ou igual a zero, com duas casas decimais.

 Saída
    Imprima 3 linhas na saída: o novo salário, o valor ganho de reajuste e o 
 percentual de reajuste ganho, conforme exemplo abaixo.
*/

using System;

class AumentoDeSalario
{
    static void Main(string[] args)
    {
        string salarioStr = "";
        double salario= 0.00;
        double novoSalario = 0.00;
        double reajuste = 0.00;
        double percentual = 0.00;

        salarioStr = Console.ReadLine().Replace(",",".");
        salario = double.Parse(salarioStr);
    
        if (salario < 0.00) 
        {
            return;
        }

        else if (salario <= 400.00)
        {
            percentual = 0.15;
            reajuste = salario * percentual;
            novoSalario = salario + reajuste;
        }

        else if (salario <= 800.00) 
        {
            percentual = 0.12;
            reajuste = salario * percentual;
            novoSalario = salario + reajuste;
        }

        else if (salario <= 1200.00)
        {
            percentual = 0.10;
            reajuste = salario * percentual;
            novoSalario = salario + reajuste;
        }

        else if (salario <= 2000.00)
        {
            percentual = 0.07;
            reajuste = salario * percentual;
            novoSalario = salario + reajuste;
        }

        else 
        {
            percentual = 0.04;
            reajuste = salario * percentual;
            novoSalario = salario + reajuste;
        }
    
        Console.WriteLine("Novo salario: {0:0.00}", novoSalario);
        Console.WriteLine("Reajuste ganho: {0:0.00}", reajuste);
        Console.WriteLine("Em percentual: {0} %", percentual * 100);
    }
}

<|start_filename|>Desafios/JavaScript/4. Solução de Problemas Essenciais/4.3. Ultrapassando V/solucao.js<|end_filename|>
/**
 * Ultrapassando V
 *
 * Desafio:
 * - Como um bom desenvolvedor, você precisa fazer um programa 
 * que leia dois ingeiros: R e V (devem ser lidos tantos valores 
 * para V quantos necessários, até que seja digitado um valor 
 * maior do que R para ele). Conte quantos números inteiros devem 
 * ser somados em sequência (considerando o R nesta soma) para que 
 * a soma ultrapasse a V o mínimo possível. Escreva o valor final 
 * da contagem.
 * 
 * - A entrada pode conter, por exemplo, os valores 21 21 15 30. 
 * Neste caso, é então assumido o valor 21 para R enquanto os valores 
 * 21 e 15 devem ser desconsiderados pois são menores ou iguais a R. 
 * Como o valor 30 está dentro da especificação (maior do que R) ele 
 * será válido e então deve-se processar os cálculos para apresentar 
 * na saída o valor 2, pois é a quantidade de valores somados para se 
 * produzir um valor maior do que 30 (21 + 22).
 * 
 * Entrada:
 * - A entrada contém somente valores inteiros, um por linha, podendo 
 * ser positivos ou negativos. O primeiro valor da entrada será o valor 
 * de R. A próxima linha da entrada irá conter V. Se V não atender a 
 * especificação do problema, ele deverá ser lido novamente, tantas vezes 
 * quantas forem necessárias.
 * 
 * Saída:
 * - mprima uma linha com um número inteiro que representa a quantidade de 
 * números inteiros que devem ser somadas, de acordo com a especificação acima.
 */

let R = parseInt(gets());

let V = 0;

let soma = 0;
let contaN = 0;

while(V <= R) {

  V = parseInt(gets());

}

while(soma <= V) {
  
    soma += R;
    R++;
    contaN++;

}

console.log(contaN);

<|start_filename|>Desafios/JavaScript/7. Introdução a Programação com JavaScript/2. Multiplicação Simples/solucao.js<|end_filename|>
/**
 * 2/3 - Multiplicação Simples
 * 
 * Desafio
 *      Você receberá dois valores inteiros. Faça a leitura e em seguida calcule 
 * o produto entre estes dois valores. Atribua esta operação à variável PROD, 
 * mostrando esta de acordo com a mensagem de saída esperada (exemplo abaixo).   
 * 
 * Entrada
 *      A entrada contém 2 valores inteiros.
 * 
 * Saída
 *      Exiba a variável PROD conforme exemplo abaixo, tendo obrigatoriamente um 
 * espaço em branco antes e depois da igualdade.
 */

let valor1 = parseInt(gets());
let valor2 = parseInt(gets());

let total = valor1 * valor2;

console.log("PROD = " + total);

<|start_filename|>Desafios/C Sharp/2. Resolvendo Algoritmos/4. Conversão de Tempo/solucao.cs<|end_filename|>
/**********************************************************************************************
 *
 * 4/7 - Conversão de Tempo  
 *
 ******************************** Desafio:
 *
 *      Você terá o desafio de ler um valor inteiro, que é o tempo de duração em segundos de um 
 * determinado evento em uma loja, e informe-o expresso no formato horas:minutos:segundos.
 *
 ******************************** Entrada:
 *
 *      O arquivo de entrada contém um valor inteiro N.
 *
 ******************************** Saída:
 *
 *      Imprima o tempo lido no arquivo de entrada (segundos), convertido para horas:minutos:
 * segundos, conforme exemplo fornecido.
 *
 **********************************************************************************************/

using System;

namespace Desafio4
{  
    class ConversaoDeTempo 
    {  
        static void Main(string[] args) 
        {
          var tempo = int.Parse(Console.ReadLine());

          var horas = (tempo / 3600); 
          var minutos = (tempo % 3600) / 60; 
          var segundos =  (tempo % 3600) % 60;

          Console.WriteLine($"{horas}:{minutos}:{segundos}");
        }
    }
}

<|start_filename|>Desafios/JavaScript/4. Solução de Problemas Essenciais/4.5. Pedro Bento e o Mundo de OZ/solucao.js<|end_filename|>
/**
 * <NAME> e o Mundo de OZ
 *
 * Desafio:
 * - No jogo, O Mundo de Oz, <NAME> é o 
 * líder do Tribunal, por causa disso ele é 
 * uma das pessoas mais importantes do mundo, 
 * no jogo. Além disso, <NAME> possui um 
 * grande tesouro, o qual possui diversos tipos 
 * de jóias.
 * 
 * - <NAME> está muito curioso para saber 
 * quantos tipos de jóias diferentes seu tesouro 
 * possui.
 * 
 * - Sabendo que você é o melhor programador do mundo, 
 * <NAME> te contratou para verificar quantos tipos 
 * de jóias distintas ele tem em seu tesouro.
 * 
 * Entrada:
 * - A entrada consiste de várias linhas e cada uma contém 
 * uma string que descreve uma das jóias de <NAME>. 
 * Essa string é composta apenas dos caracteres '(' e ')', 
 * a soma do tamanho de todas as string não excede 106.
 * 
 * Saída:
 * - Imprima quantos tipos de jóias distintas <NAME> 
 * possui.
 */

let jewels = [];

while(true) {
    
    let input = gets();
    
    if(!input) {
        
        break;
    
    }
  
    let find = jewels.find(el => el == input);
  
    if(!find) {
        
        jewels.push(input);
  
    }
}

console.log(jewels.length);

<|start_filename|>Desafios/C Sharp/8. Praticando Programação em C#/1. Coordenadas de um Ponto/solucao.cs<|end_filename|>
using System;
using System.Globalization;

namespace Coordenadas_De_Um_Ponto
{
  class Program
  {
    static void Main(string[] args)
    {
      string[] s = Console.ReadLine().Split(' ');
      double X, Y;
      
      X = double.Parse(s[0], CultureInfo.InvariantCulture);
      Y = double.Parse(s[1], CultureInfo.InvariantCulture);
      
      if ( X == 0.0 && Y == 0.0 ) { 
        Console.WriteLine("Origem"); 
      } else if ( X == 0.0 ) { 
        Console.WriteLine("Eixo Y"); 
      } else if ( Y == 0.0 ) { 
        Console.WriteLine("Eixo X"); 
      } else if ( X > 0.0 && Y > 0.0 ) { 
        Console.WriteLine("Q1"); 
      } else if ( X < 0.0 && Y > 0.0 ) { 
        Console.WriteLine("Q2"); 
      } else if ( X < 0.0 && Y < 0.0 ) { 
        Console.WriteLine("Q3"); 
      } else if ( X > 0.0 && Y < 0.0 ) { 
        Console.WriteLine("Q4"); 
      }
    }
  }
}

<|start_filename|>Desafios/C Sharp/8. Praticando Programação em C#/3. Pink e Cérebro/solucao.cs<|end_filename|>
using System;

namespace Pink_E_Cerebro
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine()),
                num, 
                cont2 = 0, 
                cont3 = 0, 
                cont4 = 0, 
                cont5 = 0;
      
            string[] numString = Console.ReadLine().Split();
      
            for (int i = 0; i < n; i++) {
                num = int.Parse(numString[i]);
          
                if (num % 2 == 0) {
                    cont2++;
                }
                
                if (num % 3 == 0) {
                    cont3++;
                }
                
                if (num % 4 == 0) {
                    cont4++;
                }
                
                if (num % 5 == 0) {
                    cont5++;
                }
            }
      
            Console.WriteLine($"{cont2} Multiplo(s) de 2\n" +
                                $"{cont3} Multiplo(s) de 3\n" +
                                $"{cont4} Multiplo(s) de 4\n" +
                                $"{cont5} Multiplo(s) de 5");
        }
    }
}

<|start_filename|>Desafios/Java/1. Ordenação e Filtros em Java/4. Fila do Banco/BankQueue.java<|end_filename|>
/**
 * Fila do Banco
 *
 * Desafio:
 * - O banco que você trabalha sempre tem problemas para organizar 
 * as filas de atendimento dos clientes.
 * 
 * - Após uma reunião com a gerência ficou decidido que os clientes 
 * ao chegar na agência receberão uma senha numérica em seu aparelho 
 * de celular via sms e que a ordem da fila será dada não pela ordem 
 * de chegada, mas sim pelo número recebido via sms. Sendo, aqueles 
 * com número maior deverão ser atendidos primeiro. 
 * 
 * - Então, dada a ordem de chegada dos clientes reordene a fila de 
 * acordo com o número recebido via sms, e diga quantos clientes não 
 * precisaram trocar de lugar nessa reordenação.
 * 
 * Entrada:
 * - A primeira linha contém um inteiro N, indicando o número de casos 
 * de teste a seguir.
 * 
 * - Cada caso de teste inicia com um inteiro M (1 ≤ M ≤ 1000), indicando 
 * o número de clientes. Em seguida haverá M inteiros distintos Pi 
 * (1 ≤ Pi ≤ 1000), onde o i-ésimo inteiro indica o número recebido via 
 * sms do i-ésimo cliente.
 * 
 * - Os inteiros acima são dados em ordem de chegada, ou seja, o primeiro 
 * inteiro diz respeito ao primeiro cliente a chegar na fila, o segundo 
 * inteiro diz respeito ao segundo cliente, e assim sucessivamente.
 * 
 * Saída:
 * - Para cada caso de teste imprima uma linha, contendo um inteiro, 
 * indicando o número de clientes que não precisaram trocar de lugar 
 * mesmo após a fila ser reordenada.
 */

import java.io.IOException;
import java.util.*;

public class BankQueue {  

    private Integer smsNumber;

    public BankQueue(int smsNumber) {
        this.smsNumber = smsNumber;
    }

    public int getSmsNumber() {
        return this.smsNumber;
    }
  
  public static void main(String[] args) throws IOException {
    
    Scanner scanner = new Scanner(System.in);
    int N = scanner.nextInt();
    scanner.nextLine();
    int peopleOnQueue;
    ArrayList<Integer> currentQueue = new ArrayList<>();
    HashMap<Integer, Integer> numToIndexOriginal = new HashMap<>();
    int currentSmsNumber;
    int numSwitches;

    for(int i = 0; i < N; i++) {
      
        peopleOnQueue = scanner.nextInt();
        numSwitches = 0;

        for(int j = 0; j < peopleOnQueue; j++) {
        
            currentSmsNumber = scanner.nextInt();
            currentQueue.add(currentSmsNumber);
            numToIndexOriginal.put(currentSmsNumber, currentQueue.size() - 1);
      
        }

      
        SmsNumberComparator comparator = new SmsNumberComparator();
        Collections.sort(currentQueue, comparator);


      
        for(int j = 0; j < currentQueue.size(); j++) {
        
            int originalIndex = numToIndexOriginal.get(currentQueue.get(j));
        
        
            if(originalIndex != j) {
          
                numSwitches++;
        
            }
      
        }

        System.out.println(peopleOnQueue - numSwitches);
        currentQueue = new ArrayList<>();
    
    }
    
    scanner.close();
  
}

static class SmsNumberComparator implements Comparator<Integer> {

    public SmsNumberComparator() {}

    @Override
    public int compare(Integer num0, Integer num1) {
      
        int res = num0.compareTo(num1);
        return -res;
    
    }
  
}
}

<|start_filename|>Desafios/C Sharp/6. Desafios Aritméticos em C#/3. Bazinga!/solucao.cs<|end_filename|>
/**
 Desafio
    Em um episódio da aclamada série The Big Ban Theor dois pernagens, Sheldon e Raj, discutem 
 qual dos dois é o melhor: o filme Saturn 3 ou a série Deep Space 9. A sugestão de Raj para a 
 resolução do impasse é uma disputa de Pedra-Papel-Tesoura. Contudo, Sheldon argumenta que, se 
 as partes envolvidas se conhecem, entre 75% e 80% das disputas de Pedra-Papel-Tesoura terminam 
 empatadas, e então sugere o Pedra-Papel-Tesoura-Lagarto-Spock.

    As regras do jogo proposto são:

 a tesoura corta o papel;
 o papel embrulha a pedra;
 a pedra esmaga o lagarto;
 o lagarto envenena Spock;
 Spock destrói a tesoura;
 a tesoura decapita o lagarto;
 o lagarto come o papel;
 o papel contesta Spock;
 Spock vaporiza a pedra;
 a pedra quebra a tesoura.

    Conhecendo os personagens, sabemos que caso Sheldon vencesse, ele gritaria a vitória com um "Bazinga!". 
 Se Raj vencesse, Sheldon o acusaria de ter trapaceado. Agora, se desse empate, Sheldon não descansaria e 
 insistira para jogarem de novo até que seja decidido. Sabendo dessas ações, faça um programa que imprima 
 a provável reação de Sheldon.

 Entrada
    A entrada consiste em uma série de casos de teste. A primeira linha contém um inteiro positivo T (T ≤ 100), 
 que representa o número de casos de teste. Cada caso de teste é representado por uma linha da entrada, contendo 
 as escolhas de Sheldon e Raj, respectivamente, separadas por um espaço em branco. As escolhas possíveis são as 
 personagens do jogo: pedra, papel, tesoura, lagarto e Spock.

 Saida
    Para cada caso de teste deverá ser impressa a mensagem "Caso #t: R", onde t é o número do caso de teste 
 (cuja contagem se inicia no número um) e R é uma das três reações possíveis de Sheldon: "Bazinga!", 
 "Raj trapaceou!", ou "De novo!".
*/

using System; 

class Bazinga 
{
  static void Main(string[] args) 
  { 
    int qtdTeste = int.Parse(Console.ReadLine());
    
    string v1, v2;
    
    for (int i = 1; i <= qtdTeste; i++)
    {
      string[] valores = Console.ReadLine().Split();
      
      v1 = valores[0];
      v2 = valores[1];
      
      if(( v1 == "tesoura" && v2 == "papel") || (v1 == "papel" && v2 == "pedra") || 
        (v1 == "pedra" && v2 == "lagarto") || (v1 == "lagarto" && v2 == "Spock") || 
        (v1 == "Spock" && v2 == "tesoura") || (v1 == "tesoura" && v2 == "lagarto") || 
        (v1 == "lagarto" && v2 == "papel") || (v1 == "papel" && v2 == "Spock") || 
        (v1 == "Spock" && v2 == "pedra") || (v1 == "pedra" && v2 == "tesoura"))

        Console.WriteLine("Caso #{0}: Bazinga!", i);                
      
      else if (( v1 == "tesoura" && v2 == "tesoura") || (v1 == "papel" && v2 == "papel") || 
        (v1 == "pedra" && v2 == "pedra") || (v1 == "lagarto" && v2 == "lagarto") || 
        (v1 == "Spock" && v2 == "Spock"))
        
        Console.WriteLine("Caso #{0}: De novo!", i);
      
      else
        Console.WriteLine("Caso #{0}: Raj trapaceou!", i);
    }
  }
}

<|start_filename|>Desafios/Java/1. Ordenação e Filtros em Java/2. Compras no Supermercado/SupermarketShopping.java<|end_filename|>
/**
 * Compras no Supermercado
 *
 * Desafio:
 * - Pedro trabalha sempre até tarde todos os dias, com isso tem 
 * pouco tempo tempo para as tarefas doméstica. Para economizar 
 * tempo ele faz a lista de compras do supermercado em um aplicativo 
 * e costuma anotar cada item na mesma hora que percebe a falta dele 
 * em casa.
 * 
 * - O problema é que o aplicativo não exclui itens duplicados, como 
 * Pedro anota o mesmo item mais de uma vez e a lista acaba ficando 
 * extensa. Sua tarefa é melhorar o aplicativo de notas desenvolvendo 
 * um código que exclua os itens duplicados da lista de compras e que 
 * os ordene alfabeticamente.
 * 
 * Entrada:
 * - A primeira linha de entrada contém um inteiro N (N < 100) com a 
 * quantidade de casos de teste que vem a seguir, ou melhor, a quantidade 
 * de listas de compras para organizar. Cada lista de compra consiste de 
 * uma única linha que contém de 1 a 1000 itens ou palavras compostas apenas 
 * de letras minúsculas (de 1 a 20 letras), sem acentos e separadas por um 
 * espaço.
 * 
 * Saída:
 * - A saída contém N linhas, cada uma representando uma lista de compra, 
 * sem os itens repetidos e em ordem alfabética.
 */

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class SupermarketShopping {

    public static void main(String[] args) {

        Scanner scr = new Scanner(System.in);
        String produtos;

        List<List<String>> listaProdutos = new ArrayList<>() {
            
            private static final long serialVersionUID = 1L;

            @Override
            public String toString() {
                
                StringBuilder stb = new StringBuilder();
                
                for (int i = 0; i < this.size(); i++) {
                    
                    stb.append(this.get(i) + " ");
                
                }

                return stb.toString();
            
            }
        
        };

        Set<String> set = new TreeSet<>();

        int N = scr.nextInt();

        scr.nextLine();

        for (int i = 0; i <N; i++) {

            produtos = scr.nextLine();
            String[] produto = produtos.split(" ");

            for (int j = 0; j < produto.length; j++) {
                
                set.add(produto[j].toLowerCase());
            
            }

            List<String> listaP = new ArrayList<>() {

                private static final long serialVersionUID = 1L;

                @Override
                public String toString() {
                    
                    StringBuilder stb = new StringBuilder();
                    
                    for (int i = 0; i < this.size(); i++) {
                    
                        stb.append(this.get(i) + " ");
                    
                    }

                    return stb.toString();
                
                }
            
            };

            Iterator<String> iterator = set.iterator();
            
            while (iterator.hasNext()) {
                
                listaP.add(iterator.next());
            
            }
            
            listaProdutos.add(listaP);
            set.clear();
        
        }
        
        listaProdutos.forEach(System.out::println);
        scr.close();
    
    }

}

<|start_filename|>Desafios/JavaScript/6. Desenvolvimento de problemas avançados em JavaScript/1. Ordenando Números Pares e Ímpares/solucao.js<|end_filename|>
/**
 * 1/3 - Ordenando Números Pares e Ímpares
 * 
 * Desafio
 *      Crie um programa onde você receberá valores inteiros não negativos 
 * como entrada.
 * 
 *      Ordene estes valores de acordo com o seguinte critério:
 * Primeiro os Pares
 * Depois os Ímpares
 * 
 *      Você deve exibir os pares em ordem crescente e na sequência os ímpares 
 * em ordem decrescente.
 * 
 * Entrada
 *      A primeira linha de entrada contém um único inteiro positivo N 
 * (1 < N < 10000) Este é o número de linhas de entrada que vem logo a seguir. 
 * As próximas N linhas terão, cada uma delas, um valor inteiro não negativo.
 * 
 * Saída
 *      Exiba todos os valores lidos na entrada segundo a ordem apresentada acima. 
 * Cada número deve ser impresso em uma linha, conforme exemplo de saída abaixo.
 */

let num = parseInt(gets());
let index = 0;

let numeros = Array(num);

while (index < num ) {
  
  numero = parseInt(gets());
  
  if (numero >= 0 ) {
    numeros[index] = numero;
    index++;
  }

}

pares = numeros.filter(value => value % 2 == 0);
impares = numeros.filter(value => value % 2 != 0);

pares.sort((a, b) => a-b);
impares.sort((a, b) => b-a);

pares.forEach(i => console.log(i));
impares.forEach(i => console.log(i));

<|start_filename|>Desafios/Java/3. Solução de Problemas Básicos em Java/2. Idade em Dias/solucao.java<|end_filename|>
/**********************************************************************************************
 *
 * 2/3 - Idade em Dias  
 *
 ******************************** Desafio:
 *
 *      Você terá o desafio de ler um valor inteiro correspondente à idade de uma pessoa em dias 
 * e informe-a em anos, meses e dias
 * 
 *      Obs.: apenas para facilitar o cálculo, considere todo ano com 365 dias e todo mês com 30 
 * dias. Nos casos de teste nunca haverá uma situação que permite 12 meses e alguns dias, como 360, 
 * 363 ou 364. 
 *
 ******************************** Entrada:
 *
 *      O arquivo de entrada contém um valor inteiro.
 *
 ******************************** Saída:
 *
 *      Imprima a saída conforme exemplo fornecido.
 *
 **********************************************************************************************/

import java.util.Scanner;

public class IdadeEmDias {
    
    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        int idadeDias = input.nextInt();
        int anos = idadeDias / 365;
        int meses = ((idadeDias % 365) / 30);
        int dias = ((idadeDias % 365) % 30);

        System.out.println(anos + " ano(s)");
        System.out.println(meses + " mes(es)");
        System.out.println(dias + " dia(s)");

        input.close();
    }
 
} 

<|start_filename|>Desafios/Kotlin/3. Praticando programação em Kotlin/3. Bob Conduite/solucao.kt<|end_filename|>
import java.util.Scanner

fun main() {
    for (i in 1..readLine()!!.toInt()) {
        val canos = readLine()!!.split(" ").map { 
            it.toInt() 
        }
        
        val r1 = canos[0]
        val r2 = canos[1]
        
        println(r1 + r2)
    }
}

<|start_filename|>Desafios/JavaScript/2. Fundamentos Aritméticos/2.1. Quantidade de Números Positivos/solucao.js<|end_filename|>
/**
 * Quantidade de Números Positivos
 * 
 * Desafio:
 * - Crie um programa que leia 6 valores. Você poderá receber valores negativos 
 * e/ou positivos como entrada, devendo desconsiderar os valores nulos. Em seguida, 
 * apresente a quantidade de valores positivos digitados.
 * 
 * Entrada:
 * - Você receberá seis valores, negativos e/ou positivos.
 * 
 * Saída:
 * - Exiba uma mensagem dizendo quantos valores positivos foram lidos assim como é 
 * exibido abaixo no exemplo de saída. Não esqueça da mensagem "valores positivos" ao final.
 */

numero = Array(6);

numero[0] = gets();
numero[1] = gets();
numero[2] = gets();
numero[3] = gets();
numero[4] = gets();
numero[5] = gets();

positivos = numero.filter(value => value > 0);

console.log(positivos.length + " valores positivos");

<|start_filename|>Desafios/JavaScript/3. Problemas Aritméticos/3.5. Teorema da Divisão Euclidiana/solucao.js<|end_filename|>
/**
 * Teorema da Divisão Euclidiana
 *
 * Desafio:
 * - Você recebeu desafio de desenvolver um programa 
 * que calcule o quociente e o resto da divisão de 
 * dois números inteiros. Não se esqueça que o quociente 
 * e o resto da divisão de um inteiro a por um inteiro 
 * não-nulo b são respectivamente os únicos inteiros q e r 
 * tais que:
 * 
 * 0 ≤ r < |b|
 * Se r < 0: r = r - |b|
 * a = b × q + r
 * q = ( a - r ) / b
 * 
 * - Caso você não saiba, o teorema que garante a existência 
 * e a unicidade dos inteiros q e r é conhecido como ‘Teorema 
 * da Divisão Euclidiana’ ou ‘Algoritmo da Divisão’.
 * 
 * **  |b| (Módulo / Valor absoluto): É o valor representado de 
 * forma positiva;
 * 
 * Entrada:
 * - A entrada é composta por dois números inteiros a e b 
 * (-1.000 ≤ a, b < 1.000).
 * 
 * Saída:
 * - Imprima o quociente q seguido pelo resto r da divisão 
 * de a por b, considerando as regras apresentadas a cima.
 */

let line = gets().split(' ');

let a = parseInt(line[0]);
let b = parseInt(line[1]);
let q = parseInt(a / b);

let r = a - b * q;

if (r < 0) {
    
    r += Math.abs(b);
    q = (a - r) / b;

}

// parseInt - Apenas como redundância.
console.log(parseInt(q) + " " + parseInt(r));

<|start_filename|>Desafios/Java/2. Resolvendo Algoritmos com Java/1. Coração das Cartas/Main.java<|end_filename|>
/**
 * Coração das Cartas
 *
 * Desafio:
 * - Marcos decidiu abandonar o bar da faculdade onde jogava truco para dedicar-se ao 
 * mundo da programação. Para que isso fosse mais fácil, decidiu criar um novo jogo 
 * de cartas.
 * 
 * - O coração das cartas, como Marcos apelidou o jogo, é individual e jogado com três 
 * pilhas, inicialmente com o mesmo número de cartas. Cada carta tem um valor numérico 
 * inteiro de 0 até 9. O jogador pode, a qualquer momento ver o valor de qualquer carta, 
 * mas só pode jogar com as cartas que estão no topo das pilhas. Em cada rodada, o jogador 
 * pode remover qualquer combinação de cartas que estejam no topo da pilha (pode escolher 1, 
 * 2 ou até 3 cartas) cuja soma dos valores seja múltiplo de 3. O jogo é ganho quando todas 
 * as cartas forem removidas das pilhas. Se alguma carta não puder ser removida, perde-se o 
 * jogo.
 * 
 * Entrada:
 * - A entrada é composta por várias instâncias Cada instância é iniciada por um inteiro N 
 * (0 ≤ N ≤ 100), que identifica o número de cartas em cada pilha. A entrada termina quando 
 * N = 0. Cada uma das N linhas seguintes contém três inteiros A, B e C, que descrevem os 
 * valores numéricos das cartas em um nível da pilha (0 ≤ A, B, C ≤  9). As pilhas são 
 * descritas do topo até o fundo.
 * 
 * Saída:
 * - Para cada instância, imprima uma linha contendo o número 1 se o jogador pode ganhar a 
 * instância do jogo ou o número 0 se o jogo for impossível.
 */

import java.util.*;

public class Main {
    
    static Map<String, Integer> m = new HashMap<String, Integer>();
    static int n;
    static int[][] pilha = new int[3][102];

    static public boolean cartas(int a, int b, int c) {
        
        String ss = "" + a + b + c;
        
        if(a == b && b == c && c == n) {
            
            m.putIfAbsent(ss, 1);
            return true;
        
        }

        int x = m.getOrDefault(ss, 0);
        
        if (x > 0) return (x == 1? true : false);
        
        if(a < n && pilha[0][a]%3 == 0 && cartas(a + 1, b, c)) {
        
            m.putIfAbsent(ss, 1);
            return true;
        
        }
        
        if(b < n && pilha[1][b]%3 == 0 && cartas(a, b + 1, c)) {
        
            m.putIfAbsent(ss, 1);
            return true;
        
        }
        
        if(c < n && pilha[2][c]%3 == 0 && cartas(a, b, c + 1)) {
        
            m.putIfAbsent(ss, 1);
            return true;
        
        }
        if(a < n && b < n && (pilha[0][a]+pilha[1][b]) % 3 == 0 && cartas(a + 1, b + 1, c)) {
            
            m.putIfAbsent(ss, 1);
            return true;
        }

        if(a < n && c < n && (pilha[0][a]+pilha[2][c]) % 3 == 0 && cartas(a + 1, b, c + 1)) {
            
            m.putIfAbsent(ss, 1);
            return true;
        
        }

        if(b < n && c < n && (pilha[1][b]+pilha[2][c])%3 == 0 && cartas(a, b + 1, c + 1)) {
            
            m.putIfAbsent(ss, 1);
            return true;
        
        }
        
        if(a < n && b < n && c < n && (pilha[0][a]+pilha[1][b]+pilha[2][c]) % 3 == 0 && cartas(a + 1, b + 1, c + 1)) {
            
            m.putIfAbsent(ss, 1);
            return true;
        }

        m.putIfAbsent(ss, 2);
        return false;
    
    }

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);

        while(true) {
            
            n = Integer.parseInt(in.nextLine());
            
            if (n == 0) break;
            
            for (int i = 0 ; i < n; i++) {
                
                StringTokenizer st = new StringTokenizer(in.nextLine());
                pilha[0][i] = Integer.parseInt(st.nextToken());
                pilha[1][i] = Integer.parseInt(st.nextToken());
                pilha[2][i] = Integer.parseInt(st.nextToken());
            
            }

            if (cartas(0,0,0) == true) System.out.println("1");
            else System.out.println("0");
            m.clear();
        }

    }

}

<|start_filename|>Desafios/JavaScript/2. Fundamentos Aritméticos/2.3. Análise de Números/solucao.js<|end_filename|>
/**
 * Quantidade de Números Positivos
 * 
 * Desafio:
 * - Você deve fazer a leitura de 5 valores inteiros. 
 * - Em seguida mostre quantos valores informados são pares, 
 * quantos valores informados são ímpares, quantos valores 
 * informados são positivos e quantos valores informados 
 * são negativos.
 * 
 * Entrada:
 * - Você receberá 5 valores inteiros.
 * 
 * Saída:
 * - Exiba a mensagem conforme o exemplo de saída abaixo, 
 * sendo uma mensagem por linha e não esquecendo o final 
 * de linha após cada uma.
 */

numero = Array(5);

numero[0] = gets();
numero[1] = gets();
numero[2] = gets();
numero[3] = gets();
numero[4] = gets();

pares = numero.filter(value => value % 2 == 0);
impares = numero.filter(value => value % 2 != 0);

positivos = numero.filter(value => value > 0);
negativos = numero.filter(value => value < 0);

console.log(pares.length + " valor(es) par(es)");
console.log(impares.length + " valor(es) impar(es)");

console.log(positivos.length + " valor(es) positivo(s)");
console.log(negativos.length + " valor(es) negativo(s)");

<|start_filename|>Desafios/JavaScript/3. Problemas Aritméticos/3.4. Imposto de Renda/solucao.js<|end_filename|>
/**
 * Imposto de Renda
 *
 * Desafio:
 * - Há um país denominado Lilipute, todos os habitantes ficam 
 * felizes em pagar seus impostos, pois sabem que nele não existem 
 * políticos corruptos e os recursos arrecadados são utilizados em 
 * benefício da população, sem qualquer desvio. A moeda deste país 
 * é o Libs, cujo símbolo é o R$.
 * 
 * - Você terá desafio de ler um valor com duas casas decimais, 
 * equivalente ao salário de uma pessoa de Libs. Em seguida, calcule 
 * e mostre o valor que esta pessoa deve pagar de Imposto de Renda, 
 * segundo a tabela abaixo.
 * 
 * - Renda
 * de 0.00 a R$ 2000.00
 * de R$ 2000.01 até R$ 3000.00
 * de R$ 3000.01 até R$ 4500.00
 * acima de R$ 4500.00
 * 
 * - Lembre que, se o salário for R$ 3002.00, a taxa que incide é de 
 * 8% apenas sobre R$ 1000.00, pois a faixa de salário que fica de 
 * R$ 0.00 até R$ 2000.00 é isenta de Imposto de Renda. No exemplo 
 * fornecido (abaixo), a taxa é de 8% sobre R$ 1000.00 + 18% sobre 
 * R$ 2.00, o que resulta em R$ 80.36 no total. O valor deve ser 
 * impresso com duas casas decimais. 
 * 
 * Entrada:
 * - A entrada contém apenas um valor de ponto flutuante, com duas 
 * casas decimais.
 * 
 * Saída:
 * - Imprima o texto "R$" seguido de um espaço e do valor total 
 * devido de Imposto de Renda, com duas casas após o ponto. Se o 
 * valor de entrada for menor ou igual a 2000, deverá ser impressa 
 * a mensagem "Isento".
 */

let calc = gets();
calc = parseFloat(calc);

if (calc <= 2000) {

  console.log('Isento');

} else if (calc <= 3000) {

  segundaFaixa = (calc - 2000) * 0.08;

  result = parseFloat(segundaFaixa);
  result = result.toFixed(2);

  console.log('R$ ' + result);

} else if (calc <= 4500) {
  
  aux1 = calc - 2000;
  aux2 = calc - 3000;
  aux2 = aux2 >= 0 ? aux2 : 0;
    
  segundaFaixa = ((calc - 2000) - aux2) * 0.08;
  terceiraFaixa = (calc - 3000) * 0.18;
    
  result = parseFloat(segundaFaixa + terceiraFaixa);
  result = result.toFixed(2);
    
  console.log('R$ ' + result);

} else {
  
  aux1 = calc - 2000;
  aux2 = calc - 3000;
  aux3 = calc - 4500;
  aux2 = aux2 >= 0 ? aux2 : 0;
  aux3 = aux3 >= 0 ? aux3 : 0;
    
  segundaFaixa = ((calc - 2000) - aux2) * 0.08;
  terceiraFaixa = ((calc - 3000) - aux3) * 0.18;
  quartaFaixa =  (calc - 4500) * 0.28;
    
  result = parseFloat(segundaFaixa+terceiraFaixa+quartaFaixa);
  result = result.toFixed(2);
   
  console.log('R$ ' + result);

}

<|start_filename|>Desafios/JavaScript/5. Busca e Laços de Repetição/5.4. Pink e Cérebro/solution.js<|end_filename|>
/**
 * Pink e Cérebro
 *
 * Desafio:
 * - Pink e Cérebro dividem um apartamento e estão juntos 
 * 24h por dia desde o começo da pandemia. Para passar o tempo, 
 * Pink cria problemas matemáticos para Cérebro resolver, o 
 * último deles foi uma lista de números com a seguinte pergunta: 
 * quantos números da lista são múltiplos de 2, 3, 4 e 5?
 * 
 * - Apesar de parecer simples, porém, quando a lista contém muitos 
 * números, Cérebro se confunde e acaba errando alguns cálculos.
 * 
 * - Ajude Cérebro a resolver o desadio de Pink.
 * 
 * Entrada:
 * - A primeira linha da entrada consiste em um inteiro N (1 ≤ N ≤1000), 
 * representando a quantidade de números na lista de Pink.
 * 
 * - A segunda linha contém N inteiros Li (1 ≤ Li ≤ 100), representando 
 * os números da lista de Pink.
 * 
 * Saída:
 * - Imprima a quantidade de números múltiplos de 2, 3, 4 e 5 presentes 
 * na lista. Observe a formatação da saída nos exemplos, pois ela deve 
 * ser seguida rigorosamente.
 */

let n = gets();
let lis = gets().split(' ');
let increment = 0;

for (let mlt = 0; mlt <= 3; mlt++) {
    
    lis.forEach(li => {
        
        if(li % (mlt + 2) == 0) {
            
            increment++;
            
        }
    
    })
    
    console.log(`${increment} Multiplo(s) de ${mlt + 2}`)
    increment = 0;

}

<|start_filename|>Desafios/C Sharp/1. Introdução a Programação com C#/2. Distância/solucao.cs<|end_filename|>
/**********************************************************************************************
 * Distância    
 ******************************** Desafio:
 *
 *      Duas motos (X e Y) partem em uma mesma direção. A moto X sai com velocidade 
 * constante de 60 Km/h e a moto Y sai com velocidade constante de 90 Km/h.
 *
 *      Em uma hora (60 minutos) a moto Y consegue se distanciar 30 quilômetros da 
 * moto X, ou seja, consegue se afastar um quilômetro a cada 2 minutos.
 *
 *      O seu desafio é ler a distância (em Km) e calcular quanto tempo leva (em minutos) 
 * para a moto Y tomar essa distância da outra moto.
 *
 ******************************** Entrada:
 *
 *      O arquivo de entrada contém um número inteiro K que representa a quantidade de 
 * quilômetro que que a moto Y deve estar da moto X.
 *
 ******************************** Saída:
 *
 *      Imprima o tempo necessário para a moto Y ficar com a quantidade K de quilômetro 
 * da moto X, seguido da mensagem " minutos".
 *
 **********************************************************************************************/

using System;

class Distancia 
{
    static void Main() 
    {
        int quilometros = Int32.Parse(Console.ReadLine());
        int minutos = quilometros * 2;
        Console.WriteLine(minutos + " minutos");
    }
}


<|start_filename|>Desafios/Kotlin/1. Introdução a programação em Kotlin/3. Quadrado e ao Cubo/solucao.kt<|end_filename|>
fun main(args: Array<String>) 
{
    var r = 0
    
    for (i in 1..readLine()!!.toInt()) {
        println("${i} ${ i * i } ${ i * i * i }") 
        r += 0
    }
}

<|start_filename|>Desafios/JavaScript/5. Busca e Laços de Repetição/5.3. Degustação de Vinho/solucao.js<|end_filename|>
/**
 * Degustação de Vinho
 *
 * Desafio:
 * - Degustação de vinho às escuras é a habilidade de 
 * identificar um vinho usando apenas seus sentidos do 
 * olfato e paladar.
 * 
 * - Durante uma competição de degustação, uma garrafa de 
 * vinho é aberta e dividia em taças para que os cinco 
 * competidores possam provar. Eles podem cheiras, saborear 
 * e avaliar a bebida para conseguir identificar qual o tipo
 * do vinho, sendo: (1) Cabernet; (2) Merlot; (3) Pinot Noir. 
 * No final, as respostas são verificadas para determinar o 
 * número de suposições corretas.
 * 
 * - Dado o qual foi o tipo do vinho e as respostas fornecidas, 
 * determine o número de participantes que receberam a resposta 
 * correta.
 * 
 * Entrada:
 * - A primeira linha contém um inteiro T representando o tipo 
 * de vinho (1 ≤ T ≤ 4). A segunda linha contém cinco inteiros 
 * A, B, C, D e E, que indica a resposta dada por cada competidor 
 * (1 ≤ A, B, C, D, E ≤ 4).
 * 
 * Saída:
 * - A saída contém um inteiro representando o número de concorrentes 
 * que obtiveram a resposta correta.
 */

let wineNumber = gets();
let wineTesters = gets().split(' ');
let correctAnswers = 0;

let correctAnswersList = wineTesters.filter(correctAnswers => correctAnswers.includes(wineNumber));
correctAnswers = correctAnswersList.length;

console.log(correctAnswers);

<|start_filename|>Desafios/JavaScript/5. Busca e Laços de Repetição/5.5. Menor e Posição/solution.js<|end_filename|>
/**
 * Menor e Posição
 *
 * Desafio:
 * - Desenvolva um código que leia um valor E. Este E será o tamanho 
 * de um vetor X[E]. A seguir, leia cada um dos valores de X, encontre 
 * o menor elemento deste vetor e a sua posição dentro do vetor, 
 * mostrando esta informação.
 * 
 * Entrada:
 * - A primeira linha de entrada contem um único inteiro E (1 < E < 1000), 
 * indicando o número de elementos que deverão ser lidos em seguida para o 
 * vetor X[E] de inteiros. A segunda linha contém cada um dos E valores, 
 * separados por um espaço.
 * 
 * Saída:
 * - A primeira linha apresenta a mensagem “Menor valor:” seguida de um 
 * espaço e do menor valor lido na entrada. A segunda linha apresenta a 
 * mensagem “Posicao:” seguido de um espaço e da posição do vetor na qual 
 * se encontra o menor valor lido, lembrando que o vetor inicia na posição 
 * zero.
 */

let qnt = parseInt(gets())
let entrada = gets()
let trimada = entrada.replace(/\s/g,',').trim().split(',');

var min = trimada[0]
var posicao = 0

for (let i = 1; i < qnt; i++) {

    if (parseFloat(min) > parseFloat(trimada[i])) {
    
        min = trimada[i]
        posicao = i
  
    }

}

console.log("Menor valor:", min)
console.log("Posicao:", posicao)

<|start_filename|>Desafios/C Sharp/3. Solução de Problemas Essenciais com C#/2. A Corrida de Tartarugas/solucao.cs<|end_filename|>
/**********************************************************************************************
 *
 * 2/5 - A corrida de Tartarugas  
 *
 ******************************** Desafio:
 *
 *      A corrida de tartarugas é um esporte que cresceu muito nos últimos anos, fazendo com que 
 * vários competidores se dediquem a capturar tartarugas rápidas, e treina-las para faturar 
 * milhões em corridas pelo mundo. Porém a tarefa de capturar tartarugas não é uma tarefa muito 
 * fácil, pois quase todos esses répteis são bem lentos. Cada tartaruga é classificada em um 
 * nível dependendo de sua velocidade:
 *
 * Nível 1: Se a velocidade é menor que 10 cm/h .
 * Nível 2: Se a velocidade é maior ou igual a 10 cm/h e menor que 20 cm/h .
 * Nível 3: Se a velocidade é maior ou igual a 20 cm/h
 *
 *      Sua tarefa é identificar qual o nível de velocidade da tartaruga mais veloz de um grupo.
 *
 ******************************** Entrada:
 *
 *      A entrada consiste de múltiplos casos de teste, e cada um consiste em duas linhas: A 
 * primeira linha contém um inteiro L (1 ≤ L ≤ 500) representando o número de tartarugas do grupo, 
 * e a segunda linha contém L inteiros Vi (1 ≤ Vi ≤ 50) representando as velocidades de cada 
 * tartaruga do grupo.
 *
 ******************************** Saída:
 *
 *      Para cada caso de teste, imprima uma única linha indicando o nível de velocidade da 
 * tartaruga mais veloz do grupo.
 *
 **********************************************************************************************/

using System;

class CorridaDeTartaturgas 
{
      public static void Main() 
      {
        
      int quantidadeEntradas = 3;
      
      while(quantidadeEntradas > 0)
      {
        var numeroQuantidade = Int32.Parse(Console.ReadLine());
        
        if(numeroQuantidade >= 1 && numeroQuantidade <= 500)
        {
          
          string[] tartarugas = Console.ReadLine().Split(" ");
          
          var maiorVelocidade = Int32.Parse(tartarugas[0]);
          
          for(int i = 1; i < numeroQuantidade; i++)
          {
            var tartaruga = Int32.Parse(tartarugas[i]);
            
            if( tartaruga > maiorVelocidade)
            {
              maiorVelocidade = tartaruga;
            }
          }
          
          if(maiorVelocidade < 10)
          {
            Console.WriteLine(1);
          }
          else if(maiorVelocidade >= 10 && maiorVelocidade < 20)
          {
            Console.WriteLine(2);
          }
          else if(maiorVelocidade >= 20)
          {
            Console.WriteLine(3);
          }
          quantidadeEntradas--;
        } 
        else 
        {
          Console.WriteLine("Insira um número entre 1 e 500");
        }
      }
    }
}

<|start_filename|>Desafios/JavaScript/3. Problemas Aritméticos/3.1. Soma Simples/solucao.js<|end_filename|>
/**
 * Soma Simples
 *
 * Desafio:
 * - Leia dois valores inteiros identificados como variáveis A e B. 
 * - Calcule a soma entre elas e chame essa variável de SOMA. 
 * - A seguir escreva o valor desta variável.
 * 
 * Entrada:
 * - O arquivo de entrada contém 2 valores inteiros.
 * 
 * Saída:
 * - Imprima a variável SOMA com todas as letras maiúsculas, 
 * inserindo um espaço em branco antes e depois do símbolo de 
 * igualdade, seguido pelo valor correspondente à soma de A e B.
 */

var A = parseInt(gets());
var B = parseInt(gets());

let soma = (A + B);

console.log("SOMA = " + soma);

<|start_filename|>Desafios/C Sharp/5. Solução de Problemas em C#/1. Consumo Médio do Automóvel/solucao.cs<|end_filename|>
/**
 Desafio
    Você deve calcular o consumo médio de um automóvel onde será informada a 
 distância total percorrida (em Km) e o total de combustível consumido (em litros).

 Entrada
    Você receberá dois valores: um valor inteiro X com a distância total percorrida 
 (em Km), e um valor real Y que representa o total de combustível consumido, com um 
 dígito após o ponto decimal.

 Saída
    Exiba o valor que representa o consumo médio do automóvel (3 casas após a vírgula), 
 incluindo no final a mensagem "km/l".
*/

using System; 

class ConsumoMedioDoAutomovel
{
    static void Main(string[] args) 
    { 
        int distancia;
        double combustivelGasto, consumoMedio;

        distancia = Convert.ToInt32(Console.ReadLine());
        combustivelGasto = Convert.ToDouble(Console.ReadLine());

        consumoMedio = distancia / combustivelGasto; 

        Console.WriteLine("{0:0.000} km/l", consumoMedio);
    }
}

<|start_filename|>Desafios/JavaScript/3. Problemas Aritméticos/3.3. Cálculo da Viagem/solucao.js<|end_filename|>
/**
 * Cálculo da Viagem
 *
 * Desafio:
 * - Rubens quer calcular e mostrar a quantidade de litros de 
 * combustível gastos em uma viagem de carro, sendo que seu carro 
 * faz 12 KM/L. Como ele não sabe fazer um programa que o auxilie 
 * nessa missão, ele te pede ajuda. Para efetuar o cálculo, deve-se 
 * fornecer o tempo gasto em horas na viagem e a velocidade média 
 * durante a mesma em km/h. Assim, você conseguirá passar para Rubens 
 * qual a distância percorrida e, em seguida, calcular quantos litros 
 * serão necessários para a viagem que ele quer fazer. Mostre o valor 
 * com 3 casas decimais após o ponto.
 * 
 * Entrada:
 * - O arquivo de entrada contém dois inteiros. O primeiro é o tempo 
 * gasto na viagem em horas e o segundo é a velocidade média durante 
 * a mesma em km/h.
 * 
 * Saída:
 * - Imprima a quantidade de litros necessária para realizar a viagem, 
 * com três dígitos após o ponto decimal
 */

let line = gets().split(" ");

let H = parseInt(line[0]);
let P = parseInt(line[1]);

let media = (H*P)/12;
let mediaFinal = media.toFixed(3);

console.log(" " + mediaFinal);

<|start_filename|>Desafios/Kotlin/2. Solucionando problemas em Kotlin/2. Área do Círculo/solucao.kt<|end_filename|>
import java.math.BigDecimal
import java.math.RoundingMode
import java.util.*
import kotlin.math.pow

fun main(args: Array<String>) 
{
    val raio = readLine()?.toDouble()
    val pi = 3.14159
  
    raio?.let {
        val area = pi*raio.pow(2)
        val resultado = BigDecimal(area).setScale(4, RoundingMode.HALF_EVEN)
        
        println("A=$resultado")
    }
}

<|start_filename|>Desafios/JavaScript/6. Desenvolvimento de problemas avançados em JavaScript/2. Animal/solucao.js<|end_filename|>
/**
 * 2/3 - Animal
 * 
 * Desafio
 *      Neste problema, você deverá ler 3 palavras que definem o tipo de animal 
 * possível segundo o esquema abaixo, da esquerda para a direita.  Em seguida 
 * conclua qual dos animais seguintes foi escolhido, através das três palavras 
 * fornecidas.
 * 
 * Entrada
 *      A entrada contém 3 palavras, uma em cada linha, necessárias para identificar 
 * o animal segundo a figura acima, com todas as letras minúsculas.
 * 
 * Saída
 *      Imprima o nome do animal correspondente à entrada fornecida.
 */

let x = gets(); 
let y = gets(); 
let z = gets(); 

if ((x == "vertebrado") && (y == "ave")  && (z == "carnivoro")) {
  console.log("aguia\n");
}

if ((x == "vertebrado") && (y == "ave")  && (z == "onivoro")) {
  console.log("pomba\n");
}

if ((x == "vertebrado") && (y == "mamifero")  && (z == "onivoro")) {
  console.log("homem\n");
}

if ((x == "vertebrado") && (y == "mamifero")  && (z == "herbivoro")) {
  console.log("vaca\n");
}

if ((x == "invertebrado") && (y == "inseto")  && (z == "hematofago")) {
  console.log("pulga\n");
}

if ((x ==  "invertebrado") && (y == "inseto")  && (z == "herbivoro")) {
  console.log("lagarta\n");
}

if ((x  == "invertebrado") && (y == "anelideo") && (z == "hematofago")) {
  console.log("sanguessuga\n");
}

if ((x  == "invertebrado") && (y == "anelideo") && (z == "onivoro")) {
  console.log("minhoca\n");
}

<|start_filename|>Desafios/JavaScript/2. Fundamentos Aritméticos/2.5. Consumo Médio do Automóvel/solucao.js<|end_filename|>
/**
 * Consumo Médio do Automóvel
 * 
 * Desafio:
 * - Você deve calcular o consumo médio de um automóvel 
 * onde será informada a distância total percorrida (em Km) 
 * e o total de combustível consumido (em litros).
 * 
 * Entrada:
 * - Você receberá dois valores: um valor inteiro X com a 
 * distância total percorrida (em Km), e um valor real Y 
 * que representa o total de combustível consumido, com um 
 * dígito após o ponto decimal.
 * 
 * Saída:
 * - Exiba o valor que representa o consumo médio do automóvel 
 * (3 casas após a vírgula), incluindo no final a mensagem "km/l".
 */

let X = parseInt(gets());
let Y = parseFloat(gets());

let consumoMedio = parseFloat(X / Y).toFixed(3);

console.log(consumoMedio + " km/l");

<|start_filename|>Desafios/Kotlin/3. Praticando programação em Kotlin/2. Conversão Simples de Base/solucao.kt<|end_filename|>
fun main(args: Array<String>) {
    var s: String
    var n: Int
    val r = "0x"
    
    while (true) {
        val s = readLine()!!
        
        try {
            val value = s.toInt()
            
            if (value == -1) {
                break
            }
        } catch (e: Exception) {}
        
        if (s.contains(r)) {
            hexaToDecimal(s)
        } else {
            decimalToHexa(s)
        }
    }
}

fun decimalToHexa(s: String) {
    val n = s.toInt()
    
    print("0x${Integer.toHexString(n).toUpperCase()}\n")
}

fun hexaToDecimal(s: String) {
    val hex = s.subSequence(2, s.length).toString()
    val n = Integer.parseInt(hex, 16)
    
    print("$n\n")
}

<|start_filename|>Desafios/Kotlin/1. Introdução a programação em Kotlin/2. Números Ímpares/solucao.kt<|end_filename|>
fun main(args: Array<String>) 
{
    for (i in 1.rangeTo(readLine()!!.toInt()).step(2)) println(i)
}

<|start_filename|>Desafios/JavaScript/4. Solução de Problemas Essenciais/4.2. A Corrida de Tartarugas/solucao.js<|end_filename|>
/**
 * A Corrida de Tartarugas
 *
 * Desafio:
 * - A corrida de tartarugas é um esporte que cresceu 
 * muito nos últimos anos, fazendo com que vários competidores 
 * se dediquem a capturar tartarugas rápidas, e treina-las para 
 * faturar milhões em corridas pelo mundo. Porém a tarefa de 
 * capturar tartarugas não é uma tarefa muito fácil, pois quase 
 * todos esses répteis são bem lentos. Cada tartaruga é 
 * classificada em um nível dependendo de sua velocidade:
 * 
 * - Nível 1: Se a velocidade é menor que 10 cm/h .
 * - Nível 2: Se a velocidade é maior ou igual a 10 cm/h e menor 
 * que 20 cm/h .
 * - Nível 3: Se a velocidade é maior ou igual a 20 cm/h .
 * 
 * - Sua tarefa é identificar qual o nível de velocidade da 
 * tartaruga mais veloz de um grupo.
 * 
 * Entrada:
 * - A entrada consiste de múltiplos casos de teste, e cada 
 * um consiste em duas linhas: A primeira linha contém um inteiro 
 * L (1 ≤ L ≤ 500) representando o número de tartarugas do grupo, 
 * e a segunda linha contém L inteiros Vi (1 ≤ Vi ≤ 50) representando 
 * as velocidades de cada tartaruga do grupo.
 * 
 * Saída:
 * - Para cada caso de teste, imprima uma única linha indicando o nível 
 * de velocidade da tartaruga mais veloz do grupo.
 */

for (i = 0; i < 3; i++) {

    let t = gets();
    let v = gets();
    
    let arrayV = v.split(" ");
    
    let maior = 0;
    let nivel = 0;
  
    maior = arrayV.reduce((a, b) => (
      Math.max(a, b)
    )) 
  
    if (maior < 10) {
      
        nivel = 1;
    
    } else if (maior < 20) {
    
        nivel = 2;
    
    } else {
    
        nivel = 3
    }

    console.log(nivel)
  
}

<|start_filename|>Desafios/JavaScript/3. Problemas Aritméticos/3.2. Coxinha de Bueno/solucao.js<|end_filename|>
/**
 * <NAME>
 *
 * Desafio:
 * - Em 2015 um novo record foi alcançado na competição de 
 * Coxinhas de Bueno de Andrada, onde Mônica mandou pra dentro 
 * 43 coxinhas em apenas 10 minutos, passando se antecessor que 
 * conseguiu comer, no mesmo tempo, 38 coxinhas em 2014.
 * 
 * - O restaurante especializado em coxinhas do pequeno distrito 
 * de Bueno de Andrada, interior de São Paulo, organiza essa competição 
 * todos os anos, mas nunca conseguiram entrar para o livro dos recordes, 
 * o Guinness Book. Para isso, o restaurante precisa preencher informações 
 * sobre a competição, como o número de coxinhas consumidas pelos competidores 
 * durante o evento.
 * 
 * - Porém, como jó foi informado, a especialidade deles é coxinha, não matemática, 
 * então será que você pode ajudá-los? Com base no número total de coxinhas consumidas 
 * e o número de participantes na competição, o dono do restaurante precisa que você 
 * desenvolva um programa para saber a quantidade média de coxinha que os participantes 
 * da competição conseguem devorar.
 * 
 * - Ah, lembre que, em troca da sua ajuda, você poderá comer quantas coxinhas conseguir.
 * 
 * Entrada:
 * - A entrada consiste de uma única linha que contém dois inteiros H e P (1 ≤ H, P ≤ 1000) 
 * indicando respectivamente o número total de coxinhas consumidas e o número total de 
 * participantes na competição.
 * 
 * Saída:
 * - Seu programa deve produzir uma única linha com um número racional representando o número 
 * médio de coxinhas consumidas pelos participantes. O resultado deve ser escrito como um número 
 * racional com exatamente dois dígitos após o ponto decimal, arredondado se necessário.
 */

let line = gets().split(" ");

let H = parseInt(line[0]);
let P = parseInt(line[1]);

let media = (H/P).toFixed(2);

console.log(" " + media);

<|start_filename|>Desafios/C Sharp/6. Desafios Aritméticos em C#/4. Tempo de um Evento/solucao.cs<|end_filename|>
/**
 Desafio
    Pedrinho está organizando um evento em sua Universidade. O evento deverá ser no mês de 
 Abril, iniciando e terminando dentro do mês. O problema é que Pedrinho quer calcular o tempo 
 que o evento vai durar, uma vez que ele sabe quando inicia e quando termina o evento.

    Sabendo que o evento pode durar de poucos segundos a vários dias, você deverá ajudar Pedrinho 
 a calcular a duração deste evento.

 Entrada
    Como entrada, na primeira linha vai haver a descrição “Dia”, seguido de um espaço e o dia do 
 mês no qual o evento vai começar. Na linha seguinte, será informado o momento no qual o evento vai 
 iniciar, no formato hh : mm : ss. Na terceira e quarta linha de entrada haverá outra informação no 
 mesmo formato das duas primeiras linhas, indicando o término do evento.

 Saída
    Na saída, deve ser apresentada a duração do evento, no seguinte formato:

 W dia(s)
 X hora(s)
 Y minuto(s)
 Z segundo(s)

    Obs: Considere que o evento do caso de teste para o problema tem duração mínima de 1 minuto.
*/

using System;

class TempoDeUmEvento
{
  static void Main(string[] args)
  {
    int diaInicio, diaTermino, horaMomentoInicio, minutoMomentoInicio, segundoMomentoInicio;
    int horaMomentoTermino, minutoMomentoTermino, segundoMomentoTerminio;

    string[] dadosInicio = Console.ReadLine().Split(" ");
    diaInicio = Convert.ToInt32(dadosInicio[1]);

    string[] dadosMomentoInicio = Console.ReadLine().Split(":");
    horaMomentoInicio = Convert.ToInt32(dadosMomentoInicio[0]);
    minutoMomentoInicio = Convert.ToInt32(dadosMomentoInicio[1]);
    segundoMomentoInicio = Convert.ToInt32(dadosMomentoInicio[2]);

    string[] dadosTermino = Console.ReadLine().Split(" ");
    diaTermino = Convert.ToInt32(dadosTermino[1]);

    string[] dadosMomentoTermino = Console.ReadLine().Split(":");
    horaMomentoTermino = Convert.ToInt32(dadosMomentoTermino[0]);
    minutoMomentoTermino = Convert.ToInt32(dadosMomentoTermino[1]);
    segundoMomentoTerminio = Convert.ToInt32(dadosMomentoTermino[2]);

    int Segundo = (segundoMomentoTerminio - segundoMomentoInicio);
    int Minuto = (minutoMomentoTermino - minutoMomentoInicio);
    int Hora = (horaMomentoTermino - horaMomentoInicio);
    int Dia = (diaTermino - diaInicio);

    if (Segundo < 0)
    {
      Segundo += 60;
      Minuto--;
    }

    if (Minuto < 0)
    {
      Minuto += 60;
      Hora--;
    }

    if (Hora < 0)
    {
      Hora += 24;
      Dia--;
    }

    Console.WriteLine(Dia + " dia(s)");
    Console.WriteLine(Hora + " hora(s)");
    Console.WriteLine(Minuto + " minuto(s)");
    Console.WriteLine(Segundo + " segundo(s)");
  }
}

<|start_filename|>Desafios/Java/1. Ordenação e Filtros em Java/1. Ordenando Números Pares e Ímpares/OrderingEvenNumbers.java<|end_filename|>
/**
 * Ordenando Números Pares e Ímpares
 *
 * Desafio:
 * - Crie um programa onde você receberá valores inteiros 
 * não negativos como entrada.
 * 
 * - Ordene estes valores de acordo com o seguinte critério:
 * 
 * - Primeiro os Pares
 * - Depois os Ímpares
 * 
 * - Você deve exibir os pares em ordem crescente e na sequência 
 * os ímpares em ordem decrescente.
 * 
 * Entrada:
 * - A primeira linha de entrada contém um único inteiro positivo 
 * N (1 < N < 10000) Este é o número de linhas de entrada que vem 
 * logo a seguir. As próximas N linhas terão, cada uma delas, um 
 * valor inteiro não negativo.
 * 
 * Saída:
 * - Exiba todos os valores lidos na entrada segundo a ordem apresentada 
 * acima. Cada número deve ser impresso em uma linha, conforme exemplo de 
 * saída abaixo.
 */

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class OrderingEvenNumbers {

    public static void main(String[] args) throws Exception {
        
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());        
        
        int N = Integer.parseInt(st.nextToken());
                    
        ArrayList<Integer> entrada = new ArrayList<Integer>();
        ArrayList<Integer> pares = new ArrayList<Integer>();
        ArrayList<Integer> impares = new ArrayList<Integer>();

        for (int i = 0; i < N; i++) {
            
            st = new StringTokenizer(br.readLine());
            entrada.add(Integer.parseInt(st.nextToken()));
            
            if (entrada.get(i) % 2 == 0) {
                
                pares.add(entrada.get(i));
            
            } else {
               
                impares.add(entrada.get(i));
            
            }
        
        }
        
        Collections.sort(pares);    
        Collections.sort(impares);        

        Collections.reverse(impares);

        for (int par : pares) {
        
            System.out.println(par);
        
        }
        
        for (int impar : impares) {
            
            System.out.println(impar);
        
        }

    }

}

<|start_filename|>Desafios/C Sharp/6. Desafios Aritméticos em C#/1. Média 1/solucao.cs<|end_filename|>
/**
 Desafio
    Leia 2 valores de ponto flutuante de dupla precisão A e B, 
 que correspondem a 2 notas de um aluno. A seguir, calcule a média 
 do aluno, sabendo que a nota A tem peso 3.5 e a nota B tem peso 7.5 
 (A soma dos pesos portanto é 11). Assuma que cada nota pode ir de 0 
 até 10.0, sempre com uma casa decimal.

 Entrada
    O arquivo de entrada contém 2 valores com uma casa decimal cada um.

 Saída
    Calcule e imprima a variável MEDIA conforme exemplo abaixo, com 5 
 dígitos após o ponto decimal e com um espaço em branco antes e depois 
 da igualdade. Utilize variáveis de dupla precisão (double) e como todos 
 os problemas, não esqueça de imprimir o fim de linha após o resultado, 
 caso contrário, você receberá "Presentation Error".
*/

using System;
    
class Media1
{
    static void Main(string[] args)
    {
        double A;
        double B;
        
        double media;
        
        A = Convert.ToDouble(Console.ReadLine());
        B = Convert.ToDouble(Console.ReadLine());
        
        media = ((A * 3.5) + (B * 7.5)) / 11;
        
        Console.WriteLine("MEDIA = " + media.ToString("F5"));
    }
}

<|start_filename|>Desafios/JavaScript/5. Busca e Laços de Repetição/5.2. Comunicação em Piralândia/solucao.js<|end_filename|>
/**
 * Comunicação em Piralândia
 *
 * Desafio:
 * - Os cientistas brasileiros descobriram um exoplaneta 
 * a 1 bilhão de anos luz da terra. Ele foi carinhosamente 
 * batizado de Piralândia, uma homenagem a cidade de Piracicaba, 
 * onde moram os cientistas. Após algum tempo observando esse 
 * planeta, os cientistas puderam ver que nele haviam habitantes 
 * e, além disso, esses habitantes estavam tentando fazer contato 
 * com os cientistas através de uma comunicação numérica.
 * 
 * - Só que a numeração que encontraram estava invertida e como 
 * muitas delas foram descobertas, os cientistas chamaram você 
 * para conseguir automatizar esse processo. Logo, dado um número 
 * grande, sua tarefa é imprimir esse número invertido.
 * 
 * Entrada:
 * - O arquivo contém apenas uma linha de teste 
 * que é o número encontrado (0 < n < 9999999999).
 * 
 * - Obs.: Perceba que o número lido é muito alto 
 * para armazenar em uma variável do tipo int, logo 
 * você irá precisar utilizar o tipo long, que para 
 * a leitura e impressão em C, você deve utilizar o 
 * %llu.
 * 
 * Saída:
 * - Imprimir o número lido invertido. Não esqueça de 
 * imprimir a quebra de linha (\n) no final, caso 
 * contrário você receberá (Presentation Error).
 */

var numeros = gets().split("");

numeros.reverse();

console.log(numeros.join(""));



<|start_filename|>Desafios/Kotlin/3. Praticando programação em Kotlin/1. O jogo Matemático de Paula/solucao.kt<|end_filename|>
fun main(args: Array<String>) {  
    val N = readLine()!!.toInt()
    
    for (i in 1..N) {
        val range1 = 'A'..'Z'
        val range2 = 'a'..'z'
        
        val line = readLine()!!
        
        for (letter in range1) {
            if (line.contains(letter)) {
                val list = line.split(letter).map { it.toInt() }
                
                val N1 = list[0]
                val N2 = list[1]
                
                if (N1 == N2) {
                    println(N2 * N1)
                } else {
                    println(N2 - N1)
                }
            }
        }
        
        for (letter in range2) {
            if (line.contains(letter)) {
                val list = line.split(letter).map { it.toInt() }
                
                val N1 = list[0]
                val N2 = list[1]

                if (N1 == N2) {
                    println(N2 * N1)
                } else {
                    println(N2 + N1)
                }
            }
        }
    }
}

<|start_filename|>Desafios/C Sharp/8. Praticando Programação em C#/2. Compras no Supermercado/solucao.cs<|end_filename|>
using System;
using System.Collections.Generic;
using System.Linq;

class ComprasNoSupermercado
{
  public static void Main(string[] args)
  {
    int numeroDeTestes = int.Parse(Console.ReadLine());
  
    for (int i = 0; i < numeroDeTestes; i++) {
      List<string> listDeCompras = new List<String>(Console.ReadLine().Split(' '));
      List<string> listaSemDuplicados = listDeCompras.Distinct().ToList();

      listaSemDuplicados.Sort();
  
      foreach (string item in listaSemDuplicados) {
        Console.Write($"{item} ");
      }
      
      Console.WriteLine(" ");
    }
  }
}

<|start_filename|>Desafios/JavaScript/7. Introdução a Programação com JavaScript/3. Folha de Pagamento/solucao.js<|end_filename|>
/**
 * 3/3 - Folha de Pagamento
 * 
 * Desafio
 *      Precisamos saber quanto uma determinada empresa deve pagar para seus 
 * colaboradores, porém temos apenas a quantidade de horas trabalhadas e o valor 
 * hora. Escreva um programa que leia o número de um colaborador, seu número de 
 * horas trabalhadas, o valor que recebe por hora e calcula o salário desse 
 * colaborador. Em seguida, apresente o número e o salário do colaborador, com duas 
 * casas decimais.
 * 
 * Entrada
 *      Você receverá 2 números inteiros e 1 número com duas casas decimais, 
 * representando o número, quantidade de horas trabalhadas e o valor que o 
 * funcionário recebe por hora trabalhada.
 * 
 * Saída
 *      Exiba o número e o salário do colaborador, conforme exemplo abaixo, com um 
 * espaço em branco antes e depois da igualdade. No caso do salário, também deve 
 * haver um espaço em branco após o $.
 */

let valor1 = parseInt(gets());
let valor2 = parseInt(gets());
let valor3 = parseFloat(gets());

let salary = parseFloat(valor2 * valor3).toFixed(2);

console.log("NUMBER = " + valor1);
console.log("SALARY = U$ " + salary);

<|start_filename|>Desafios/Java/1. Ordenação e Filtros em Java/5. Gincana no Acampamento/GymkhanaInTheCamp.java<|end_filename|>
/**
 * Gincana no Acampamento
 *
 * Desafio:
 * - Nas férias de Dezembro, várias escolas se organizam e levam seus 
 * alunos para um acampamento de férias por uma semana. Nestes acampamentos 
 * os alunos são divididos em cabanas coletivos por gênero e idade, sempre 
 * com um adulto que, além de dormir com o grupo no cabana, também são 
 * responsáveis por criar e executar várias atividades, como por exemplo 
 * jogos, excursões, Gincanas Noturnas, etc.
 * 
 * - No primeiro dia foi realizada uma gincana em que a atividade constituia 
 * em agrupar os alunos em um círculo (organizado no sentido anti-horário) do 
 * qual seriam retiradas uma a uma até que sobrasse apenas um aluno, que seria 
 * o vencedor.
 * 
 * - No momento em que entra no círculo, cada aluno recebe uma pequena ficha 
 * que contém um valor de 1 a 500. Depois que o círculo é formado, conta-se, 
 * iniciando no aluno que está ao lado da primeira que entrou no círculo, o 
 * número correspondente à ficha que o primeiro detém. O aluno onde o número 
 * contado cair, deve ser retirado do grupo, e a contagem inicia novamente 
 * segundo a ficha do aluno que acabou de ser eliminado. Para ficar mais 
 * interessante, quando o valor que consta na ficha é par, a contagem é feita 
 * no sentido horário e quando o valor que consta na ficha é ímpar, a contagem 
 * é feita no sentido anti-horário.
 * 
 * - Desenvolva um programa para que no próximo evento o responsável pela brincadeira 
 * saiba previamente qual criança irá ser a vencedora de cada grupo, com base nas 
 * informações fornecidas.
 * 
 * Entrada:
 * - A entrada contém vários casos de teste. A primeira linha de cada caso de teste 
 * contém um inteiro N (1 ≤ N ≤ 100), indicando a quantidade de alunos que farão parte 
 * de cada círculo. Em seguida, as N linhas de cada caso de teste conterão duas informações, 
 * o Nome e o Valor (1 ≤ Valor ≤ 500) que consta na ficha de cada aluno, separados por um 
 * espaço, na ordem de entrada na formação do círculo inicial.
 * 
 * - OBS: O Nome de cada aluno não deverá ultrapassar 30 caracteres e contém apenas letras 
 * maiúsculas e minúsculas, sem acentos, e o caractere “_”. O final da entrada é indicado 
 * pelo número zero.
 * 
 * Saída:
 * - Para cada caso de teste, deve-se apresentar a mensagem Vencedor(a): xxxxxx, com um espaço 
 * após o sinal ":" indicando qual é o aluno do grupo que venceu a brincadeira.
 */

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class GymkhanaInTheCamp {

	public static void main(String[] args) {
        
        Scanner scr = new Scanner(System.in);
		List<String> listaAlunos = new ArrayList<>(); 
		
		int numeroDeAlunos;
		String aluno;
		String valorFicha;
		int valorAtualFicha;
		int indiceAtual;
		int indiceAlunoEliminado;
		
		numeroDeAlunos = Integer.parseInt(scr.next());
		
		while (numeroDeAlunos > 0) {
            
            for (int i = 0; i < numeroDeAlunos; i++) {
				
				aluno = scr.next();
				valorFicha = scr.next();	
				listaAlunos.add(aluno.trim() + " " + valorFicha.trim());
            
            }
			
			indiceAtual = 0;
			indiceAlunoEliminado = 0;
			valorAtualFicha = Integer.parseInt(listaAlunos.get(indiceAtual).split(" ")[1]);
			
			for (int i = 0; i < numeroDeAlunos - 1; i++) {

				if (valorAtualFicha % 2 == 0) {
                    
                    indiceAlunoEliminado = (listaAlunos.size() - (valorAtualFicha % listaAlunos.size()) + indiceAtual) % listaAlunos.size();
					
				} else if (valorAtualFicha % 2 != 0) {
                    
                    indiceAlunoEliminado = (valorAtualFicha % listaAlunos.size() + indiceAtual) % listaAlunos.size();
                
                }
				
			valorAtualFicha = Integer.parseInt(listaAlunos.get(indiceAlunoEliminado).split(" ")[1]);
			listaAlunos.remove(indiceAlunoEliminado);

			indiceAtual = (valorAtualFicha % 2 == 0) ? 
					((indiceAlunoEliminado <= listaAlunos.size() - 1) ? 
							indiceAlunoEliminado : 0):
						((indiceAlunoEliminado == 0) ?
							(listaAlunos.size() - 1):(indiceAlunoEliminado - 1));
				
			}

			System.out.println("Vencedor(a): " + listaAlunos.get(0).split(" ")[0]);
			
			listaAlunos.clear();
			numeroDeAlunos = Integer.parseInt(scr.next());
						
		}
			
		scr.close();
		
	}

}

<|start_filename|>Desafios/JavaScript/4. Solução de Problemas Essenciais/4.1. Quadrado e ao Cubo/solucao.js<|end_filename|>
/**
 * Quadrado e ao Cubo
 *
 * Desafio:
 * - Você terá o desafio de escrever um programa 
 * que leia um valor inteiro N (1 < N < 1000). 
 * Este N é a quantidade de linhas de saída que 
 * serão apresentadas na execução do programa.
 * 
 * Entrada:
 * - O arquivo de entrada contém um número inteiro 
 * positivo N.
 * 
 * Saída:
 * - Imprima a saída conforme o exemplo fornecido.
 */

let N = parseInt(gets());

let a, b;

for (let i = 1; i <= N; i++) {
    
    a = i * i
    b = i * i * i
    
    console.log(i, a, b)

}

<|start_filename|>Desafios/C Sharp/2. Resolvendo Algoritmos/2. Cardápio Aéreo/solucao.cs<|end_filename|>
/**********************************************************************************************
 *
 * 2/7 - <NAME>  
 *
 ******************************** Desafio:
 *
 *      Durante um longo voo é comum que as companhias aéreas ofereçam alguma refeição aos seus 
 * passageiros, e é comum as aeromoças conduzirem carrinhos contendo tais refeições pelos 
 * corredores do avião. Sentado numa fileira, você avista o carrinho chegando até você, a qual 
 * em um piscar de olhos você é questionado imediatamente: “Pizza, salada, ou massa?”.
 *
 *      Mesmo tendo noção das opção, você tem apenas alguns segundos para selecionar, mas sua 
 * relutância imediata vem da dúvida de como pode ser a aparência de sua escolha, pois seu 
 * vizinho ainda não abriu o embrulho…
 *
 *      Então a aeromoça decidiu mudar o procedimento. Primeiro ela vai perguntar a todos os 
 * passageiros o que eles querem, e com base nisso vai checar se o estoque pode satisfazer todo 
 * mundo. Obviamente, ela quer automatizar esse processo e você se prontificou a ajudar.
 *
 *      Então assim, por exemplo, considere que o número de refeições de pizza, salada e massa 
 * disponíveis são respectivamente (80, 20, 40), enquanto o número de passageiros que escolheu 
 * pizza, salada e massa seja respectivamente (45, 23, 48). Neste caso, onze pessoas seguramente 
 * ficaram sem suas respectivas escolhas de refeição, já que três passageiros que queriam salada 
 * e oito que gostariam de massa não poderão ser atendidos.
 *
 *      Dada a quantidade de refeições disponíveis para cada escolha e o número de refeições 
 * pedidas para cada escolha, você poderia ajudar a aeromoça a determinar quantos passageiros 
 * certamente não poderão ser atendidos?
 *
 ******************************** Entrada:
 *
 *      A primeira linha contem três inteiros Ca, Ba e Pa (0 ≤ Ca, Ba, Pa ≤ 100), representando 
 * respectivamente o número de refeições disponiveis de pizza, salada e massa. A segunda linha 
 * contem três inteiros Cr, Br e Pr (0 ≤ Cr, Br, Pr ≤ 100), indicando respectivamente o número de 
 * refeições requisitadas de pizza, salada e massa respectivamente.
 *
 ******************************** Saída:
 *
 *      Imprima uma única linha com um inteiro representando o número total de passageiros que 
 * seguramente não receberão sua escolha de refeição.
 *
 **********************************************************************************************/

using System;

class CardapioAereo 
{  
  public static void Main (string[] args) 
  {
    string[] refeicoesDisponiveis = Console.ReadLine().Split(' ');
      
      int Ca = int.Parse(refeicoesDisponiveis[0]);
      int Ba = int.Parse(refeicoesDisponiveis[1]);
      int Pa = int.Parse(refeicoesDisponiveis[2]);

      string[] refeicoesRequisitadas = Console.ReadLine().Split(' ');
      
      int Cr = int.Parse(refeicoesRequisitadas[0]);
      int Br = int.Parse(refeicoesRequisitadas[1]);
      int Pr = int.Parse(refeicoesRequisitadas[2]);

      int somaTotal = 0;

      int CaCr = Ca - Cr;
      int BaBr = Ba - Br;
      int PaPr = Pa - Pr;


      if (CaCr<0)
        somaTotal = somaTotal + (CaCr * -1);

      if (BaBr<0)
        somaTotal = somaTotal + (BaBr * -1);

      if (PaPr<0)
        somaTotal = somaTotal + (PaPr * -1);

      Console.Write(somaTotal);
  } 
}

<|start_filename|>Desafios/C Sharp/4. Desenvolvendo algoritmos com C#/2. Álbum da Copa/solucao.cs<|end_filename|>
/**
 * Desafio 2/3 - Álbum da Copa
 *      Rubens quer calcular e mostrar a quantidade de litros de combustível gastos 
 * em uma viagem de carro, sendo que seu carro faz 12 KM/L. Como ele não sabe fazer 
 * um programa que o auxilie nessa missão, ele te pede ajuda. Para efetuar o cálculo, 
 * deve-se fornecer o tempo gasto em horas na viagem e a velocidade média durante a 
 * mesma em km/h. Assim, você conseguirá passar para Rubens qual a distância percorrida 
 * e, em seguida, calcular quantos litros serão necessários para a viagem que ele quer 
 * fazer. Mostre o valor com 3 casas decimais após o ponto.
 *
 * Entrada
 *      O arquivo de entrada contém dois inteiros. O primeiro é o tempo gasto na viagem em 
 * horas e o segundo é a velocidade média durante a mesma em km/h.
 *
 * Saída
 *      Imprima a quantidade de litros necessária para realizar a viagem, com três dígitos 
 * após o ponto decimal.
 */

using System;

class Program 
{
    static void Main(string[] args) 
    {
        int numeroDeFigurinhas = int.Parse(Console.ReadLine());
        int numeroDeFigurinhasCompradas = int.Parse(Console.ReadLine());
        int totalDeFigurinhas = 0;

        int[] albumDeFigurinha = new int[numeroDeFigurinhasCompradas];

        for (int i = 0; i < numeroDeFigurinhasCompradas; i++) 
        {
            string entrada = Console.ReadLine();
            
            if (entrada != null) 
            {
                albumDeFigurinha[i] = int.Parse(entrada);
            }
        }

        for (int i = 0; i < numeroDeFigurinhasCompradas; i++) 
        {
            int figurinha = albumDeFigurinha[i];
            int repetida = 0;

            for (int j = 0; j < numeroDeFigurinhasCompradas; j++) 
            {
                if (albumDeFigurinha[j] == figurinha) 
                {
                    repetida++;
                } 
            }

            if (repetida >= 2) 
            {    
                for (int j = 0; j < numeroDeFigurinhasCompradas; j++) {
                    if (figurinha == albumDeFigurinha[j]) { 
                        albumDeFigurinha[j] = -1;
                        break;
                    }
                }
            }
        }

        int figuras = 0;

        for (int i = 0; i < numeroDeFigurinhasCompradas; i++) 
        {    
            if (albumDeFigurinha[i] != -1) 
            {
                figuras++;
            }
        }
        totalDeFigurinhas = numeroDeFigurinhas - figuras;
        Console.Write(totalDeFigurinhas);
    }
}

<|start_filename|>Desafios/Kotlin/2. Solucionando problemas em Kotlin/3. Primo Rápido/solucao.kt<|end_filename|>
import kotlin.math.sqrt

fun main() 
{
    val n = readLine()!!.toInt()
    
    for (i in 0 until n) {
        var x = readLine()!!.toDouble()
        val prime = isPrime(x)
        
        print(prime)
    }
}

fun print(prime: Boolean) 
{
    if (prime) {
        print("Prime\n")
    } else print("Not Prime\n")
}

fun isPrime(num: Double): Boolean 
{
    if (num < 2) return false
    if (num % 2 == 0.0) return num == 2.0
    
    val root = sqrt(num).toInt()
    var i = 3
    
    while (i <= root) {
        if (num % i == 0.0) return false
        i += 2
    }
    
    return true
}

<|start_filename|>Desafios/C Sharp/3. Solução de Problemas Essenciais com C#/4. Validação de Nota/solucao.cs<|end_filename|>
/**********************************************************************************************
 *
 * 4/5 - Validação de Nota  
 *
 ******************************** Desafio:
 *
 *      Para ajudar a calcular as notas referentes às duas avaliações dos alunos, uma professora 
 * pediu para que você desenvolva um programa que calcule e imprima a média semestral. Faça com 
 * que o algoritmo só aceite notas válidas (uma nota válida deve pertencer ao intervalo [0,10]). 
 * Cada nota deve ser validada separadamente.
 *
 ******************************** Entrada:
 *
 *      A entrada contém vários valores reais, positivos ou negativos. O programa deve ser 
 * encerrado quando forem lidas duas notas válidas.
 *
 ******************************** Saída:
 *
 *      Se uma nota inválida  for lida, deve ser impressa a mensagem "nota invalida".
 *      Quando duas notas válidas forem lidas, deve ser impressa a mensagem "media = " seguido do 
 * valor do cálculo. O valor deve ser apresentado com duas casas após o ponto decimal.
 *
 **********************************************************************************************/

using System;

class ValidacaoDeNota 
{  
    public static void Main() 
    {
      
      double somaDasNotas = 0;
      int contador = 0;
      
      do
      {
        double notaEntradaConsole = double.Parse(Console.ReadLine());
        
        if (notaEntradaConsole < 0 || notaEntradaConsole > 10)
        {
          Console.WriteLine("nota invalida");
        } 
        else 
        {
          contador++;
          
          somaDasNotas += notaEntradaConsole; 
        }    
      } 
      while (contador < 2);
      
      Console.WriteLine("media = " + (somaDasNotas / 2).ToString("N2"));
    }
}

<|start_filename|>Desafios/C Sharp/2. Resolvendo Algoritmos/7. Rodízio de Cavalos e Carruagens/solucao.cs<|end_filename|>
/**********************************************************************************************
 *
 * 7/7 - <NAME> e Carruagens  
 *
 ******************************** Desafio:
 *
 *     O rodízio de veículos de Bravoos é uma restrição à circulação de veículos na cidade. 
 * Com o propósito de melhorar as condições ambientais reduzindo a carga de poluentes na 
 * atmosfera,incluindo na região de Westeros, se consolidou como um instrumento para reduzir 
 * congestionamentos nas principais vias da cidade, nos horários de maior movimento. Nas ruas 
 * delimitadoras não é permitido o tráfego de cavalos e carruagens que estejam dentro da 
 * restrição. Há uma escala que determina em quais dias da semana quais veículos não podem 
 * circular. Essa escala é regida pelo último dígito da placa do animal, sendo:
 *
 * Segunda-feira, digito final da placa 1 e 2
 * Terça-feira, digito final da placa 3 e 4
 * Quarta-feira, digito final da placa 5 e 6
 * Quinta-feira, digito final da placa 7 e 8
 * Sexta-feira, digito final da placa 9 e 0
 *
 *      Os motoristas que são flagrados violando a restrição de circulação são autuados com multa 
 * de 4 galinhas e condenados a passar 1 semana na Muralha.
 *
 ******************************** Entrada:
 *
 *      A primeira linha de entrada representa a quantidade de testes N (0 <= N < 1000) que 
 * deverão ser considerados. As demais entradas são cadeia de caracteres com tamanho máximo S 
 * (1 <= S <= 100) que representam cada placa que deverá ser analisada, de tal forma que, cada 
 * placa fique em uma única linha de entrada. O formato esperado para uma placa veicular válida 
 * em Bravoos é "AAA-9999", tal que A é um caracter válido em [A-Z], e 9 um dígito numérico válido 
 * em [0-9].
 *
 ******************************** Saída:
 *
 *      O conjunto de valores válidos como saída são: SEGUNDA, TERCA, QUARTA, QUINTA e SEXTA, de 
 * acordo com a tabela de restrições predefinida, e FALHA caso a placa não apresente o padrão 
 * definido.
 *
 **********************************************************************************************/

using System;
using System.Text.RegularExpressions;

class RodizioDeCavalosECarruagens 
{
  public static void Main (string[] args) 
  {
    var N = int.Parse(Console.ReadLine());

    Regex rgx = new Regex(@"^[A-Z][A-Z][A-Z]-[0-9][0-9][0-9][0-9]$");

    for (var i = 1; i <= N; i++)
    {
      string placa = Console.ReadLine();

      if (rgx.IsMatch(placa) == false)
      {
        Console.WriteLine("FALHA");
      }
      else
      {
        switch (placa[7])
        {
            case '1':
            case '2':
              Console.WriteLine("SEGUNDA");
              break;
            case '3':
            case '4':
                Console.WriteLine("TERCA");
                break;
            case '5':
            case '6':
                Console.WriteLine("QUARTA");
                break;
            case '7':
            case '8':
                Console.WriteLine("QUINTA");
                break;
            case '9':
            case '0':
                Console.WriteLine("SEXTA");
                break;
        }
      }
    }
  }
}

<|start_filename|>Desafios/JavaScript/5. Busca e Laços de Repetição/5.1. O Escolhido/solucao.js<|end_filename|>
/**
 * O Escolhido
 *
 * Desafio:
 * - As aulas do Prof. Xavier estão dando o que falar 
 * até no exterior, pois ele ensina Algorítmos de um 
 * jeito diferente aos seus alunos. Uma universidade 
 * dos EUA, que soube sobre o método do Prof. Xavier, 
 * quer selecionar um aluno para um intercâmbio no país. 
 * Para isso, ele possuem uma lista de inscrição com o 
 * número de cada aluno e sua nota. 
 * 
 * - Para ajudá-los a encontrarem o melhor aluno que 
 * ganhará o intercâmbio, você deve desenvolver um 
 * programa. Só tem um detalhe, se a nota mais alta 
 * não for maior ou igual a 8, você deverá imprimir 
 * “Minimum note not reached”.
 * 
 * Entrada:
 * - O arquivo contém primeiro a quantidade de alunos 
 * (3 <= n <= 100) existentes e em seguida, os n alunos 
 * contendo o número da matrícula (0 < m < 1000000) de 
 * cada um, seguido da respectiva nota 
 * (0 <= nota <= 10.0, com 1 casa decimal).
 * 
 * - Obs.: as notas não serão repetidas. Ou seja, não tem 
 * chance de ter dois alunos com a mesma nota.
 * 
 * Saída:
 * - Você deve imprimir o número do estudante que obteve a 
 * maior pontuação ou "Minimum note not reached" (sem aspas) 
 * caso nenhum estudante tenha tirado uma nota maior ou igual 
 * a 8.
 */

let n = parseInt(gets());

let arrMat = Array(n);
let arrNot = Array(n);

for (i = 0; i < n; i++) {
    
    let line = gets().split(' ');
    
    arrMat[i] = parseInt(line[0]);
    arrNot[i] = parseFloat(line[1]);

}

let maior = 0;

var max = arrNot.reduce(function(a, b) {
    
    return Math.max(a, b);

}); 

for (i = 0; i < n; i++) {
    
    if (max < 8) {
        
        console.log('Minimum note not reached'); 
        break;
    
    } else if (arrNot[i] === max) {
        
        console.log(arrMat[i]);
    
    }

}

<|start_filename|>Desafios/JavaScript/4. Solução de Problemas Essenciais/4.4. Validação da Nota/solucao.js<|end_filename|>
/**
 * Validação da Nota
 *
 * Desafio:
 * - Para ajudar a calcular as notas referentes às 
 * duas avaliações dos alunos, uma professora pediu 
 * para que você desenvolva um programa que calcule 
 * e imprima a média semestral. Faça com que o algoritmo 
 * só aceite notas válidas (uma nota válida deve pertencer 
 * ao intervalo [0,10]). Cada nota deve ser validada 
 * separadamente.
 * 
 * Entrada:
 * - A entrada contém vários valores reais, positivos ou 
 * negativos. O programa deve ser encerrado quando forem 
 * lidas duas notas válidas.
 * 
 * Saída:
 * - Se uma nota inválida  for lida, deve ser impressa a 
 * mensagem "nota invalida".
 *
 * - Quando duas notas válidas forem lidas, deve ser impressa 
 * a mensagem "media = " seguido do valor do cálculo. O valor 
 * deve ser apresentado com duas casas após o ponto decimal.
 */

let qtdeNotasValidas = 0;
let notas = [];
let cont = 0;

while(qtdeNotasValidas < 2) {
    
    cont++;
    const nota = parseFloat(gets());
    
    if (!nota) break;
    
    if (nota >= 0 && nota <= 10) {
        
        notas.push(nota)
        qtdeNotasValidas++;
    
    } else {
        
        console.log('nota invalida')
    
    }
}

const arraySum = arr => arr.reduce((acc, current) => acc + current)
const arrayMedia = arr => arraySum(arr) / arr.length

console.log("media = " + arrayMedia(notas).toFixed(2))

<|start_filename|>Desafios/C Sharp/4. Desenvolvendo algoritmos com C#/1. Cálculo de Viagem/solucao.cs<|end_filename|>
/**
 * Desafio 1/3 - Cálculo de Viagem
 *      Rubens quer calcular e mostrar a quantidade de litros de combustível gastos 
 * em uma viagem de carro, sendo que seu carro faz 12 KM/L. Como ele não sabe fazer 
 * um programa que o auxilie nessa missão, ele te pede ajuda. Para efetuar o cálculo, 
 * deve-se fornecer o tempo gasto em horas na viagem e a velocidade média durante a 
 * mesma em km/h. Assim, você conseguirá passar para Rubens qual a distância percorrida 
 * e, em seguida, calcular quantos litros serão necessários para a viagem que ele quer 
 * fazer. Mostre o valor com 3 casas decimais após o ponto.
 *
 * Entrada
 *      O arquivo de entrada contém dois inteiros. O primeiro é o tempo gasto na viagem em 
 * horas e o segundo é a velocidade média durante a mesma em km/h.
 *
 * Saída
 *      Imprima a quantidade de litros necessária para realizar a viagem, com três dígitos 
 * após o ponto decimal.
 */

using System;
using static System.Math;

class Program 
{
    static void Main(string[] args) 
    {
        string[] km = Console.ReadLine().Split(" ");
        
        int h = Int32.Parse(km[0]);
        int veloc = Int32.Parse(km[1]);

        double x = 12;
        double litro = (h * veloc);
        double total = litro/x;

        Console.WriteLine(total.ToString("N3"));
    }
}

<|start_filename|>Desafios/JavaScript/8.  Solução de Problemas Básicos em JavaScript/3. Tipo de Combustível/solucao.js<|end_filename|>
/**
 Desafio
    Você recebeu desafio para determinar qual dos produtos é o preferêncial dos clientes de 
 um posto de abastecimento de combustível. Para isso você deve escrever um algoritmo para ler 
 o tipo de combustível abastecido (codificado da seguinte forma: 1.Álcool 2.Gasolina 3.Diesel 4.Fim). 
 Caso o usuário informe um código inválido (fora da faixa de 1 a 4) deve ser solicitado um novo código 
 (até que seja válido). O programa será encerrado quando o código informado for o número 4.

 Entrada
    A entrada contém apenas valores inteiros e positivos.

 Saída
    Deve ser escrito a mensagem: "MUITO OBRIGADO" e a quantidade de clientes que abasteceram cada tipo 
 de combustível, conforme exemplo.
*/

let alcohol = 0
let gasoline = 0
let diesel = 0
let x = true

while (x) {
  
  const code = Number(gets())
  
  switch (code) {
    
    case 1:
      alcohol++
      break
      
    case 2:
      gasoline++
      break
      
    case 3:
      diesel++
      break
      
    case 4:
      x = false
      break

  }
}

console.log("MUITO OBRIGADO")
console.log("Alcool: " + alcohol)
console.log("Gasolina: " + gasoline)
console.log("Diesel: " + diesel)


<|start_filename|>Desafios/C Sharp/6. Desafios Aritméticos em C#/5. Comunicação em Piralândia/solucao.cs<|end_filename|>
/**
 Desafio
    Os cientistas brasileiros descobriram um exoplaneta a 1 bilhão de anos luz da terra. 
 Ele foi carinhosamente batizado de Piralândia, uma homenagem a cidade de Piracicaba, onde 
 moram os cientistas. Após algum tempo observando esse planeta, os cientistas puderam ver 
 que nele haviam habitantes e, além disso, esses habitantes estavam tentando fazer contato 
 com os cientistas através de uma comunicação numérica. 

    Só que a numeração que encontraram estava invertida e como muitas delas foram descobertas, 
 os cientistas chamaram você para conseguir automatizar esse processo. Logo, dado um número 
 grande, sua tarefa é imprimir esse número invertido.

 Entrada
    O arquivo contém apenas uma linha de teste que é o número encontrado (0 < n < 9999999999).

    Obs.: Perceba que o número lido é muito alto para armazenar em uma variável do tipo int, 
 logo você irá precisar utilizar o tipo long, que para a leitura e impressão em C, você deve 
 utilizar o %llu.

 Saída
    Imprimir o número lido invertido. Não esqueça de imprimir a quebra de linha (\n) no final, 
 caso contrário você receberá (Presentation Error).
*/

using System; 

class ComunicaoEmPiralandia {
  static void Main(string[] args) { 
    
    string n = Console.ReadLine();
    char[] arr = n.ToCharArray();
    
    Array.Reverse(arr);
    string v = new string(arr);
    
    Console.WriteLine(v);
  }
}