Preciso de ajuda na hora de pegar as alturas para fazer a mediana , estou com dificuldade na hora de pegar os valores do vetor

int Jogadores = 10;
String [] nome = new String [Jogadores];

for(int i = 0 ; i < Jogadores ; ++i){
System.out.println("Insira o nome do " + (i+1) + “° jogador .”);
nome[i] = entrada.next();
}

double [] Altura = new double [Jogadores];

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

System.out.println(“Insira a altura do " + (i+1) + “° jogador .”);
Altura[i] = entrada.nextDouble();
while (Altura[i]<=0){
System.out.println(“Valor invalido , reensira o valor : “);
Altura [i] = entrada.nextDouble();
}
}
System.out.println(”=========== TIME DE BASQUETE ===========”); // laço para jogador + sua altura
for(int i = 0; i < Jogadores;++i){
System.out.println(nome[i] +” ---- "+ Altura [i]+“m”);
}

    System.out.println("A media das alturas dos jogarores é : ");
    double soma;
    soma = Altura [0] + Altura [1] + Altura [2] +Altura [3] +Altura [4] +Altura [5] +Altura [6] +Altura [7] +Altura [8] +Altura [9] ; // Soma das alturas
  double media = soma/10;
    System.out.println(media);
    
    
    
    double t1 = Altura[0]*Altura[0]; // as alturas elevadas ao quadrado
    double t2 = Altura[1]*Altura[1];
    double t3 = Altura[2]*Altura[2];
    double t4 = Altura[3]*Altura[3];
    double t5 = Altura[4]*Altura[4];
    double t6 = Altura[5]*Altura[5];
    double t7 = Altura[6]*Altura[6];
    double t8 = Altura[7]*Altura[7];
    double t9= Altura[8]*Altura[8];
    double t10 = Altura[9]*Altura[9];
    
    double soma2 = t1+t2+t3+t4+t5+t6+t7+t8+t9+t10; // soma dos valores
    double media2 = media*media; // media ao quadrado 
    
    double desvio = (soma2/10)-media2; // calculo para o Desvio Padrão
    System.out.println("O desvio padrão é "+desvio);
    
    
    double maior = Altura[0];
    double menor=Altura[0];
    String nomeMaior = "";
    String nomeMenor = "";
    for(int i=0; i<Jogadores; i++){
    if(Altura[i] > maior){
        nomeMaior = nome[i];
        maior = Altura[i]; 
    }
    if(Altura[i]<= menor){
        menor = Altura[i];
        nomeMenor = nome[i];
    }
    }
    
   
   System.out.println("A maior altura é : "+maior+" m do jogador  " + nomeMaior ); // saida da maior / menor altura dos jogadores 
   System.out.println("A menor altura é : "+menor+" m do jogador " + nomeMenor);

   
     
    
    double mediana ;
    Arrays.sort(Altura);
    mediana = Altura[4]+Altura[5];  --> Nessa parte os valores não batem com o resultado 
    double media3 = mediana / 2;
    System.out.println("A mediana das alturas é igual a : "+media3);
}

}

Nos dê uma contextualização!

O que você está tentando fazer?

A base da codigo vem dessa atividade que foi passada , consegui fazer a maioria dos itens , so que estou empacado na parte da mediana , que no caso , preciso pegar os valores do meio do vetor altura e dividir , so que quando utilizo Altura[4] + altura[5] os valores não sao os correspondentes n e quando vou fazer a prova real (fora do programa) o valor não bate

A ideia é fazer um programa que implemente um relatório estatístico
dos jogadores de um time de basquete de uma temporada. Esse relatório é
importante para o técnico definir se seu time está com índices de
desenvolvimento bons em relação aos demais times da temporada.

Sabe-se que em um time de basquete são necessários 5 jogadores em quadra,
podendo ter até outros 5 jogadores reservas, contabilizando 10 jogadores por
time no total.

Para cada um dos jogadores do time, seu programa deve ler o nome e a altura.
Usar um vetor de Strings para armazenar os nomes e um vetor para armazenar
as alturas.

Após a entrada dos dados dos 10 jogadores, o programa deve apresentar o
seguinte menu de opções:

======== TIME DE BASQUETE ========
1 – Dados dos jogadores
2 – Média de alturas
3 – Desvio padrão das alturas
4 – Maior e Menor altura
5 – Mediana das alturas
6 – Finalizar Digite uma opção:

• Item 1 – Exibir o nome e a altura de cada jogador do time;
• Item 2 – Calcular e apresentar a média das alturas do time de basquete;
• Item 3 – Apenas se a média já estiver sido calculada, calcular o desvio padrão
que é dado pela fórmula:

