Resoluções da etapa 3

import java.util.Scanner;

public class FormulaFinal{
	
	public static int fat(int n){
		int total = 1;

		if(n==0)
			return 1;

		for(int i=1; i<=n; i++){
			total *= i;
		}
		return total;
	}


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

		int n = sc.nextInt();
		sc.nextLine();
		for(int i=0; i<n; i++){
			int total = 1;
			String[] num = sc.nextLine().split(" ");
			int f = 0;
			for(String snum : num){
				f = Integer.parseInt(snum);
				total += fat(f);
			}
			System.out.println(f);
		}

	}
}

import java.util.Scanner;

class Catapulta{
    public static void main(String[] args) {
        Scanner sc1 = new Scanner(System.in);
        int N = sc1.nextInt();
        int g = 10;

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

            int d1 = sc1.nextInt();
            int d2 = sc1.nextInt();
            int vx = sc1.nextInt();
            int vy = sc1.nextInt();

            int t = vy/g;
            int distancia = 2 * t * vx;
            if(distancia >= d1 && distancia <= d2) System.out.println("YEEEET");
            else System.out.println("F on the chat");
        }
    }
}

import java.util.Scanner;

public class Gandalf{
	public static String[] desembaralha(String[] embaralhada){
		int tam = embaralhada.length;
		String[] original = new String[tam];

		for(int i = 0; i<tam/2; i++){
			original[i] = embaralhada[i*2];
			original[tam/2 + i] = embaralhada[i*2 + 1];
		}
		return original;
	}

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

		for(int i=0; i<n; i++){
			String[] embaralhada = sc.nextLine().split(" ");

			String[] original = desembaralha(embaralhada);

			for(String nota : original)
				System.out.print(nota + " ");

			System.out.println();

		}
		
	}

}

import java.util.*;

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

		Scanner input = new Scanner(System.in);

		int n = Integer.parseInt(input.nextLine());

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

			String s = input.nextLine();
			
			// Os numeros estao em formato de String para os casos 012 ficar 210
			String[] nums = input.nextLine().split(" ");
			System.out.println(substituir(s, inverter(nums[0]), inverter(nums[1])));
		}
	}


	// Metodo para inverter a String (os numeros)
	public static String inverter(String n){

		String resp = "";

		// Vai pegando o char do final e colocando no comeco
		for(int i = 0; i < n.length(); i++)
			resp = n.charAt(i) + resp;

		return resp;
	}

	public static String substituir(String s, String n1, String n2){

		// Funcao de String que substitui uma sequencia de char por outra
		s = s.replace("(x)", n2);
		s = s.replace("(y)", n1);

		return s;
	}
}

// Atencao: Nao eh necessario utilizar objetos. So utilizei para ficar mais bacaninha 

import java.util.Scanner;

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

		Scanner input = new Scanner(System.in);

		String registro = input.nextLine();

		// Separando os itens do registro e criando um array de Governante
		String[] infos = registro.split("/n");
		Governante[] govs = new Governante[infos.length];

		// Criando e inserindo objetos do tipo Governante no array de Governante
		for(int i = 0; i < infos.length; i++){
			String[] anos = pegarAnos(infos[i]);
			govs[i] = new Governante(pegarNome(infos[i]), anos[0], anos[1], anos[2], anos[3]);
		}

		// Nessa parte ele recebe os comandos de busca ou encerramento
		while(true){

			String nome = input.nextLine();

			if(nome.equalsIgnoreCase("Fim"))
				System.exit(0);

			Governante encontrado = buscar(govs, nome);

			if(encontrado == null)
				System.out.println("Erro => " + nome + " nao encontrado(a)");
			
			else
				System.out.println(encontrado);
		}
	}

	public static String pegarNome(String s){

		// Acha as posicoes do '<' e '>'
		int ini = s.indexOf('<');
		int fim = s.indexOf('>');

		// Retorna a substring entre '<' e '>'
		return s.substring(ini + 1, fim);
	}

	public static String[] pegarAnos(String s){

		// Posicao no array: 0 = idade / 1 = inicio reinado / 2 = fim reinado / 3 = tempo reinando
		String[] anos = new String[4];

		// Acha a posicao da primeira aparicao do '+'
		int mais = s.indexOf('+');

		// Se o '+' fizer parte do nome, acha a posicao da primeira aparicao do '+' depois do '>'
		if(s.indexOf('<') < mais && mais < s.indexOf('>'))
			mais = s.indexOf('+', s.indexOf('>'));

		// Acha a primeira aparicao do '-' depois da posicao do '+'
		int primeiroTraco = s.indexOf('-', mais);

		// Vai pegando os numeros entre cada traco
		anos[0] = s.substring(mais+1, primeiroTraco);
		anos[1] = s.substring(primeiroTraco+1, primeiroTraco+5);
		anos[2] = s.substring(primeiroTraco+6, primeiroTraco+10);
		anos[3] = "" + (Integer.parseInt(anos[2]) - Integer.parseInt(anos[1]));

		return anos;
	}

	public static Governante buscar(Governante[] govs , String nome){

		// Busca sequencial izi de implementar
		for(Governante g : govs)
			if(g.nome.equalsIgnoreCase(nome))
				return g;

		return null;
	}
}

