Vérification des éléments adjacents dans les baies 2d et remplacement de ceux-ci

Question

\ Donc, je construis une méthode pour vérifier un tableau 2d pour une valeur cible et remplacer chaque élément adjacent par cette valeur cible. J'ai littéralement essayé de réfléchir la solution à ce pendant environ une heure et je veux juste savoir si quelqu'un peut me aider, c'est le code que j'ai jusqu'à présent

public int[][] replaceValue(int n, int[][]y){ 
int [][]temp0 = new int[y.length][y[0].length]; 
int[]top, down ,left, right = new int[y[0].length]; 
for(int row = 0; row < y.length; row++){ 
    for(int col = 0; col < y[row].length; col++){ 
    temp0[row][col] = y[row][col];// new array so I wouldn't mess with the array passed in 
    } 
} 
for(int row = 0; row < temp0.length; row++){ 
    for(int col = 0; col < temp0[row].length; col++){ 
    top[row] = temp0[row-1][col]; 
    down[row] = temp0[row+1][col]; 
    right[row] = temp0[row][col+1]; 
    left[row] = temp0[row] [col-1]; 
    } 
} 

J'ai des messages d'erreur tels que I n'a pas initialisé mes variables top et left et right et down mais je ne comprends tout simplement pas comment la logique fonctionne pour vérifier les éléments adjacents et s'assurer que tout le tableau n'est pas remplacé par la valeur cible. Merci

Answer 1

La question est un peu confuse donc je vais essayer de l'interpréter.

Ce qui vous est donné est un tableau bidimensionnel avec des valeurs entières. Votre fonction doit analyser le tableau 2-D, et si vous trouvez une valeur cible, renvoie également un tableau 2-d avec les index adjacents comme valeur cible.

Par exemple, si nous avons un tableau de 3x3 et la cible est 2 ...

1 1 1  1 2 1 
1 2 1 ====> 2 2 2 
1 1 1  1 2 1 

Votre problème est que vous ne pouvez pas penser à une façon de changer la valeur sans changer l'ensemble tableau à 2.

Solution One: vous scannez la valeur cible dans le tableau donné, mais vous mettez à jour les valeurs dans le tableau temporaire .

Solution 2: Vous analysez la matrice temporaire et vous enregistrez si elle doit ou non être modifiée à l'aide d'un tableau booléen bidimensionnel.

Solution One est beaucoup mieux en termes d'efficacité (mémoire et temps), donc je vais vous donner ma solution # 2, et vous laisser faire Solution One par vous-même.

En outre, s'il vous plaît utiliser des noms de variables plus descriptives quand il importe: P (pourquoi est l'entrée appelée température ??)

public static int[][] replaceValue(int target, int[][] currArray){ 
     int[][] temp = new int[currArray.length][]; 

     //get a boolean array of same size 
     //NOTE: it is initialized as false 
     boolean[][] needsChange = new boolean[currArray.length][currArray[0].length]; 

     //copy the current array into temp 
     for(int i = 0; i < currArray.length; i++){ 
      temp[i] = currArray[i].clone(); 
     } 

     //Go through each value in the 2d array 
     for(int i = 0; i < temp.length; i++){ 
      for(int j = 0; j < temp[0].length; j++){ 
       //if it is the target value, mark it to be changed 
       if(temp[i][j] == target){ 
        needsChange[i][j] = true; 
       } 
      } 
     } 

     //Go through each value in the 2d array 
     for(int i = 0; i < temp.length; i++){ 
      for(int j = 0; j < temp[0].length; j++){ 
       if(needsChange[i][j]){ //NOTE: same as "needsChange[i][j] = true;" 
        //Now, we will check to make sure we don't go out of bounds 
        //Top 
        if(i > 0){ 
         temp[i-1][j] = target; 
        } 

        //Bottom 
        if(i + 1 < temp.length){ 
         temp[i+1][j] = target; 
        } 

        //Left 
        if(j > 0){ 
         temp[i][j-1] = target; 
        } 

        //Right 
        if(j + 1 < temp[0].length){ 
         temp[i][j+1] = target; 
        } 
       } 
      } 
     } 

     //return the new array we made 
     return temp; 
    } 

Answer 2

Vous n'avez pas initialisé vos variables locales avant la première utilisation. Donc, vous devez changer votre 3ème ligne à quelque chose comme le code ci-dessous:

int[] top = new int[temp[0].length], down = new int[temp[0].length], 
     left = new int[temp[0].length], right = new int[temp[0].length]; 

Après que votre code est compilé et vous pouvez vérifier votre logique.