• Item 4 – Encontrar o jogador mais alto e o jogador mais baixo do time.
Apresentar o nome do jogador e a sua altura;
• Item 5 – Calcula a mediana das alturas. A mediana é o elemento central de
uma lista ordenada. Caso o conjunto de dados seja par, então a mediana é a
média dos dois valores centrais. Pesquise como “ordenar vetor em JAVA”.
2
Lembre-se que o vetor de nomes também devem ser alterados, para tanto,
pesquise a função de cópia de strings – clone(); • Item 6 – Finaliza a execução
do programa.
REGRAS E RESTRIÇÕES
Para o correto desenvolvimento do programa algumas regras e restrições devem
ser cumpridas:

  1. A tela de início do programa deve apresentar (System.out.println()) o
    nome completo e o RA de cada integrante do grupo!
  2. A altura de cada jogador, não pode ser 0 negativa. Caso seja digitado um
    valor inválido, o programa deverá solicitar um novo valor;
  3. 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;
  4. O programa somente deve ser finalizado ao escolher o item 5 do menu;
  5. Pode utilizar o conceito de métodos – pesquisar nos livros de referência;
  6. Para armazenar os nomes dos jogadores, o grupo deve pesquisar o
    conceito de matrizes (“vetor de Strings em Java” no google).

O cálculo da mediana difere entre conjuntos pares e ímpares.
Quando você tem um conjunto ímpar de valores ordenados, a mediana é o valor da posição central.
Quando você tem um conjunto par de valores ordenados, a mediana é a média dos dois valores centrais.

Complementando a resposta já apresentada neste tópico:

import java.io.PrintStream;
import java.util.Arrays;
import java.util.Scanner;

public class Programa {

    public static void main(String[] args) {
        Programa programa = new Programa();
        programa.executar();
    }

    private final Scanner entrada = new Scanner(System.in);
    private final PrintStream saida = System.out;

    public void executar() {
        int jogadores = 10;
        String[] nomes = new String[jogadores];
        double[] alturas = new double[jogadores];

        for (int i = 0; i < jogadores; i++) {
            nomes[i] = lerNome(i + 1);
            alturas[i] = lerAltura(i + 1);
        }

        saida.println("=========== TIME DE BASQUETE ===========");
        for (int i = 0; i < jogadores; i++) {
            saida.println(nomes[i] + " ---- " + alturas[i] + " m");
        }

        double media = media(alturas);
        saida.println("A media das alturas dos jogadores é: " + media + " m");

        double mediana = mediana(alturas);
        saida.println("A mediana das alturas é igual a: " + mediana);

        double desvioPadrao = desvioPadrao(alturas, media);
        saida.println("O desvio padrão das alturas dos jogadores é: " + desvioPadrao);

        int maior = posicaoMaior(alturas);
        saida.println("A maior altura é " + alturas[maior] + " m do jogador " + nomes[maior]);

        int menor = posicaoMenor(alturas);
        saida.println("A menor altura é " + alturas[menor] + " m do jogador " + nomes[menor]);
    }

    private String lerNome(int jogador) {
        saida.println("Insira o nome do " + jogador + "° jogador .");
        return entrada.nextLine();
    }

    private double lerAltura(int jogador) {
        while (true) {
            saida.println("Insira a altura do " + jogador + "° jogador .");
            double altura = Double.parseDouble(entrada.nextLine());
            if (altura > 0) {
                return altura;
            }
            saida.println("Reinsira o valor");
        }
    }

    private double media(double[] valores) {
        double soma = 0;
        for (double valor : valores) {
            soma += valor;
        }
        double quantidade = valores.length;
        return soma / quantidade;
    }

    private double mediana(double[] valores) {
        int quantidade = valores.length;
        double[] valoresOrdenados = new double[quantidade];
        System.arraycopy(valores, 0, valoresOrdenados, 0, quantidade);
        Arrays.sort(valoresOrdenados);
        double mediana;
        if (quantidade % 2 == 0) { // conjunto par
            int esquerda = quantidade / 2;
            int direita = esquerda + 1;
            mediana = (valoresOrdenados[esquerda] + valoresOrdenados[direita]) / 2.0;
        } else { // conjunto ímpar
            int meio = quantidade / 2;
            mediana = valoresOrdenados[meio];
        }
        return mediana;
    }

    private double desvioPadrao(double[] valores, double media) {
        double soma = 0;
        for (double valor : valores) {
            soma += Math.pow(valor - media, 2);
        }
        double quantidade = valores.length;
        return Math.sqrt(soma / quantidade);
    }