class Governante {

	String nome;
	String iniReino;
	String fimReino;
	String idade;
	String tempoReinando;

	// Construtor
	public Governante(String nome, String idade, String iniReino, String fimReino, String tempoReinando){

		this.nome = nome;
		this.idade = idade;
		this.iniReino = iniReino;
		this.fimReino = fimReino;
		this.tempoReinando = tempoReinando;
	}

	// Lembre-se que o toString eh chamado quando tento imprimir um objeto.
	// Entao o System.out.println(encontrado); ira imprimir tudo que esse metodo retorna
	public String toString(){

		return "Nome => " + this.nome + ", Tempo de Vida => " + this.idade + " anos, Reinado => " + 
		this.iniReino + "-" + this.fimReino + ", Tempo Reinando => " + this.tempoReinando + " anos";
	}
}

// OBS: Essa nao eh a melhor solucao possivel. Porem, ela eh a que julguei que seria mais facil de entender com somente o conhecimento de IP

/* Para As Portas de Durin se abrirem, a frase falada deve conter mellon, porem tem alguns detalhes para se atentar:

	- Pode conter letras maiusculas e minusculas
	- Mellon pode ter varias variacoes na sua forma de escrita, podendo conter repeticao de letras e espacos. Exemplo:
		. meeeeeeeeeeeeeellllllooooooooooooooooooonnnnnnnnnn
		. mmm m m m m m  e e e e e e eeeeee l l l l llll oooo n n n
	- Porem nao pode faltar letra e nem conter outras letras no meio, isso seria invalido. Exemplo:
		. melon
		. meeeeeeeeeeeeeee l oooooooooon
		. m aaaaa ellon
	- Mellon nao pode estar grudado em outras palavras, ou seja, tem que ter um espaco antes de 'm' e um espaco depois de 'n' se nao forem o primeiro ou o ultimo char
		. marshmellon (Invalido)
		. melloncolia (Invalido)
		. carammmm m eeeellon (Valido)
		. mellonnnnn n nnn nnnnncia (Valido)
	 */

import java.util.Scanner;

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

		Scanner input = new Scanner(System.in);

		int casos = Integer.parseInt(input.nextLine());
		System.out.println(casos + " tentativas");

		for(int casoAtual = 0; casoAtual < casos; casoAtual++){
			
			String frase = input.nextLine();

			if(contemMellon(frase))
				System.out.println("As Portas de Durin se abrem");

			else
				System.out.println("Nada acontece");
		}
	}

	public static boolean contemMellon(String entrada){

		entrada = entrada.toLowerCase();
		char[] s = entrada.toCharArray();

		// Coloquei mellon num array de char, assim o programa funcionara
		// para qualquer palavra (teoricamente)
		char[] palavra = {'m', 'e', 'l', 'l', 'o', 'n'};

		// taIndo eh para verificacao
		// p eh para navegacao
		boolean taIndo = false;
		int p = 1;

		char anterior = ' ';
		char atual = palavra[0];
		char prox = palavra[1];

		for(int i = 0; i < s.length; i++){

			// Se o char na posicao i eh a primeira letra e antes tem um espaco
			// Comeca a analisar a palavra em si com o "taIndo"
			if(s[i] == palavra[0] && anterior == ' ')
				taIndo = true;

			// Se entramos no estado taIndo, esse else if checa se pode mudar de letra para verificar,
			// se chegou no final ou se teve uma interrupcao
			else if(taIndo){

				// Se o char na posicao i nao for a letra atual, nem a proxima letra e nem o espaco, reseta tudo
				if(s[i] != atual && s[i] != prox && s[i] != ' '){
					taIndo = false;
					atual = palavra[0];
					prox = palavra[1];
					p = 1;
					continue;
				}

				// Se chegarmos na ultima letra da palavra analisada e o essa letra ja eh o final da frase ou tem um espaco depois dessa letra
				// Retorna true, indicando que lemos toda a seuqeuncia de variacoes da palavra analisada
				if((anterior == palavra[palavra.length-1] && s[i] == ' ') || (i == (s.length - 1) && s[i] == palavra[palavra.length-1]))
					return true;

				// Se o char na posicao i for a proxima letra da palavra analisada ('e' eh a proxima letra de 'm')
				// Mude a letra atual (atual se torna a proxima) e a proxima da proxima se torna a proxima (gracas ao p)
				if(s[i] == prox){
					p++;
					if(p < palavra.length){
						atual = prox;
						prox = palavra[p];
					}
				}
			}

			// Atualiza o char anterior lido
			anterior = s[i];
		}

		return false;
	}
}