Je dois trouver combien de lignes d'horizon ont 4 nombre consécutif de la même valeur dans la matrice (8x7). Si j'ai raison, il y a 2 lignes horizontales.
2 1 1 6 1 0 0 p>
2 1 1 7 6 0 1 p>
1 1 7 1 6 1 1 p>
9 7 6 0 1 1 6 p>
7 9 1 1 6 9 0 p>
7 5 9 2 2 2 0 p>
7 5 7 1 1 1 1 strong> 0 0 P> mais quand je l'exécute: P > # de lignes horizontales: 3 strong> p> Quelqu'un voudrait-il résoudre ce problème? p> problème changé après mon commentaire aidé avec mon 1er problème . P> public class Q5_Numbers{
public static void main(String[] args){
int[][] matrix = {
{2, 1, 1, 6, 1, 0, 0},
{2, 1, 1, 7, 6, 0, 1},
{1, 1, 7, 1, 6, 1, 1},
{9, 7, 6, 0, 1, 1, 6},
{7, 9, 1, 1, 6, 9, 0},
{7, 5, 9, 2, 2, 2, 0},
{7, 5, 9, 9, 9, 9, 0},
{7, 1, 1, 1, 1, 0, 0}
};
// # of Horizontal Lines = 2
System.out.printf("# of Horizontal lines: %d\n", findHorizontal(matrix));
}
public static int findHorizontal(int[][] values){
int countH = 0;
int found = 0;
for(int i = 0; i < values.length; i++){
int current = values[i][0];
for(int j = 0; j < values[i].length; j++){
if(values[i][j] == current){
found++;
if(found == 4){
countH++;
found = 0;
}
}
}
}
return countH;
}
}
5 Réponses :
Vous devez instancier la variable actuelle à chaque fois que vous visitez un élément d'affilée, car lorsque vous réparez Par exemple dans la ligne avec cela, le code sera le suivant: actuel au premier élément de la ligne que vous manquez les chances de compter le 4 consécutif quand une telle ligne ne commence pas par le premier élément de la ligne. 7, 5, 9, 9, 9, 9, 0 si vous réparez actuel à 7 , vous manquez cette ligne. De plus, vous devez instancier trouvé pour chaque actuel .
Cela fonctionne, mais que le interne tandis que boucle introduit une complexité inutile de l'algorithme. La solution de SC0DER semble plus simple. Avoir un uppot de toute façon.
@Federicoklezculloca tandis que la boucle n'augmente pas la complexité du temps que vous ne vouliez pas dire par ce droit? Parce que j est mis à jour dans la boucle tandis que. Mais savoir consécutifs 4, vous devez vous arrêter quelque part et continuer à regarder et il est assez facile de lire. Plus important encore, cela n'augmente pas l'heure.
Non, je ne voulais pas dire la complexité de temps. Je pense qu'une meilleure expression aurait été "charge mentale". Mais comme je l'ai dit, je trouve la solution de Sc0oder plus facile à raisonner. Mais peut-être que c'est juste moi.
Convenu. C'est plus simple.
1) La comparaison des éléments contre le premier élément de la ligne est fausse. Une ligne telle que celle-ci ne sera pas une correspondance quand elle devrait être 2) réinitialisation trouvée code> uniquement sur l'accès à 4 éléments est fausse, car toute ligne sans 1, 2, ou 3 correspondances porteront sur le décompte de la ligne suivante. P> int[][] matrix = {
{1, 1, 2, 1, 1}
};
mettre à jour le code pour réinitialiser comme ceci: , sortie trouvé et garder une trace de l'élément précédent dans actuel
Merci. Cela corrige le problème :)
Une réponse alternative
//This'd be a lot sweeter with foldRight
(int) Arrays.stream(values).filter(arr -> {
int prev = arr[0], found = 0;
for (int i = 1; i < arr.length; i ++) {
int x = arr[i];
if (prev == x) {
if (++found == 3) return true;
} else {
found = 0;
prev = x;
}
}
return false;
}).count()
package com.vish.array;
matrice de classe publique
{ }
Vous voudrez peut-être réinitialiser
trouvé à 0, parfois.@Federicoklezculloca ah merci. Mais maintenant j'ai trouvé un autre problème parce que pour une raison quelconque, le # est 3 au lieu de 2
Notez également que ces 4 valeurs consécutives peuvent ne pas être la même valeur qui commence chaque ligne, donc
int Courant = valeurs [i] [0]; semble un peu désactivé. Vous comptez combien d'éléments sont les mêmes que le premier, pas combien d'éléments consécutifs il y a@Federicoklezculloca Comment devrais-je continuer à résoudre ce problème?
Votre valeur actuelle ne doit pas arrêter au début de votre ligne, car @FedericokleZculloca a déjà dit. Aussi dans la boucle interne, vous avez besoin d'un bloc d'autre qui gère le cas
valeurs [i] [j]! = Actuel . Vous obtenez maintenant les trois parce que votre ligne 3 contient 5 nombres identiques (même s'ils ne sont pas dans une rangée, vous les comptez toujours comme consécutifs), de sorte que le contre-conseil augmente.