    private int posicaoMaior(double[] valores) {
        int maior = 0;
        for (int i = 1; i < valores.length; i++) {
            if (valores[i] > valores[maior]) {
                maior = i;
            }
        }
        return maior;
    }

    private int posicaoMenor(double[] valores) {
        int menor = 0;
        for (int i = 1; i < valores.length; i++) {
            if (valores[i] < valores[menor]) {
                menor = i;
            }
        }
        return menor;
    }
}

Certo , mas no caso , utilizei o Arrays.sort para organizar em ordem , só que , quando pego
double mediana = Altura[4] + Altura [5] ; não bate o resultado no final , sou meio iniciante , e fiquei meio empacado

Como eu disse, num conjunto PAR a mediada é a MÉDIA dos dois valores centrais.
Você não calculou a MÉDIA, você fez a SOMA.

Veja como foi calculado a mediana na solução postada. :wink:

Posta os valores que você está informando para os 10 jogadores e qual deveria ser o resultado apresentado.

Olha fiz assim,
Arrays.sort(Altura);
mediana = Altura[4]+Altura[5];
double media3 = mediana / 2;
System.out.println("A mediana das alturas é igual a : "+media3);
e desculpa é que não sei muita coisa e não consegui entender a codigo que voce mandou , tem mta coisa q eu ainda não vi :confused:

Quais os valores contidos na posição 4 e 5?
Qual seria o valor esperado e qual é o valor que está aparecendo?

Note que você está dividindo seus valores por 2 que é um int.
Toda divisão por um int resulta em um número inteiro.
Se espera um valor real, divida por 2.0 ou por (double) 2. :wink:

Não peça desculpas, você está aprendendo. Deveria pedir desculpas se estivesse se recusando a aprender. :wink:

O que você não entendeu?
Foque no método executar e tente entender o que acontece em cada linha, os nomes dos métodos estão bem legíveis.

então , fiz com os valores de 1 a 10 , na posição central fica o 4 e o 5 sendo mediana com valor par , o esperado era dar 4,5 certo ? só que esta dando 5,5

Então, vamos “desenhar” seu array com os valores nas respectivas posições:

        +----+----+----+----+----+----+----+----+----+----+
posição |  0 |  1 |  2 |  3 |  4 |  5 |  6 |  7 |  8 |  9 |
        +----+----+----+----+----+----+----+----+----+----+
  valor |  1 |  2 |  3 |  4 |  5 |  6 |  7 |  8 |  9 | 10 |
        +----+----+----+----+----+----+----+----+----+----+

Na posição 4 temos o valor 5.
Na posição 5 temos o valor 6.

 5 + 6 = 11
11 / 2 = 5.5

O resultado está correto, o que está errado é você achar que nas posições 4 e 5 havia também os valores 4 e 5.

Mas é um problema você informar manualmente ao posições pois se você quiser mudar a quantidade de jogadores para 11, 12 ou 8, você vai ter que reescrever todo o seu algoritmo novamente ajustando as posições para o cálculo.

Com o método abaixo isso não acontece:

private double mediana(double[] valores) { // aqui eu recebo o array de valores por parâmetro
    int quantidade = valores.length; // guardo o tamanho do array numa variável
    double[] valoresOrdenados = new double[quantidade]; // crio um novo array
    System.arraycopy(valores, 0, valoresOrdenados, 0, quantidade); copio os valores do array original para novo array
    Arrays.sort(valoresOrdenados); // ordeno os valores do novo array, sem alterar o array original
    double mediana; // crio uma variável para armazenar o valor da mediana
    if (quantidade % 2 == 0) { // se a quantidade de elementos do array for par, calculo as duas posições centrais
        int esquerda = quantidade / 2; // a primeira posição central é a metade do tamanho do array
        int direita = esquerda + 1; // a segunda posição central é posição ao lado da primeira
        mediana = (valoresOrdenados[esquerda] + valoresOrdenados[direita]) / 2.0; // calculo a média das duas posições
    } else { // se a quantidade de elementos do array for ímpar, a mediana será a posição central
        int meio = quantidade / 2; // o meio é a metade da quantidade
        mediana = valoresOrdenados[meio]; // usa o valor do medio
    }
    return mediana; // retorna o valor da mediana para quem chamou este método
}
1 curtida

Nossa , muito obrigado mesmo , estava vacilando em coisa boba ,
em relação a quantidade ja é limitada então acho q da para deixar assim , muito obrigado msm

1 curtida