Java challenges

Algoz.java

import java.io.IOException;
import java.util.Scanner;

/**
 * Ramsay: "(...) você vence se conseguir adivinhar quem eu sou e por que estou torturando você."

Theon deve pensar rápido e adivinhar quem é seu algoz! Entretanto, Ramsay já decidiu o que ele irá fazer depois que Theon der sua resposta.

Theon pode dizer que seu algoz é alguma dentre N pessoas. Considere que as pessoas são numeradas de 1 a N. Se Theon responder que seu algoz é a pessoa i, Ramsay irá atingi-lo Ti vezes.

Sua tarefa é ajudar Theon a determinar qual deve ser sua resposta de forma a minimizar o número de vezes que ele será atingido.

Entrada
A primeira linha contém um inteiro N (1 ≤ N ≤ 100). A segunda linha contém N inteiros T1, T2, ..., TN (0 ≤ Ti ≤ 20).

Saída
Imprima uma linha contendo o número da pessoa que Theon deve dizer ser seu algoz. Se existe mais de uma resposta possível, imprima a menor.

 
Exemplos de Entrada	Exemplos de Saída
3
8 0 7 saída 2 
2
1 1 saída 1

Escola de Inverno da Maratona - Erechim RS - 2015
 */

public class Algoz {

  public static void main(String[] args) throws IOException {
    Scanner leitor = new Scanner(System.in);
    int N = leitor.nextInt();
    int T, menor = 0, posMenor = 0;
    for (int i = 1; i <= N; i++) {
      T = leitor.nextInt();
      if (i == 1) {
        posMenor = 1;
        menor = T;
      } else if (T < menor) {
        posMenor = i;
        menor = T;
      }
    }
    System.out.println(posMenor);

    leitor.close();
  }
}

Atraso.java

import java.io.IOException;
import java.util.Scanner;

/**
 * Domingo é dia de feira. Logo de manhã muitas pessoas se deslocam para o polo de lazer da Parangaba, onde acontece uma feira, conhecida por ser a maior da cidade. Na feira da Parangaba você pode encontrar de tudo.

Todos os domingos, Bino faz compras na feira. Ele sempre marca com seu amigo Cino de se encontrarem no terminal de ônibus da Parangaba às 8h, para irem juntos comprar na feira. Porém, muitas vezes Bino acorda muito tarde e se atrasa para o encontro com seu amigo.

Sabendo que Bino leva de 30 a 60 minutos para chegar ao terminal. Diga o atraso máximo de Bino.

Entrada
A entrada consiste em múltiplos casos teste. Cada caso de tese contém uma única linha contendo um horário H (5:00 ≤ H ≤ 9:00) que Bino acordou. A entrada termina com final de arquivo (EOF).

Saída
Para cada caso de teste, imprima "Atraso maximo: X" (sem aspas), X indica o atraso maximo (em minutos) de Bino no encontro com Cino.

 
Exemplo de Entrada	Exemplo de Saída
7:10
5:00

Atraso maximo: 10
Atraso maximo: 0

 
Olimpíada Cearense de Informática - 2015
 */
public class Atraso {

  public static void main(String[] args) throws IOException {
    Scanner leitor = new Scanner(System.in);
    while (leitor.hasNext()) {
      String[] relogio = leitor.nextLine().split(":");
      int hora = Integer.parseInt(relogio[0]);
      int min = Integer.parseInt(relogio[1]);
      switch (hora) {
        case (7):
          System.out.println("Atraso maximo: " + min);
          break;
        case (8):
          System.out.println("Atraso maximo: " + (60 + min));
          break;
        case (9):
          System.out.println("Atraso maximo: " + (120 + min));
          break;
        default:
          System.out.println("Atraso maximo: 0");
      }
    }
    leitor.close();
  }
}

CombinaStrings.java

import java.util.Scanner;

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

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

Saída - Combine as duas cadeias de caracteres da entrada como mostrado no exemplo abaixo e exiba a cadeia resultante.

Exemplo de Entrada	
2
aA Bb
aa bb

Exemplo de Saída
aBAb
abab
 */
public class CombinaStrings {

  public static void main(String[] args) {
    Scanner leitor = new Scanner(System.in);
    //int N = leitor.nextInt();
    int N = Integer.parseInt(leitor.nextLine());

    for (int i = 0; i < N; i++) {
      StringBuilder resultado = new StringBuilder();
      String[] palavras = leitor.nextLine().split(" ");
      int maxSize = Math.max(palavras[0].length(), palavras[1].length());

      for (int j = 0; j < maxSize; j++) {
        if (j < palavras[0].length()) {
          resultado.append(palavras[0].charAt(j));
        }
        if (j < palavras[1].length()) {
          resultado.append(palavras[1].charAt(j));
        }
      }
      System.out.println(resultado.toString());
    }
    leitor.close();
  }
}

Desafio.java

import java.io.IOException;
import java.util.Scanner;

/**
 * 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. Considere que o número zero é positivo, mas não pode ser considerado como positivo ou negativo.

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.
 */
public class Desafio {

  public static void main(String[] args) throws IOException {
    Scanner leitor = new Scanner(System.in);
    //declare suas variaveis corretamente

    int[] n = new int[5];
    int pares = 0;
    int impares = 0;
    int positivos = 0;
    int negativos = 0;

    for (int i = 0; i < 5; i++) {
      n[i] = leitor.nextInt();

      if (n[i] != 0) {
        if (n[i] % 2 == 0) pares++; else impares++;
        if (n[i] > 0) positivos++; else negativos++;
      } else pares++;
    }

    //insira suas variaveis corretamente
    System.out.println(pares + " par(es)");
    System.out.println(impares + " impar(es)");
    System.out.println(positivos + " positivo(s)");
    System.out.println(negativos + " negativo(s)");

    leitor.close();
  }
}

Divisao.java

import java.io.IOException;
import java.util.Scanner;

/**
 * Você terá o desafio de escrever um algoritmo que leia 2 números e imprima o resultado da divisão do primeiro pelo segundo. Caso não for possível, mostre a mensagem “divisao impossivel” para os valores em questão.

Entrada
A entrada contém um número inteiro N. Este N será a quantidade de pares de valores inteiros (X e Y) que serão lidos em seguida.

Saída
Para cada caso mostre o resultado da divisão com um dígito após o ponto decimal, ou “divisao impossivel” caso não seja possível efetuar o cálculo.
 */

public class Divisao {

  public static void main(String[] args) throws IOException {
    //complete os espaços com sua solução
    Scanner leitor = new Scanner(System.in);
    int N = leitor.nextInt();
    int X, Y;
    for (int i = 0; i < N; i++) {
      X = leitor.nextInt();
      Y = leitor.nextInt();
      if (Y == 0) System.out.println(
        "divisao impossivel"
      ); else System.out.printf("%.1f%n", (float) X / Y);
    }
    leitor.close();
  }
}

Divisores.java

import java.util.Scanner;

/**
 * Ler um número inteiro N e calcular todos os seus divisores.

Entrada
O arquivo de entrada contém um valor inteiro.

Saída
Escreva todos os divisores positivos de N, um valor por linha.

Exemplo de Entrada	
6
Exemplo de Saída
1
2
3
6
 */

public class Divisores {

  public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    int n;
    n = input.nextInt();

    for (int i = 1; i < n; i++) {
      if (n % i == 0) {
        System.out.println(i);
      }
    }
    System.out.println(n);

    input.close();
  }
}

Duracao.java

import java.util.Scanner;

/**
 * Tento como base a hora inicial e final de um jogo, calcule a duração do dele, sabendo que o mesmo pode começar em um dia e terminar em outro, tendo uma duração mínima de, 60 minutos e máxima de 24 horas.

Entrada
A entrada contém dois valores inteiros representando a hora de início e a hora de fim do jogo.

Saída
Apresente a duração do jogo conforme exemplo abaixo.

Exemplo de Entrada =	Exemplo de Saída
16 2 = O JOGO DUROU 10 HORA(S)
0 0 = O JOGO DUROU 24 HORA(S)
2 16 = O JOGO DUROU 14 HORA(S)
 */

public class Duracao {

  public static void main(String[] args) {
    //complete os espaços em branco com sua solução para o problema

    Scanner scan = new Scanner(System.in);
    int inicio, fim, horas;
    inicio = scan.nextInt();
    fim = scan.nextInt();
    horas = fim - inicio;

    if (horas == 0) {
      System.out.print("O JOGO DUROU 24 HORA(S)\n");
    } else if (horas < 0) {
      System.out.print("O JOGO DUROU " + (24 + horas) + " HORA(S)\n");
    } else {
      System.out.print("O JOGO DUROU " + horas + " HORA(S)\n");
    }
    scan.close();
  }
}

Fatorial.java

import java.util.Scanner;

public class Fatorial {

  public static void main(String[] args) {
    Scanner ent = new Scanner(System.in);
    int n = 1, fat = 1;

    n = ent.nextInt();
    if ((n > 0) || (n < 13)) {
      for (int i = 1; i <= n; i++) {
        fat = fat * i;
      }

      System.out.println(fat);
    }

    ent.close();
  }
}

Fibonacci.java

import java.util.Scanner;

public class Fibonacci {

  static int fib(int n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
  }

  public static void main(String[] args) {
    Scanner ent = new Scanner(System.in);
    int n = 1;

    n = ent.nextInt();
    if ((n > 0) || (n < 51)) {
      float f = fib(n);
      System.out.printf("%.1f%n", f);
    }

    ent.close();
  }
}

Main.java

public class Main {

  public static void main(String[] args) {
    for (int i = 1; i < 40; i++) System.out.print("-");
    System.out.println();

    for (int i = 0; i < 5; i++) {
      for (int j = 1; j < 40; j++) {
        if (j == 1 || j == 39) {
          System.out.print("|");
        } else {
          System.out.print(" ");
        }
      }
      System.out.println();
    }
    for (int i = 1; i < 40; i++) System.out.print("-");
  }
}

Media.java

import java.util.Scanner;

/**
 * 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".

 
Exemplos de Entrada	Exemplos de Saída
5.0
7.1 MEDIA = 6.43182
0.0
7.1	MEDIA = 4.84091
10.0
10.0	MEDIA = 10.00000
 */
public class Media {

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    double A, B, media;

    A = sc.nextDouble();
    B = sc.nextDouble();

    media = (A * 3.5 + B * 7.5) / 11;

    System.out.printf("MEDIA = %.5f", media);
    System.out.println();

    sc.close();
  }
}

Motos.java

import java.io.IOException;
import java.util.Scanner;

/**
 * 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 distancia 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".
 */

public class Motos {

  public static void main(String[] args) throws IOException {
    Scanner leitor = new Scanner(System.in);
    int km = leitor.nextInt();
    int minutos = (km * 2); //insira código no espaço em branco
    System.out.println(minutos + " minutos");
    leitor.close();
  }
}

Multiplicacao.java

import java.util.Scanner;

/**
 * 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.

 
Exemplos de Entrada	Exemplos de Saída
3
9
PROD = 27
 */

public class Multiplicacao {

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    int A, B, PROD;

    A = sc.nextInt();
    B = sc.nextInt();

    PROD = A * B; //implemente o código que representa a multiplicação.

    System.out.println("PROD = " + PROD);

    sc.close();
  }
}

Multiplos.java

import java.io.IOException;
import java.util.Scanner;

/**
 * Leia 2 valores inteiros (A e B). Após, o programa deve mostrar uma mensagem "Sao Multiplos" ou "Nao sao Multiplos", indicando se os valores lidos são múltiplos entre si.

Entrada
A entrada contém valores inteiros.

Saída
A saída deve conter uma das mensagens conforme descrito acima.

 
Exemplo de Entrada - 	Exemplo de Saída
6 24 - Sao Multiplos
6 25 - Nao sao Multiplos
 */
public class Multiplos {

  public static void main(String[] args) throws IOException {
    Scanner leitor = new Scanner(System.in);
    int A = leitor.nextInt();
    int B = leitor.nextInt();

    if (A != 0 && B != 0) {
      if ((A % B == 0) || (B % A == 0)) {
        System.out.println("Sao Multiplos");
      } else {
        System.out.println("Nao sao Multiplos");
      }
    } else {
      System.out.println("Nao sao Multiplos");
    }
    leitor.close();
  }
}

Ninja.java

import java.io.IOException;
import java.util.Scanner;

/**
 * Uma das técnicas mais poderosas usadas pelos ninjas, chamada de Kage Bunshin no Jutsu e conhecida também como "Técnica dos clones de sombra", é capas de produzir uma cópia idêntica da pessoa que utilizar essa técnica.
É como uma espécie de mitose, na qual um ninja vira dois, sem possibilidade de diferenciar qual é o original e qual é a cópia.
E por se tratar de uma cópia fidedigna, essa cópia por si só também é capaz de realizar a técnica de clone de sombra e, portanto, se o original e a cópia o fizeram, isso resultaria em 4 ninjas no total. E assim por diante, numa multiplicidade quase infinita a depender da habilidade do ninja.
Há N ninjas diante de você, mas ao invés de contá-los usando seus reflexos, o que seria muito difícil, você irá usar seus conhecimentos em programação para determinar quantos existem.

Entrada - A entrada contém vários casos de teste. Cada caso contém uma linha com o número N (1 ≤ N ≤ 106). É garantido que o valor de N é tal que é possível obter exatamente N cópias de um ninja utilizando a técnica (incluindo o original).

Saída - Para cada caso de teste, imprima uma linha contendo o número de vezes que a técnica foi utilizada.

 Exemplo de Entrada	
1
2
4
Exemplo de Saída
0
1
2
 */
public class Ninja {

  public static void main(String[] args) throws IOException {
    Scanner sc = new Scanner(System.in);
    while (sc.hasNext()) {
      int N = sc.nextInt();
      System.out.println((int) (Math.log(N) / Math.log(2)));
    }
    sc.close();
  }
}

ParesImpares.java

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

/**
 * 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.

Exemplo de Entrada | Exemplo de Saída
10   
4    | 4
32   | 32
34   | 34
543  | 98
3456 | 654
654  | 3456
567  | 6789
87   | 567
6789 | 543
98   | 87
 */
public class ParesImpares {

  public static void main(String[] args) throws Exception {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());

    int linhas = Integer.parseInt(st.nextToken());

    ArrayList<Integer> inteiros = new ArrayList<Integer>();
    ArrayList<Integer> pares = new ArrayList<Integer>();
    ArrayList<Integer> impares = new ArrayList<Integer>();

    for (int i = 0; i < linhas; i++) {
      st = new StringTokenizer(br.readLine());
      inteiros.add(Integer.parseInt(st.nextToken()));

      if (inteiros.get(i) % 2 == 0) {
        pares.add(inteiros.get(i));
      } else {
        impares.add(inteiros.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);
    }
  }
}

Soma.java

import java.util.Scanner;

/**
 * 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.
 */

public class Soma {

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    int A, B, soma;

    A = sc.nextInt();
    B = sc.nextInt();

    soma = A + B; //insira as variáveis corretamente

    System.out.println("SOMA = " + soma);

    sc.close();
  }
}

SomaImpares.java

import java.util.Scanner;

public class SomaImpares {

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int soma = 0;
    int X = sc.nextInt();
    int Y = sc.nextInt();

    if (X < Y) {
      for (int i = X + 1; i < Y; i++) {
        if (i % 2 != 0) {
          soma += i;
        }
      }
    } else {
      for (int i = Y + 1; i < X; i++) {
        if (i % 2 != 0) {
          soma += i;
        }
      }
    }
    System.out.println(soma);
    sc.close();
  }
}

VerificaN.java

import java.util.Scanner;

/**
 * Paulinho tem em suas mãos um pequeno problema. A professora lhe pediu que ele construísse um programa para verificar, à partir de dois valores inteiros A e B, se B corresponde aos últimos dígitos de A.

Entrada
A entrada consiste de vários casos de teste. A primeira linha de entrada contém um inteiro N que indica a quantidade de casos de teste. Cada caso de teste consiste de dois inteiros A (1 ≤ A < 231 ) e B (1 ≤ B < 231) positivos.

Saída
Para cada caso de entrada imprima uma mensagem indicando se o segundo valor encaixa no primeiro valor, confome exemplo abaixo.

Exemplo de Entrada -	Exemplo de Saída
4
5678690 78690 - encaixa
5434554 543 - nao encaixa
1243 1243 - encaixa
54 654 - nao encaixa
 */
public class VerificaN {

  public static void main(String[] args) throws Exception {
    Scanner scan = new Scanner(System.in);
    int A, B;
    String Sa, Sb;
    int count = scan.nextInt();

    for (int i = 0; i < count; i++) {
      A = scan.nextInt();
      B = scan.nextInt();
      Sa = Integer.toString(A);
      Sb = Integer.toString(B);
      if (Sa.length() >= Sb.length()) {
        if (
          Sa.substring(Sa.length() - Sb.length()).contains(Sb)
        ) System.out.println("encaixa"); else System.out.println("nao encaixa");
      } else System.out.println("nao encaixa");
    }
    scan.close();
  }
}

Xadrez.java

import java.util.Scanner;

/**
 * No tabuleiro de xadrez, a casa na linha 1, coluna 1 (canto superior esquerdo) é sempre branca e as cores das casas se alternam entre branca e preta, formando o formato tão conhecido como xadrez. Dessa forma, como o tabuleiro tradicional tem oito linhas e oito colunas, a casa na linha 8, coluna 8 (canto inferior direito) será também branca. Porém, neste problema, queremos ser capazes de predizer a cor independente do número de linhas e colunas, sendo: L linhas e C colunas. No exemplo da figura, para L = 6 e C = 9, a casa no canto inferior direito será preta, uma simples previsão matemática, não?

Entrada
A primeira linha da entrada contém um inteiro L (1 ≤ L ≤ 1000) indicando o número de linhas do tabuleiro.
A segunda linha da entrada contém um inteiro C (1 ≤ C ≤ 1000) representando o número de colunas.

Saída
Imprima uma linha na saída. A linha deve conter um inteiro, representando a cor da casa no canto inferior direito do tabuleiro, e para identificar, considere o inteiro 1 para a cor branca e 0 para a cor preta.

 
Exemplos de Entrada	Exemplos de Saída
6
9 saída 0
8
8 saída 1
5
91 saída 1
 */

public class Xadrez {

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    int L = sc.nextInt();
    int C = sc.nextInt();
    if ((L + C) % 2 == 0) System.out.println("1"); else System.out.println("0");
    sc.close();
  }
}