Resoluções da etapa 5

Desafio 1 – O Incrível Plano de Robson

Enunciado
Resolução
// Maluco, na moral.

import java.util.*;

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

		Scanner input = new Scanner(System.in);

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

		// Só pega qualquer entrada N vezes
		for(int i = 0; i < n; i++)
			input.nextLine();

		// Printa A no final
		System.out.println("A");
	}
}

Desafio 2 – Contos Infantis

Enunciado
Resolução
import java.util.Scanner;

class ContosInfantis {
    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 tamanho = sc.nextInt();
            sc.nextLine();
            String texto = sc.nextLine();
            char[][] resposta = new char[tamanho][tamanho];
            int posicao = 0;
            //preenchendo a matriz. Começando do canto superior direito e terminando no canto inferior esquerdo
            for (int coluna = tamanho - 1; coluna >= 0; coluna--) {
                for (int linha = 0; linha < resposta.length; linha++) {
                    resposta[linha][coluna] = texto.charAt(posicao);
                    posicao++;
                }
            }
            //imprimindo a matriz
            for (int linha = 0; linha < resposta.length; linha++) {  
                for (int coluna = 0; coluna < resposta[0].length; coluna++) { 
                    System.out.print(resposta[linha][coluna] + " ");
                }  
                System.out.println(" ");
            }

        }
    }
}

Desafio 3 – Amaterasu e os Vestidos do Clima

Enunciado
Resolução
import java.util.Scanner;

public class amaterasu {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();
        for(int loop = 0; loop < n; loop++){
            String frase = sc.nextLine();
            frase= frase.toLowerCase();
            boolean inicio = true;
            if(frase.contains("sem nuvens")){
                if(!inicio){
                    System.out.print(" - ");
                }
                inicio = false;
                System.out.print("branco");
            }
            if(frase.contains("ensolarado")){
                if(!inicio){
                    System.out.print(" - ");
                }
                inicio = false;
                System.out.print("vermelho");
            }
            if(frase.contains("muitas nuvens")){
                if(!inicio){
                    System.out.print(" - ");
                }
                inicio = false;
                System.out.print("verde");
            }
            if(frase.contains("tempestade")){
                if(!inicio){
                    System.out.print(" - ");
                }
                inicio = false;
                System.out.print("preto");
            }
            if(frase.contains("sol encoberto")){
                if(!inicio){
                    System.out.print(" - ");
                }
                inicio = false;
                System.out.print("amarelo");
            }
            if(frase.contains("chuva")){
                if(!inicio){
                    System.out.print(" - ");
                }
                inicio = false;
                System.out.print("azul");
            }
            if(frase.contains("neblina")){
                if(!inicio){
                    System.out.print(" - ");
                }
                inicio = false;
                System.out.print("cinza");
            }
            if(frase.contains("sol fraco")){
                if(!inicio){
                    System.out.print(" - ");
                }
                inicio = false;
                System.out.print("laranja");
            }
            if(frase.contains("garoa")){
                if(!inicio){
                    System.out.print(" - ");
                }
                inicio = false;
                System.out.print("roxo");
            }
            System.out.println();
        }
        
    }
}

Desafio 4 – Clovis, a Raposa Disfarcada

Enunciado
Resolução
// ATENCAO: Essa nao eh a forma mais eficiente de resolver esse problema.
// Aqui, ela eh resolvida em O(n^3), tem como fazer O(n^2)
// Essa nao eh a forma mais eficiente, mas eh a mais facil, entao eu so fui

import java.util.Scanner;

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

		Scanner input = new Scanner(System.in);

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

		for(int casoAtual = 0; casoAtual < casos; casoAtual++){

			String s = input.nextLine();
			int n = Integer.parseInt(input.nextLine());
			String resp = "";

			// i eh o comeco do pedaco da String e j eh o final
			// Esses fors servem para pegar todas as substrings possiveis
			for(int i = 0; i < s.length(); i++){
				for(int j = i + 1; j <= s.length(); j++){
					String subs = s.substring(i, j);
					// Se repete n vezes ou mais e a substring eh maior que a ex-maior
					// ela se torna a nova maior
					if(repeticoes(s, subs, i) >= n && subs.length() > resp.length())
						resp = subs;
				}
			}

			if(!resp.equals(""))
				System.out.println(resp);

			else
				System.out.println("Raposo, nao pegue");
		}
	}

	public static int repeticoes(String inteira, String comp, int n){

		int rep = 0;

		// Percorre a frase vendo quantas vezes a substring aparece
		for(int i = n; i <= inteira.length() - comp.length(); i++)
			if(inteira.substring(i, i + comp.length()).equals(comp))
				rep++;

		return rep;
	}
}

