Java Lançamento de Projetil em Java

[Juliana Samstag]

Olá me chamo Juliana e preciso de ajuda!

 

 obter o alcance horizontal,

 

alcanceHorizontal = 2 × velocidadeInicial2 × cos(ângulo) × sen(ângulo) / aceleração

 

o tempo do trajeto

 

tempoTrajeto = 2 × velocidadeInicial × sen(angulo) / aceleracao

 

e a altura máxima atingida pela bala.

 

alturaMaxima = velocidadeInicial2 × sen(angulo) 2 / 2 × aceleracao

 

Não sei onde to errando

 

CODE<

Scanner in = new Scanner(System.in);
        
        // Variáveis
       
         double
               x = 9.81;//aceleração considerar 9,81 m/s igual valor da gravidade 9,81 m/s
               
         int
         vou = 12;
               ang = 25;
               tempo_Trajeto = 0;
        
        Math.pow(vou, 2);
        Math.sin(25);
        Math.cos(25);
        y_rad = Math.toRadians(25);
        
        
                
        //Entrada de Dados
                   
        System.out.println("Altura máxima = " + (Math.pow(vou,2)) * (Math.sin(Math.toRadians(y_rad))) / 2 * x);
        System.out.println("Tempo = " + 2 *  vou *(Math.sin(Math.toRadians(ang))) /  x);
        System.out.println("Alcance horizontal = " + 2 * (Math.pow(vou,2)) *(Math.cos(Math.toRadians(ang)) * (Math.cos(Math.toRadians(ang))/ x)));
    }
 

>

 

 

 Deve-se solicitar ao usuário, após os cálculos,

 

a distância em que se encontra o alvo e o tamanho do alvo. O alvo sempre está no chão e não tem nenhuma altura.

 

O programa deverá informar se o alvo foi atingido, ou se a bala caiu antes ou se caiu depois do alvo.

 

Deve-se imprimir também a altura máxima atingida pela bala, o tempo do trajeto e o alcance horinzontal da bala.

 

regras

a velocidade inicial deve ser positiva. Caso seja digitado um valor negativo ou zero, o programa deverá solicitar um novo valor.

 

 A aceleração do projétil é igual a aceleração da gravidade. Utilizar a constante 9,81m/s2

 

O ângulo do canhão deverá ser maior que zero e menor do que 90 graus. Caso seja digitado um valor fora desse intervalo, o programa deverá solicitar um novo valor. O ângulo deverá ser digitado em graus. Fazer a conversão para radianos (Math.toRadians()) para utilizar os métodos que calculam seno (Math.sin()) e cosseno (Math.cos()). 

 

A distância deverá ser maior do que zero. Caso seja digitado um valor menor ou igual a zero, o programa deve solicitar um novo valor.

 

.O alvo não pode ter tamanho menor que 20 e maior do que 50.

 

O programa deve validar essa entrada também e somente prosseguir a execução, se for um valor válido 

 

. Para qualquer uma das regras listadas, o programa não pode ser finalizado. O programa deve fazer as validações de entrada e somente prosseguir quando os dados de entrada forem válidos

[AdrianoSiqueira]

Não entendi direito o que esse programa deve fazer, mas baseado no seu código, acho que você precisa de algo assim:

public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        final double aceleracao = 9.81;     // Constante
        double velocidadeInicial;
        double angulo;
        
        // 2 * velocidadeInicial * cos(angulo) * sen(angulo) / aceleracao
        double alcanceHorizontal;

        // 2 * velocidadeInicial * sen(angulo) / aceleracao
        double tempoTrajeto;

        // velocidadeInicial * sen(angulo) / (2 * aceleracao)
        double alturaMaxima;
        
        // ----- Entrada de dados
        do {
            System.out.print("Velocidade inicial: ");
            velocidadeInicial = scanner.nextDouble();
            scanner.nextLine();
        } while (velocidadeInicial < 0);

        do {
            System.out.print("Ângulo [ 1 - 89 ]: ");
            angulo = scanner.nextDouble();
            scanner.nextLine();
        } while (angulo <= 0 || angulo >= 90);
        // ----- Entrada de dados

        // Converte graus para radianos
        angulo = Math.toRadians(angulo);
        
        // ----- Realiza os cálculos
        alcanceHorizontal = 2 * velocidadeInicial * Math.cos(angulo) * Math.sin(angulo) / aceleracao;
        tempoTrajeto = 2 * velocidadeInicial * Math.sin(angulo) / aceleracao;
        alturaMaxima = velocidadeInicial * Math.sin(angulo) / (2 * aceleracao);
        // ----- Realiza os cálculos
        
        // ----- Relatório
        System.out.println("alcanceHorizontal = " + alcanceHorizontal);
        System.out.println("tempoTrajeto = " + tempoTrajeto);
        System.out.println("alturaMaxima = " + alturaMaxima);
        // ----- Relatório
    }

 

adicionado 5 minutos depois

Dica: Procure sempre dar nomes mais significativos para suas variáveis, isso ajuda muito no entendimento do código. Além disso dê um pouquinho mais de atenção à indentação do código, um código bem organizado, além de bonito, ajuda a se localizar e a localizar erros que no meio da bagunça passam despercebidos .

[AdrianoSiqueira]

@Juliana Samstag Confirma uma coisa.

 

1 hora atrás, Juliana Samstag disse:

alturaMaxima = velocidadeInicial2 × sen(angulo) 2 / 2 × aceleracao

 

Essa fórmula tem um '2' sobrando antes da divisão. Foi um erro de digitação?

Ou ele representa uma potência assim?:

Citação

alturaMaxima = velocidadeInicial2 × (sen(angulo) ^ 2) / 2 × aceleracao

 

[Juliana Samstag]

@AdrianoSiqueira

Oi Adriano, tudo bem?

 

É isso mesmo alturaMaxima = velocidadeInicial2 × (sen(angulo) ^ 2) / 2 × aceleracao

 

foi dada essa equação

 

Obrigada pelas dicas, estou no 1 semestre e meio perdida. Achei bacana essa questão de organizar os códigos, vou fazer mais exercicios nesse formato para fazer certinho

adicionado 0 minutos depois

@AdrianoSiqueira

Oi Adriano, tudo bem?

 

É isso mesmo alturaMaxima = velocidadeInicial2 × (sen(angulo) ^ 2) / 2 × aceleracao

 

foi dada essa equação

 

Obrigada pelas dicas, estou no 1 semestre e meio perdida. Achei bacana essa questão de organizar os códigos, vou fazer mais exercicios nesse formato para fazer certinho

[AdrianoSiqueira]

Agora que eu li o enunciado com calma. Se for o que eu entendi, você está fazendo um jogo tipo Conquer Antarctica?

[Juliana Samstag]

@AdrianoSiqueira  sim, é um lançamento de canhão.

 

Eu inclui umas regras que o professor solicitou a partir do seu raciocínio como diâmetro do alvo e a função Math.pow porque na fórmula de altura máxima, a velocidade inicial e o seno é elevado à potência

http://phet.colorado.edu/sims/html/projectile-motion/latest/projectile-motion_en.html

 

public static void main(String[] args) {CODE<>
            Scanner scanner = new Scanner(System.in);
        
        final double aceleracao = 9.81;     // Aceleração = Gravidade 9,81m/s² 
        double velocidadeInicial;
        double angulo;
        double alvo;
        
        // 2 * velocidadeInicial² * cos(angulo) * sen(angulo) / aceleracao
        double alcanceHorizontal;

        // 2 * velocidadeInicial * sen(angulo) / aceleracao
        double tempoTrajeto;

        // velocidadeInicial² * sen(angulo)² / (2 * aceleracao)
        double alturaMaxima;
        
        // ENTRADA DE DADOS
        do {
            System.out.print("Velocidade inicial: ");
            velocidadeInicial = scanner.nextDouble();
            scanner.nextLine();
        } while (velocidadeInicial < 0);

        do {
            System.out.print("Ângulo [ 1 - 89 ] Graus: ");
            angulo = scanner.nextDouble();
            scanner.nextLine();
        } while (angulo <= 0 || angulo >= 90);
        
        do {
            System.out.print("Alvo(metros): ");
           alvo = scanner.nextDouble();
            scanner.nextLine();
        } while (alvo <20 || alvo >50);
                      
                        
        // ENTRADA DE DADOS

        // Converte graus para radianos
        angulo = Math.toRadians(angulo);
        
        // PROCESSAMENTO
        alcanceHorizontal = 2 * (Math.pow(velocidadeInicial,2)) * Math.cos(angulo) * Math.sin(angulo) / aceleracao;
        tempoTrajeto =  velocidadeInicial * Math.sin(angulo) / aceleracao;
        alturaMaxima = (Math.pow(velocidadeInicial,2)) * (Math.pow(Math.sin(angulo),2)) / (2 * aceleracao);
       

}

}

CODE<>
        

 

[AdrianoSiqueira]

Bem, já que você resolveu, vou só deixar uma versão alternativa para a posteridade:

import java.util.Scanner;

public class Program {

    /**
     * Constante que representa a aceleração da gravidade
     */
    private static final double ACELERACAO = 9.81;

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

        // Dados do alvo
        double tamanho;     // 20 <= tamanho < 50
        double distancia;

        // Configuração do canhao
        double velocidade;
        double angulo;      // 0 < angulo < 90

        // Dados de resultado;
        double alcance;
        double alturaMaxima;
        double tempo;
        Status resultado;


        // ----- Entrada de dados
        do {
            System.out.print("Tamanho do alvo [ 20 - 49 ]: ");
            tamanho = scanner.nextDouble();
            scanner.nextLine();
        } while (tamanho < 20 || tamanho >= 50);

