Comme le titre l'indique, j'ai juste besoin d'aide / de conseils sur la façon dont je peux simplifier une partie de mon code. J'obtiens le rendement que je veux mais il est évident de voir que la façon dont je m'y prends est un peu excessive. Ce que j'essaie de faire dans mon programme, c'est de passer le tableau
int length = 8; [0] = 1; [1] = 2; [2] = 1; [3] = 1; [4] = 1; [5] = 2; [6] = 2; [7] = 2;
Dans ma méthode buildFeetArray qui prend juste les éléments du tableau, les divise par 12 pour obtenir une nouvelle valeur d'élément qui est ensuite placée dans un nouveau tableau qui est retourné. Voici la méthode
public static int[] buildFeetArray(int[] arrayParam) {
int sum = 0;
int lessthan1 = 0;
int lessthan2 = 0;
int lessthan3 = 0;
int lessthan4 = 0;
int lessthan5 = 0;
int lessthan6 = 0;
int lessthan7 = 0;
int lessthan8 = 0;
for (int count = 0; count < arrayParam.length; count++) {
if (arrayParam[count] / 12 == 0) {
lessthan1++;
} else if (arrayParam[count] / 12 == 1) {
lessthan2++;
} else if (arrayParam[count] / 12 == 2) {
lessthan3++;
} else if (arrayParam[count] / 12 == 3) {
lessthan4++;
} else if (arrayParam[count] / 12 == 4) {
lessthan5++;
} else if (arrayParam[count] / 12 == 5) {
lessthan6++;
} else if (arrayParam[count] / 12 == 6) {
lessthan7++;
} else if (arrayParam[count] / 12 == 7) {
lessthan8++;
}
}
int[] newArray = {lessthan1, lessthan2, lessthan3, lessthan4, lessthan5, lessthan6, lessthan7, lessthan8};
return newArray;
}
Idéalement, la sortie devrait être
int [] myInches = {89,12,33,7,72,42,76,49,69,85,61,23};
Ce que c'est, mais il y a certainement un moyen plus simple de s'y prendre, si possible, j'aimerais éviter d'utiliser des listes et de m'en tenir aux boucles car j'ai besoin de m'entraîner avec elles. Merci d'avance pour tous conseils / astuces.
6 Réponses :
Vous pouvez utiliser un bloc Switch:
switch(arrayParam[count]/12){
case 0:
lessthan1++;
break;
case 1:
lessthan2++;
break;
//and so on...
}
L'effet est le même mais il a l'air beaucoup plus propre et il est pratique dans des situations comme celle-ci
Vous pouvez utiliser un autre tableau pour stocker le résultat, par exemple:
public static int[] buildFeetArray(int [] arrayParam) {
int[] lessThanArray = new int[8];
for (int count = 0; count < arrayParam.length; count++) {
for (int remainder = 0; remainder < lessThanArray.length; remainder++) {
if (arrayParam[count] / 12 == remainder) {
lessThanArray[remainder]++;
break; // exit from the inner "for" loop
}
}
}
return lessThanArray;
}
Pourtant, il n'y a vraiment aucune raison d'utiliser une deuxième boucle pour cela; cela ne fait qu'ajouter à la confusion.
J'ai écrit un pseudo-code pour cela, dans lequel vous devez simplement initialiser un tableau et incrémenter un index particulier du tableau lorsqu'une certaine condition correspond:
public static int [] buildFeetArray(int [] arrayParam) {
int index;
int [] lessthan = {0,0,0,0,0,0,0,0};
for (int count = 0; count < arrayParam.length; count++) {
index = arrayParam[count]/12;
if(index < 8 ) {
lessthan[index]++;
}
}
return lessthan;
}
Et ça:
int[] lessThanArray = new int[8];
for (int entry: myInches) {
int lessThan = entry / 12;
if (lessThan < 8) {
lessThanArray[lessThan]++;
}
}
Nous pouvons utiliser certaines API Java-8 pour le rendre encore plus court.
[1, 2, 1, 1, 1, 2, 2, 2]
Explication :
Itérer à travers un flux d'entiers générant des valeurs d'index jusqu'à la longueur du tableau d'entrée.
Dans chaque itération, trouver l'indice à la suite de la division avec 12 et incrémenter le compteur, soit 89/12 = 7 donc on incrémente le compteur du 7 e index. Cela dénoterait lessthan8 variable dans votre code.
length supplémentaire.Contribution:
int[] res = buildFeetArray(new int[]{89,12,33,7,72,42,76,49,69,85,61,23}, 8);
Production:
public static int [] buildFeetArray(int [] arrayParam, int length) {
int [] result = new int[arrayParam.length];
IntStream.range(0, arrayParam.length).forEach(i -> result[arrayParam[i] / 12] = result[arrayParam[i] / 12] + 1 );
return Arrays.copyOf(result, length);
}
J'ai simplement modifié un peu votre code. Vous pouvez essayer ceci:
public static int [] buildFeetArray(int [] arrayParam) {
int sum = 0;
int len=8; // your ideal lengh, change it if needed
int[] lessthan = new int[len+1];
for(int i=0; i<len+1; i++){ lessthan[i]=0; }
for (int count = 0; count < arrayParam.length; count++) {
int d = arrayParam[count]/12;
d = d+1;
lessthan[d]++;
// so, if arrayParam[count]/12 == 0,1,2,..., then d = 1,2,3,...
}
return lessthan;
}
Votre solution est techniquement incorrecte, veuillez relire la question attentivement
Le code de votre question ne correspond pas du tout à la spécification. J'ai du mal à comprendre ce que fait le code, pour être honnête, mais il ne fait clairement pas ce que vous prétendez faire. Pouvez-vous donner une spécification précise de ce que le code est censé faire?
Il semble que vous renvoyez le nombre d'entrées qui ont 1, 2, 3, 4, etc. pieds, ce qui ne correspond pas à ce que vous dites. De plus, la dénomination «lessThan» n'a aucun sens puisque
lessThan8devrait être toutes les entrées fournies.