Desafio 5 – Susanoo e a Serpente dos Mares

Enunciado
Resolução
import java.util.Scanner;

public class Susanoo {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();
        for(int loop = 0; loop < n; loop++){
            boolean err = false;
            char[][] matrix = new char[17][17];
            for(int i = 0; i< 17; i++){
                String linha = sc.nextLine();
                matrix[i] = linha.toCharArray();
            }

            for(int i = 0; i < 8; i++){
                int ncab = 0;
                for(int j = i; j < 17-i; j++){
                    if(matrix[i][j] == 'C'){
                        ncab++;
                    }
                    if(matrix[16-i][j] == 'C'){
                        ncab++;
                    }
                    if(j != i && j != 16-i){

                        if(matrix[j][i] == 'C'){
                            ncab++;
                        }
                        if(matrix[j][16-i] == 'C'){
                            ncab++;
                        }
                    }
                }
                if(ncab != 1){
                    System.out.println("Yas... Susanoo, nessa pedra nao da pra fazer o 1v8, so vai feedar.");
                    err = true;
                    break;
                }
            }
            if(err){
                sc.nextLine();
                continue;
            }else{
                System.out.println("Bora Susanoo, ja vou pedir o bolo de casamento!");
            }
            sc.nextLine();
        }
    }
}

Desafio 6 – Princesa Takiyasha e o Exército de Esqueletos

Enunciado
Resolução
// Maluco respira que o barato eh loco e o processo eh lento
/* Tem alguns passos que nao sao necessarios para a resolucao. Esses passos fizeram a solucao ficar maior.
   Por exemplo, nao eh necessario usar varias classes e interfaces, so usei pois fica mais facil 
   de implementar outros tipos de tropas da Takyiasha, outros movimentos e ate ataques.
   Basicamente, nao precisa fazer assim, mas assim eh divertido e facilita caso outras coisas sejam adicionadas no codigo. */

import java.util.*;

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

		Scanner input = new Scanner(System.in);

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

		for(int casoAtual = 0; casoAtual < casos; casoAtual++){

			char[][] campo = entrada(input);

			Esqueleto[] esqueletos = buscarEsqueletos(campo);

			if(deslocarTropas(campo, esqueletos, 0))
				System.out.println("Muahaha todos os humanos morreram");

			else
				System.out.println("Poutz, princesa foi decapitada");
		}
	}

	// Metodo para pegar a entrada e transformas em matriz
	public static char[][] entrada(Scanner input){

		String[] nums = input.nextLine().split(" ");

		int numLin = Integer.parseInt(nums[0]);
		int numCol = Integer.parseInt(nums[1]);

		char[][] campo = new char[numLin][numCol];

		for(int i = 0; i < numLin; i++){
			String entrada = input.nextLine();

			String[] linha = entrada.split(" ");

			for(int j = 0; j < numCol; j++)
				campo[i][j] = linha[j].charAt(0);
		}

		return campo;
	}

	// Checa se existe um Humano no campo
	public static boolean checarCampo(char[][] m){
		for(char[] a : m)
			for(char c : a)
				if(c == 'H')
					return false;

		return true;
	}

	// Agora o negocio fica loco
	// Esse metodo eh o que vai simular a movimentacao dos esqueletos
	public static boolean deslocarTropas(char[][] campo, Esqueleto[] esqueletos, int n){

		// i eh as quatro direcoes que os esqueletos podem se movimentar
		// Cada iteracao desse loop eh uma direcao
		// Basicamente, esse loop eh exponencial. Se eu tivesse 4 esqueletos em campo
		// Teria que ter 4 loops, um dentro do outro (4 vezes)
		// So que no caso eu nao sei quantos esqueletos terao, entao usei
		// * recursao *
		// Entao a recursao vai servir para fazer esse loop dentro do loop dentro do loop...
		// Dava pra ter feito de outra maneira? Sim, mas recursao eh legal
		for(int i = 0; i < 4; i++){

			Esqueleto e = esqueletos[n];
			e.mudarMovimento(i);

			if(n < esqueletos.length - 1)
				if(deslocarTropas(campo, esqueletos, n + 1))
					return true;

			char[][] m = copiarMatriz(campo);

			for(int j = 0; j < esqueletos.length; j++)
				esqueletos[j].mover(m);

			if(checarCampo(m))
				return true;
		}

		return false;
	}

	// Esse metodo ai percorrer a matriz procurando por esqueletos
	// Fica bem mais simples se usar uma lista
	public static Esqueleto[] buscarEsqueletos(char[][] m){
		
		int quantE = 0;

		for(char[] a : m)
			for(char c : a)
				if(c == 'E')
					quantE++;

		Esqueleto[] esqueletos = new Esqueleto[quantE];

		int pos = 0;
		for(int i = 0; i < m.length; i++){
			for(int j = 0; j < m[0].length; j++){
				if(m[i][j] == 'E'){
					Esqueleto esq = new Esqueleto();

					esq.linha = i;
					esq.coluna = j;

					esqueletos[pos] = esq;
					pos++;
				}
			}
		}

		return esqueletos;
	}

	// Como sabemos que java trabalha com arrays por referencia, se eu quiser alterar uma matriz
	// Sem alterar a original, eu teria que fazer uma copia dela
	public static char[][] copiarMatriz(char[][] m){

		char[][] nova = new char[m.length][m[0].length];

		for(int i = 0; i < m.length; i++)
			for(int j = 0; j < m[0].length; j++)
				nova[i][j] = m[i][j];

		return nova;
	}
}