        System.out.print("Distância do alvo: ");
        distancia = scanner.nextDouble();
        scanner.nextLine();
        distancia = Math.abs(distancia);    // Garante que seja positiva

        System.out.print("Velocidade do projétil: ");
        velocidade = scanner.nextDouble();
        scanner.nextLine();
        velocidade = Math.abs(velocidade);  // Garante que seja positiva

        do {
            System.out.print("Ângulo do canhão [ 1 - 89 ]: ");
            angulo = scanner.nextDouble();
            scanner.nextLine();
        } while (angulo <= 0 || angulo >= 90);

        // Converte graus para radianos
        angulo = Math.toRadians(angulo);
        // ----- Entrada de dados

        // ----- Cálculos
        alcance = calcularAlcance(velocidade, angulo);
        alturaMaxima = calcularAlturaMaxima(velocidade, angulo);
        tempo = calcularTempo(velocidade, angulo);
        resultado = calcularResultado(alcance, distancia, tamanho);
        // ----- Cálculos

        // ----- Relatório
        System.out.println("-----------------------------------------");
        System.out.println("Alvo:");
        System.out.println("  tamanho = " + tamanho);
        System.out.println("distancia = " + distancia);
        System.out.println("-----------------------------------------");
        System.out.println("Canhão:");
        System.out.println("  velocidade = " + velocidade);
        System.out.println("angulo (gra) = " + Math.toDegrees(angulo));
        System.out.println("angulo (rad) = " + angulo);
        System.out.println("-----------------------------------------");
        System.out.println("Resultado:");
        System.out.println("     alcance = " + alcance);
        System.out.println("alturaMaxima = " + alturaMaxima);
        System.out.println("       tempo = " + tempo);
        System.out.println("   resultado = " + resultado);
        System.out.println("-----------------------------------------");
        // ----- Relatório
    }

    /**
     * Calcula o alcance horizontal que o proj́étil consegue percorrer.
     *
     * @param velocidade Velocidade do projétil.
     * @param angulo     Angulo de inclinação do canhão (radianos).
     *
     * @return Alcance.
     */
    private static double calcularAlcance(double velocidade, double angulo) {
        return 2 * velocidade * Math.cos(angulo) * Math.sin(angulo) / ACELERACAO;
    }

    /**
     * Calcula o tempo que o projétil leva para tocar o solo.
     *
     * @param velocidade Velocidade do projétil.
     * @param angulo     Angulo de inclinação do canhão (radianos).
     *
     * @return Tempo.
     */
    private static double calcularTempo(double velocidade, double angulo) {
        return 2 * velocidade * Math.sin(angulo) / ACELERACAO;
    }

    /**
     * Calcula a altura máxima que o projétil alcançou.
     *
     * @param velocidade Velocidade do projétil.
     * @param angulo     Angulo de inclinação do canhão (radianos).
     *
     * @return Altura máxima.
     */
    private static double calcularAlturaMaxima(double velocidade, double angulo) {
        return Math.pow(velocidade, 2) * Math.pow(Math.sin(angulo), 2) / (2 * ACELERACAO);
    }

    /**
     * Determina se o tiro acertou ou não o alvo.
     *
     * @param alcance   Disância horizontal que o tiro alcançou.
     * @param distancia Distância que o alvo se encontra.
     * @param tamanho   Tamanho do alvo.
     *
     * @return Objeto do tipo {@link Status} representando a situação do disparo.
     */
    private static Status calcularResultado(double alcance, double distancia, double tamanho) {
        //              (errou)               (acertou)              (errou)
        // ______________________________===================________________________
        //              distancia              tamanho                passou
        //
        // ------------------------------*                *
        //                 distancia +1 <|                |> distancia + tamanho -1

        double distanciaMinimaAcerto = distancia + 1;
        double distanciaMaximaAcerto = distancia + tamanho - 1;

        if (alcance < distanciaMinimaAcerto) {
            return Status.NAO_ALCANCOU;
        } else if (alcance > distanciaMaximaAcerto) {
            return Status.PASSOU;
        } else {
            return Status.ACERTOU;
        }
    }

    /**
     * Representa os possíveis resultados do tiro.
     */
    private enum Status {
        NAO_ALCANCOU("Não chegou no alvo"),
        PASSOU("Passou do alvo"),
        ACERTOU("Na mosca");

        private final String status;

        Status(String status) {
            this.status = status;
        }

        @Override
        public String toString() {
            return status;
        }
    }
}

 

[Lucas Bonfim silva gomes]

preciso fazer esse mesmo exercicio só que em python alguem pode me ajudar

[Lucas Bonfim silva gomes]

@AdrianoSiqueira como respondo isso em python??

[AdrianoSiqueira]

Acredito que seria melhor criar um tópico no setor do Python para ter maior visibilidade.