[Resolvido] Obter os 4 maiores valores de um array com Desvio Padrão

fillipemr · Setembro 24, 2012, 12:05pm

Olá pessoal,

Estou precisando capturar os índices que possuem os quatro (4) maiores valores em um array[20] posições.
A seleção dos 4 maiores valores não podem ser de maneira ordenada. Deve-se, portanto, localizar(informar) os valores
nas suas respectivas posições no vetor.

Essa classe trabalha com os valores de desvios padrões e precisa-se saber quais os 4 maiores valores sem ordená-los e mantendo
as suas respectivas posições no vetor.

A saída que eu tenho dos valores dos desvios padrões:

Desvio Padrão : 0.5196152422706635
Desvio Padrão : 1.0503967504392486
Desvio Padrão : 1.0503967504392486
Desvio Padrão : 2.4946609656090213
Desvio Padrão : 3.2316146634976968
Desvio Padrão : 1.5275252316519468
Desvio Padrão : 2.8448784391135824
Desvio Padrão : 0.05773502691896237
Desvio Padrão : 2.871120571019847
Desvio Padrão : 2.4378952670968728
Desvio Padrão : 4.007908847932215 * 2° maior valor
Desvio Padrão : 0.5
Desvio Padrão : 3.702701716314724 * 4° maior valor
Desvio Padrão : 0.4509249752822896
Desvio Padrão : 0.950438495292217
Desvio Padrão : 4.981298358192705 * 1° maior valor
Desvio Padrão : 2.516611478423583
Desvio Padrão : 2.023198787399136
Desvio Padrão : 3.855299383100272 * 3° maior valor
Desvio Padrão : 0.09999999999999964

A saída que eu preciso. Apenas os 4 maiores valores respeitando suas posições no array:

Desvio Padrão : x
Desvio Padrão : x
Desvio Padrão : x
Desvio Padrão : x
Desvio Padrão : x
Desvio Padrão : x
Desvio Padrão : x
Desvio Padrão : x
Desvio Padrão : x
Desvio Padrão : x
Desvio Padrão : 4.007908847932215 *
Desvio Padrão : x
Desvio Padrão : 3.702701716314724 *
Desvio Padrão : x
Desvio Padrão : x
Desvio Padrão : 4.981298358192705 *
Desvio Padrão : x
Desvio Padrão : x
Desvio Padrão : 3.855299383100272 *
Desvio Padrão : x

Obrigado, pessoal.

package pkg;

/**
 *
 * @author Fillipe Morais
 */
public class Principal {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {


          double array[] = new double[3];
	  array[0] = 10;
	  array[1] = 10; 
	  array[2] = 9.1; 
//	  double media = (array[0]*4+array[1]*5+array[2]*6)/15;
//	  if (media < 3) {
//	    System.out.println(media+ ":Reprovado"); 
//	  } else if (media < 7) {
//	    System.out.println(media+ ":Prova Final");
//	  } else {
//	    System.out.println(media+ ":Aprovado");
//	  }
	  double DvP[] = array;
          DesvioPadrao d = new DesvioPadrao();
          double result = d.desvioPadrao(DvP);
          //System.out.println("Desvio Padrao 1: " +result);
    