class Esqueleto {

	public int linha;
	public int coluna;
	public Movimento mov;

	// Se cada movimento eh uma classe que implementa a Inteface Movimento, vai facilar caso queira
	// Implementar novos movimentos (ja que era a ideia original do desafio)
	public void mudarMovimento(int n){
		if(n == 0)
			mov = new EsqueletoEsq();

		if(n == 1)
			mov = new EsqueletoDir();

		if(n == 2)
			mov = new EsqueletoCima();
		
		if(n == 3)
			mov = new EsqueletoBaixo();
	}


	// Esse metodo tem alguns passos desnecessarios para a resolucao do exercicio
	// Porem sao necessarios caso vc queira imprimir a matriz e vizualizar os movimentos
	public void mover(char[][] m){

		int exLin = this.linha;
		int exCol = this.coluna;

		if(mov.fazerMovimento(m, this)){
			m[exLin][exCol] = '.';
			m[this.linha][this.coluna] = 'E';
		}

		this.linha = exLin;
		this.coluna = exCol;
	}
}

// Classes resposaveis por fazer os movimentos. Se eu quisesse adicionar mais movimentos ou tipos de ataques,
// eh so criar mais classes de movimentos
interface Movimento {
	public boolean fazerMovimento(char[][] m, Esqueleto e);
}

class EsqueletoCima implements Movimento {

	public boolean fazerMovimento(char[][] m, Esqueleto e){
		if(e.linha < 2 || m[e.linha - 2][e.coluna] == 'E')
			return false;

		for(int i = 0; i <= 2; i++)
			m[e.linha - i][e.coluna] = '.';

		e.linha = e.linha - 2;
		
		return true;
	}
}

class EsqueletoBaixo implements Movimento {

	public boolean fazerMovimento(char[][] m, Esqueleto e){
		if(e.linha > m.length - 3 || m[e.linha + 2][e.coluna] == 'E')
			return false;

		for(int i = 0; i <= 2; i++)
			m[e.linha + i][e.coluna] = '.';

		e.linha = e.linha + 2;

		return true;
	}
}

class EsqueletoDir implements Movimento {

	public boolean fazerMovimento(char[][] m, Esqueleto e){
		if(e.coluna > m[0].length - 3 || m[e.linha][e.coluna + 2] == 'E')
			return false;

		for(int i = 0; i <= 2; i++)
			m[e.linha][e.coluna + i] = '.';
		
		e.coluna = e.coluna + 2;
		
		return true;
	}
}

class EsqueletoEsq implements Movimento {

	public boolean fazerMovimento(char[][] m, Esqueleto e){
		if(e.coluna < 2 || m[e.linha][e.coluna - 2] == 'E')
			return false;

		for(int i = 0; i <= 2; i++)
			m[e.linha][e.coluna - i] = '.';

		e.coluna = e.coluna - 2;

		return true;
	}
}

// Consideracoes finais: Sim, tem maneiras talvez mais simples de resolver, mas dessa maneira da para vizualizar
// os movimentos e da para incrementar o codigo

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *