Resoluções da Etapa 2

int main()
{
    //Define as constantes
    double G = 6*(pow(10, -7));
    double minhaM = 100000.0;
    double maxim = 1.5*(pow(10.0,10.0));
    int n;
    cin >> n; //Recebe o numero de casos
    for(int i = 0; i < n; i++) //Para cada caso de teste 
    {
        double massa, raio;
        string nome; //Recebe o nome do planeta
        cin >> nome;
        double m;
        string lixo;
        cin >> massa >> lixo >> lixo >> lixo >> m; //Recebe a massa e a potencia
        massa = massa*(pow(10, m));
        cin >> raio; //Recebe o raio
        raio = raio*1000;
        float g = (G*massa)/(raio*raio);
        float p = minhaM*g;
        cout << "Planeta: " << nome << "." << endl; //Printa o nome
        //Printa as resoluções
        if(p < maxim)
        {
            cout << "Eh seguro aterrissar neste planeta, pois sua estrutura aguentaria" << endl;
        }
        else
        {
            cout << "Nao eh seguro aterrissar neste planeta, pois sua estrutura cederia" << endl;
        }
    }
}

import java.util.*;
class queijo {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    
    int n = sc.nextInt();
    sc.nextLine();
    
    while(n > 0) {
      n--;
      
      String queijosStr = sc.nextLine();
      String[] queijosStrSep = queijosStr.split(" ");
      
      int pesoMax = 200;
      
      //Ordem: RBGC
      int[] pedacos = {10, 5, 3, 1};
      int[] queijos = new int[4];
      
      for(int i = 0; i < 4; i++) {
        queijos[i] = Integer.parseInt(queijosStrSep[i]);
      }
      
      //A entrada está numa ordem diferente da ordem dos pedacos, então vamos arrumar de BRCG para RBGC
      int[] queijosOrd = {queijos[1], queijos[0], queijos[3], queijos[2]};
      
      int[] quantPedacos = new int[4];
      
      int soma = 0;
      for(int i = 0; i < pedacos.length; i++) {
        int iterador = 0;
        while(soma + pedacos[i] <= 200 && iterador + 1 <= queijosOrd[i]) {
          soma += pedacos[i];
          iterador++;
        }
        quantPedacos[i] = iterador;
      }
      
      System.out.println("B: " + quantPedacos[1] +
                        ", R: " + quantPedacos[0] +
                        ", C: " + quantPedacos[3] +
                        ", G: " + quantPedacos[2]);
      
      boolean pegouTodos = true;
      for(int i = 0; i < queijosOrd.length; i++) {
        if(queijosOrd[i] != quantPedacos[i]) {
          pegouTodos = false;
        }
      }
      
      if(pegouTodos) {
        System.out.println("Todos os pedacos foram pegos");
      } else {
        System.out.println("Nao foi possivel pegar todos os pedacos");
      }
      
    }
    
  }
}

#include "javalib.hpp"

const std::string morse[] = {".-", "-...", "-.-.", "-..", ".", "..-.", "-.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."};

int main()
{
	int n = jl::nextInt();
	jl::nextLine();
	for(; n > 0; n--)
	{
		std::string line = jl::nextLine();

		bool space = false;

		for(char ch : line)
		{
			int ch_int = ch - 'A';

			if(ch_int < 0 || ch_int >= 26)
			{
				if(ch == ' ')
					std::cout << '/' << std::flush;
				else
					std::cout << ' ' << std::flush;
				space = false;
			}
			else
			{
				if(space == true)
					std::cout << ' ' << std::flush;
				std::cout << morse[ch_int] << std::flush;
				space = true;
			}
		}

		std::cout << std::endl;
	}
}

import java.util.Scanner;
public class ComidasEspaciais {
    
    public static void main (String[] args){
    
        //Scanner
        Scanner sc = new Scanner(System.in);
        
        //Valores de custo e benefício
        float custo;
        float beneficio;
        
        //Nome do produto
        String nome;
        
        //Vetor contendo os custos benefício
        float[] custoBeneficio;
		
        //Valor da resposta
        float resp;
        
        //Contadores de casos de teste e entradas
        int n = sc.nextInt();
        sc.nextLine();
        int m;
        
        //Loop de execução
        for (int i = 0; i < n; i++){
            
            //Leitura da entrada parte A
            nome = sc.next();
            m = sc.nextInt();
            sc.nextLine();
            
            //Preparação do vetor
            custoBeneficio = new float[m];
            
            //Loop interno de execução
            for (int j = 0; j < m; j++){
                
                //Leitura da entrada parte B
				beneficio = sc.nextFloat();
                custo = sc.nextFloat();
				sc.nextLine();
                
                //Cálculo do custo benefício
                custoBeneficio[j] = CalcularCustoBeneficio(beneficio, custo);
                
            }
            
            //Definição do melhor cuto benefício
            resp = AcharMelhorCustoBeneficio(custoBeneficio);
            
            //Saída
            System.out.println(nome + ": " + (int)Math.ceil(resp));
            
        }
        
    }
    
    //Função para calcular o custo benefício da opção
    public static float CalcularCustoBeneficio(float beneficio, float custo){
        return beneficio/custo;
    }
    
    //Função para encontrar o valor do melhor custo benefício
    public static float AcharMelhorCustoBeneficio(float[] custoBeneficio){
        float melhor = custoBeneficio[0];
        for (int i = 0; i < custoBeneficio.length; i++){
            if(custoBeneficio[i] >= melhor){
                melhor = custoBeneficio[i];
            }
        }
        return melhor;
    }
    
}