          double array2[] = new double[3];  
	  array2[0] = 2.7;
	  array2[1] = 3.7; 
	  array2[2] = 4.8; 
	  double DvP2[] = array2;
          DesvioPadrao d2 = new DesvioPadrao();
          double result2 = d2.desvioPadrao(DvP2);
            //System.out.println("Desvio Padrao 2: " +result2);
            // System.out.println("Desvio Padrao 2: " +d2.desvioPadrao(DvP2));
    
    
          double array3[] = new double[3];  
	  array3[0] = 8.0;
	  array3[1] = 7.0; 
	  array3[2] = 9.1; 
     	  double DvP3[] = array3;
          DesvioPadrao d3 = new DesvioPadrao();
          double result3 = d3.desvioPadrao(DvP3);
           // System.out.println("Desvio Padrao 3: " +d3.desvioPadrao(DvP3));
    
            
          double array4[] = new double[3];  
	  array4[0] = 5.3;
	  array4[1] = 10; 
	  array4[2] = 9.1; 
          double DvP4[] = array4;
          DesvioPadrao d4 = new DesvioPadrao();
          double result4 = d4.desvioPadrao(DvP4);
          //  System.out.println("Desvio Padrao 4: " +d4.desvioPadrao(DvP4));
            
              
          double array5[] = new double[3];  
	  array5[0] = 2.2;
	  array5[1] = 1.0; 
	  array5[2] = 7.1; 
          double DvP5[] = array5;
          DesvioPadrao d5 = new DesvioPadrao();
          double result5 = d5.desvioPadrao(DvP5);
            //System.out.println("Desvio Padrao 5: " +d5.desvioPadrao(DvP5));
           
            
              
          double array6[] = new double[3];  
	  array6[0] = 10;
	  array6[1] = 7.0; 
	  array6[2] = 8.0; 
          double DvP6[] = array6;
          DesvioPadrao d6 = new DesvioPadrao();
          double result6 = d6.desvioPadrao(DvP6);
           // System.out.println("Desvio Padrao 6: " +d6.desvioPadrao(DvP6));
   
            
              
          double array7[] = new double[3];  
	  array7[0] = 4.7;
	  array7[1] = 5.3; 
	  array7[2] = 9.9; 
          double DvP7[] = array7;
          DesvioPadrao d7 = new DesvioPadrao();
          double result7 = d7.desvioPadrao(DvP7);
          //  System.out.println("Desvio Padrao 7: " +d7.desvioPadrao(DvP7));
   
            
              
          double array8[] = new double[3];  
	  array8[0] = 9.9;
	  array8[1] = 10; 
	  array8[2] = 9.9; 
          double DvP8[] = array8;
          DesvioPadrao d8 = new DesvioPadrao();
          double result8 = d8.desvioPadrao(DvP8);
          //  System.out.println("Desvio Padrao 8: " +d8.desvioPadrao(DvP8));
   
            
              
          double array9[] = new double[3];  
	  array9[0] = 1.2;
	  array9[1] = 2.9; 
	  array9[2] = 6.8; 
          double DvP9[] = array9;
          DesvioPadrao d9 = new DesvioPadrao();
          double result9 = d9.desvioPadrao(DvP9);
           // System.out.println("Desvio Padrao 9: " +d9.desvioPadrao(DvP9));
   
            
              
          double array10[] = new double[3];  
	  array10[0] = 3.2;
	  array10[1] = 7.8; 
	  array10[2] = 4.1; 
          double DvP10[] = array10;
          DesvioPadrao d10 = new DesvioPadrao();
          double result10 = d10.desvioPadrao(DvP10);
           // System.out.println("Desvio Padrao 10: " +d10.desvioPadrao(DvP10));
   
            
              
          double array11[] = new double[3];  
	  array11[0] = 4.5;
	  array11[1] = 2.2; 
	  array11[2] = 10; 
          double DvP11[] = array11;
          DesvioPadrao d11 = new DesvioPadrao();
          double result11 = d11.desvioPadrao(DvP11);
           // System.out.println("Desvio Padrao 11: " +d11.desvioPadrao(DvP11));
   
            
              
          double array12[] = new double[3];  
	  array12[0] = 5.0;
	  array12[1] = 5.5; 
	  array12[2] = 6.0; 
          double DvP12[] = array12;
          DesvioPadrao d12 = new DesvioPadrao();
          double result12 = d12.desvioPadrao(DvP12);
            //System.out.println("Desvio Padrao 12: " +d12.desvioPadrao(DvP12));
   
          
              
          double array13[] = new double[3];  
	  array13[0] = 1.2;
	  array13[1] = 8.4; 
	  array13[2] = 3.3; 
          double DvP13[] = array13;
          DesvioPadrao d13 = new DesvioPadrao();
          double result13 = d13.desvioPadrao(DvP13);
          //  System.out.println("Desvio Padrao 13: " +d13.desvioPadrao(DvP13));
            
          double array14[] = new double[3];  
	  array14[0] = 4.0;
	  array14[1] = 4.4; 
	  array14[2] = 4.9; 
          double DvP14[] = array14;
          DesvioPadrao d14 = new DesvioPadrao();
          double result14 = d14.desvioPadrao(DvP14);
           // System.out.println("Desvio Padrao 14: " +d14.desvioPadrao(DvP14));
   
            
              
          double array15[] = new double[3];  
	  array15[0] = 4.5;
	  array15[1] = 6.4; 
	  array15[2] = 5.5; 
          double DvP15[] = array15;
          DesvioPadrao d15 = new DesvioPadrao();
          double result15 = d15.desvioPadrao(DvP15);
           // System.out.println("Desvio Padrao 15: " +d15.desvioPadrao(DvP15));
   
            
              
          double array16[] = new double[3];  
	  array16[0] = 10;
	  array16[1] = 1.0; 
	  array16[2] = 9.2; 
          double DvP16[] = array16;
          DesvioPadrao d16 = new DesvioPadrao();
          double result16 = d16.desvioPadrao(DvP16);
           // System.out.println("Desvio Padrao 16: " +d16.desvioPadrao(DvP16));
   
            
              
          double array17[] = new double[3];  
	  array17[0] = 2.1;
	  array17[1] = 5.1; 
	  array17[2] = 7.1; 
          double DvP17[] = array17;
          DesvioPadrao d17 = new DesvioPadrao();
          double result17 = d17.desvioPadrao(DvP17);
           // System.out.println("Desvio Padrao 17: " +d17.desvioPadrao(DvP17));
   
            
              
          double array18[] = new double[3];  
	  array18[0] = 7.0;
	  array18[1] = 3.4; 
	  array18[2] = 6.8; 
          double DvP18[] = array18;
          DesvioPadrao d18 = new DesvioPadrao();
          double result18 = d18.desvioPadrao(DvP18);
           //System.out.println("Desvio Padrao 18: " +result18);
   
            
            
              
          double array19[] = new double[3];  
	  array19[0] = 2.4;
	  array19[1] = 7.7; 
	  array19[2] = 9.9; 
          double DvP19[] = array19;
          DesvioPadrao d19 = new DesvioPadrao();
          double result19 = d19.desvioPadrao(DvP19);
          //   System.out.println("Desvio Padrao 19: " +d19.desvioPadrao(DvP19));
   
            
              
          double array20[] = new double[3];  
	  array20[0] = 8.3;
	  array20[1] = 8.4; 
	  array20[2] = 8.5; 
          double DvP20[] = array20;
          DesvioPadrao d20 = new DesvioPadrao();
          double result20 = d20.desvioPadrao(DvP20);
           // System.out.println("Desvio Padrao 20: " +d20.desvioPadrao(DvP20));
   
           
        
          double arrayDP[] = new double [20];
          arrayDP[0] = result;
          arrayDP[1] = result2;
          arrayDP[2] = result3;
          arrayDP[3] = result4;
          arrayDP[4] = result5;
          arrayDP[5] = result6;
          arrayDP[6] = result7;
          arrayDP[7] = result8;
          arrayDP[8] = result9;
          arrayDP[9] = result10;
          arrayDP[10] = result11;
          arrayDP[11] = result12;
          arrayDP[12] = result13;
          arrayDP[13] = result14;
          arrayDP[14] = result15;
          arrayDP[15] = result16;
          arrayDP[16] = result17;
          arrayDP[17] = result18;
          arrayDP[18] = result19;
          arrayDP[19] = result20;
          
