import java.util.Random;
import java.util.Scanner;

public class Simulado2 {

    public static void questao1() {
        Scanner scanner = new Scanner(System.in);

        int s = scanner.nextInt();
        int n = scanner.nextInt();
        int m = scanner.nextInt();

        int[][] matriz = new int[n][m];
        //Lê a matriz
        for (int i = 0; i < n; i++) {
            for  (int j = 0; j < m; j++) {
                matriz[i][j] = scanner.nextInt();
            }
        }
        //Compara a soma elementos à esquerda e acima para cada um dos elementos
        // da matriz.
        for (int i = 0; i < n; i++) {
            for  (int j = 0; j < m; j++) {
                /* O fato de ambos os ifs verificarem se i,j >0 para fazerem algo
                 * nos faz pensar que os laços poderiam começar de 1 e não de 0.
                 * Mas isso não funcionaria. Por que?
                 */
                if (i > 0 && matriz[i - 1][j] + matriz[i][j] == s) {
                    System.out.printf("(%d,%d)-(%d,%d) ", i - 1, j, i, j);
                }
                if (j > 0 && matriz[i][j-1] + matriz[i][j] == s) {
                    System.out.printf("(%d,%d)-(%d,%d) ", i, j - 1, i, j);
                }
            }
        }
        System.out.println();
    }

    public static int[] entremeia (int[] v1, int[] v2) {
        // Entremeia (mais comumente conhecido como intercala) dois vetores
        // ordenados.

        // Vetor que contém o resultado a ser devolvido
        int[] v3 = new int[v1.length + v2.length];
        // Índices do próximo elemento de v1, e v2
        int p_v1 = 0;
        int p_v2 = 0;
        int p_v3 = 0;

        while (p_v1 < v1.length && p_v2 < v2.length) {
            v3[p_v3++] = v1[p_v1] < v2[p_v2] ? v1[p_v1++] : v2[p_v2++];
        }

        // Copia os elementos remanescentes. Note que apenas um dos vetores terá
        // elementos sobrando. Pq?
        while (p_v1 < v1.length) {
            v3[p_v3++] = v1[p_v1++];
        }
        while (p_v2 < v2.length) {
            v3[p_v3++] = v2[p_v2++];
        }

        return v3;
    }

    public static void questao2() {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        int[] v1 = new int[n];
        //Lê o 1 vetor
        for (int i = 0; i < n; i++) {
            v1[i] = scanner.nextInt();
        }

        int m = scanner.nextInt();
        int[] v2 = new int[m];
        //Lê o 2 vetor
        for (int i = 0; i < m; i++) {
            v2[i] = scanner.nextInt();
        }

        int[] v3 = entremeia(v1, v2);
        for (int i = 0; i < v3.length; i++) {
            System.out.print(v3[i] +  " ");
        }
        System.out.println();
    }

    public static void questao3() {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        int[] v = new int[n];
        //Lê o vetor
        for (int i = 0; i < n; i++) {
            v[i] = scanner.nextInt();
        }

        //Ordena os elementos do vetor. Este algoritmo é chamado de BubbleSort
        for (int i = 0; i < n - 1; i++) { //Efetua as n - 1 varreduras
            /* A cada varredura precisamos varrer um elemento a menos. Para isso
             * aproveitamos o contador do laço externo (i) que já está efetuando
             * a contagem
             */
            for (int j = 1; j < n - i; j++) {
                if (v[j - 1] > v[j]) { //Caso a ordem esteja invertida, troca
                    int tmp = v[j - 1];
                    v[j - 1] = v[j];
                    v[j] = tmp;
                }
            }
        }

        //imprime o elementos do vetor já ordenado
        for (int i = 0; i < n; i++) {
            System.out.print(v[i] +  " ");
        }
        System.out.println();

    }

    public static void questao4() {
        Random rand = new Random();
        int nJogadas = 15;
        //Armazena a quantidade de números não repetidos já sorteados
        int qtd = 0;
        //Armazena os números já sorteados, sem repetições
        int[] sorteados = new int[nJogadas];

        while (qtd < nJogadas) {
            // Sorteia um número no intervalo desejado.
            // Usar nextInt(26) diretamente (sem o +1) não funciona. Pq?
            int candidato = rand.nextInt(25) + 1;
            //verifica se é um número repetido
            boolean repetido = false;
            for (int i = 0; i < qtd && !repetido; i++) {
                repetido = sorteados[i] == candidato;
            }
            if (!repetido) {
                sorteados[qtd++] = candidato;
            }
        }

        //Imprime os números sorteados
        for (int i = 0; i < nJogadas; i++) {
            System.out.print(sorteados[i] +  " ");
        }
        System.out.println();

    }


}