          for (int i = 0; i < arrayDP.length; i++) {  
            System.out.println("Desvio Padrão : " + arrayDP[i]);  
  
        }
          
          
   
    }

    
}

Obrigado.

Ataxexe · Setembro 24, 2012, 12:14pm

O GUJ não vai te dar o trabalho que você precisa, vai tentar tirar a dúvida que você tem. Em vez de pedir um trabalho e colocar URGENTE no tópico, poste suas dúvidas que iremos te ajudar.

Te adianto que poderá percorrer o array “arrayDP” usando Math.max. Tente fazer isso e vá postando as dúvidas decorrentes.

fillipemr · Setembro 24, 2012, 12:17pm

[quote=Ataxexe]O GUJ não vai te dar o trabalho que você precisa, vai tentar tirar a dúvida que você tem. Em vez de pedir um trabalho e colocar URGENTE no tópico, poste suas dúvidas que iremos te ajudar.

Te adianto que poderá percorrer o array “arrayDP” usando Math.max. Tente fazer isso e vá postando as dúvidas decorrentes.[/quote]

Sem problemas, Ataxexe. Desculpa pela ignorância, pois foi meu primeiro Post.

Ataxexe · Setembro 24, 2012, 12:33pm

Tudo bem, mas o fato de ser seu primeiro post não o isenta de seguir as regras do fórum. Tenha mais cuidado com seus posts e seja bem-vindo ao GUJ.

fillipemr · Setembro 24, 2012, 12:37pm

Obrigado!

Eu tentei usar aqui o Math.max, mas não consegui fazer ele me listar só os 4 maiores índices. Essa Math.max e Math.min são mais para ordenação, não?

Pior que se fosse para ordenar os valores seria mais simples… mas estou quebrando a cabeça de todas as formas tentando listar os maiores e que eles
permaneçam nas suas posições.

ViniGodoy · Setembro 24, 2012, 12:49pm

Por favor, não peça urgências no fórum.

A solução do seu problema:
a) Crie uma classe com 2 campos: desvioPadrao e índice;
b) Torne essa classe um Comparable: http://www.guj.com.br/java/54036-usando-comparator-e-comparable
c) Em seguida, copie os dados do array pra um TreeSet, usando essa classe.
d) Pegue os 4 primeiros elementos do TreeSet.

fillipemr · Setembro 24, 2012, 8:55pm

… a partir do arrayDP[19] = result20; segue o código:

 //Arrays.sort(arrayDP);      
        for (int i = 0; i < arrayDP.length; i++) {  
             System.out.println("Desvio Padrão " + i + " : " + arrayDP[i]); 
           
        }    
        System.out.println("---------------------------------------------------");
        /*  System.arraycopy(from, fromIndex, to, toIndex, count);
            1) from e to:  se referem ao array de origem e o array alvo. 
            2) Os demais parâmetros se referem ao índices e qtd de elementos a serem copiados.
        */
          Arrays.sort(arrayDP);
          int percentual = (int)(arrayDP.length*0.83) ; // O cálculo da porcentagem é invertido. Ex: p/ 10% usa 90%; p/ 35% usa 65%. [Arredonda p/ mais]
          int arrayDPauxSize = (int)((arrayDP.length)-percentual);
          double arrayDPaux[] = new double[arrayDPauxSize];
               System.arraycopy(arrayDP, percentual, arrayDPaux, 0, (int)((arrayDP.length)-percentual));
          for(double valorDPaux : arrayDPaux){
              System.out.println("Desvio Padrão Auxiliar : " + valorDPaux);
          }
          System.exit(0);
          // + valorDPaux será rotulado.

Lógica suficiente. Obrigado!

system · Dezembro 28, 2015, 4:21pm

[Resolvido] Obter os 4 maiores valores de um array com Desvio Padrão

Cursos de Mobile

Cursos de Programação

Cursos de Front-end

Cursos de DevOps

Cursos de Design & UX

Cursos de Business

Cursos de Data & BI