Java: Comment obtenir ces deux méthodes en une?

Question

Dans notre mission, nous sommes seulement autorisés à utiliser une méthode. Je ne savais pas à ce sujet et j'en ai écrit deux. Je voulais donc demander, si c'est en quelque sorte possible d'intégrer la fonction de ma méthode de voisinage dans la méthode de la vie. J'ai essayé, mais je ne sais pas comment initialiser mes voisins int. Regardez le code suivant:

public static String[] life(String[] dish) { 
    String[] newGen = new String[dish.length]; 

    //TODO: implement this function 
    for (int line = 0; line < dish.length; line++) { // for loop going through each line 
     newGen[line] = ""; 
     for (int i = 0; i < dish[line].length(); i++) { // loops through every character in the line 
      String top = ""; // neighbours on the top 
      String middle = ""; // neighbors on the same line 
      String down = ""; // neighbors down 
      if (i == 0){ 
       if(line == 0){ 
        top = null; 
       } else { 
        top = dish[line-1].substring(i, i+2); 
       } 
       middle = dish[line].substring(i + 1, i +2); 
       if(line == dish.length -1){ 
        down = null; 
       } else { 
        down = dish[line + 1].substring(i, i + 2); 
       } 
      } else if (i == dish[line].length() - 1){ 
       if(line == 0){ 
        top = null; 
       } else { 
        top = dish[line - 1].substring(i - 1, i + 1); 
       } 
       middle = dish[line].substring(i - 1, i); 
       if(line == dish.length - 1){ 
        down = null; 
       } else { 
        down = dish [line + 1].substring(i - 1, i + 1); 
       } 
      } else { 
       if (line == 0){ 
        top = null; 
       } else { 
        top = dish[line - 1].substring(i - 1, i + 2); 
       } 
       middle = dish[line].substring(i - 1, i) + dish[line].substring(i+1, i+2); 
       if (line == dish.length - 1){ 
        down = null; 
       } else { 
        down = dish[line + 1].substring(i - 1, i + 2); 
       } 
      } 

      int neighbors = neighbourconditions(top, middle, down); 
      if (neighbors < 2 || neighbors > 3){ // neighbours < 2 or >3 neighbors -> they die 
       newGen[line] += "o"; 
      } else if (neighbors == 3){ 
       newGen[line] += "x"; // neighbours exactly 3 -> they spawn/live 
      } else { 
       newGen[line] += dish[line].charAt(i); // 2 neighbours -> stay 
      } 
     } 
    } 
    return newGen; 
} 

// helpmethod with three arguments and the conditions 
public static int neighbourconditions(String top, String middle, String down) { 
    int counter = 0; 
    if (top != null) { // if no one's on top 
     for (int x = 0; x < top.length(); ++x) { 
      if (top.charAt(x) == 'x') { 
       counter++; // count if an organism's here 
      } 
     } 
    } 
    for (int x = 0; x < middle.length(); ++x) { 
     if (middle.charAt(x) == 'x') { // two organisms, one on each side 
      counter++; // count if an organism's here 
     } 
    } 
    if (down != null) { // if no one's down 
     for (int x = 0; x < down.length(); ++x) { 
      if (down.charAt(x) == 'x') { // each neighbour down 
       counter++; // count if an organism's here 
      } 
     } 
    } 
    return counter; 
} 

Answer 1

La réponse triviale à cette question est de copier et coller le code de la méthode dans le corps de l'autre méthode. Si vous utilisez un IDE, vous pouvez utiliser les outils de refactoring intégrés pour incorporer la méthode (par exemple ctrl-alt-n, dans intellij).

Mais c'est le genre de comportement qui fait que les générations futures maudissent votre nom. Cela rend le code méchant, illisible et inaccessible. Ne fais pas ça. Comme GhostCat l'a souligné dans les commentaires, vous devriez chercher à rendre les méthodes plus petites, pas plus grandes. Prenez un peu de recul et examinez si vous abordez le problème de la bonne manière. Cherchez des motifs répétitifs dans le code existant, pour voir si vous pouvez le simplifier. Ou, parfois, considérez que vous avez juste pris la mauvaise approche en premier lieu, et ainsi vous devez trouver une approche alternative.

---

Pour autant que je peux travailler, tout ce que vous essayez de faire est de compter le nombre de x s dans les 8 cellules entourant immédiatement la position actuelle.

Vous n'avez pas besoin de tout ce code pour le faire. Vous pouvez simplement faire:

for(int row = 0; row < dish.length; row++){ // each row 
    for(int col = 0; col < dish[row].length(); col++){ // each char in the row 

    int neighbors = 0; 
    for (int r = Math.max(row - 1, 0); r < Math.min(row + 2, dish.length); ++r) { 
     for (int c = Math.max(col - 1, 0); c < Math.min(col + 2, dish[row].length()); ++c) { 
     // Don't count (row, col). 
     if (r == row && c == col) continue; 

     if (dish[r].charAt(c) == 'x') ++neighbors; 
     } 
    } 

    //here ends the interesting part for you 
    if(neighbors < 2 || neighbors > 3){ 
     // etc. 

Manque de code, pas besoin de méthode auxiliaire. Aussi beaucoup plus efficace, car cela évite de créer inutilement des chaînes.

Answer 2

Tout ce que vous faites dans la deuxième fonction devra être fait dans la première fonction. Donc, il suffit de copier le code de la fonction 2 en fonction 1:

public static String[] life(String[] dish){ 
String[] newGen= new String[dish.length]; 

//TODO: implement this functions 
for(int row = 0; row < dish.length; row++){ // each row 
    newGen[row]= ""; 
    for(int i = 0; i < dish[row].length(); i++){ // each char in the row 
     String above = ""; // neighbors above 
     String same = ""; // neighbors in the same row 
     String below = ""; // neighbors below 
     if(i == 0){ // all the way on the left 
      // no one above if on the top row 
      // otherwise grab the neighbors from above 
      above = (row == 0) ? null : dish[row - 1].substring(i, i + 2); 
      same = dish[row].substring(i + 1, i + 2); 
      // no one below if on the bottom row 
      // otherwise grab the neighbors from below 
      below = (row == dish.length - 1) ? null : dish[row + 1].substring(i, i + 2); 
     }else if(i == dish[row].length() - 1){//right 
      // no one above if on the top row 
      // otherwise grab the neighbors from above 
      above = (row == 0) ? null : dish[row - 1].substring(i - 1, i + 1); 
      same = dish[row].substring(i - 1, i); 
      // no one below if on the bottom row 
      // otherwise grab the neighbors from below 
      below = (row == dish.length - 1) ? null : dish[row + 1].substring(i - 1, i + 1); 
     }else{ // anywhere else 
      // no one above if on the top row 
      //otherwise grab the neighbors from above 
      above = (row == 0) ? null : dish[row - 1].substring(i - 1, i + 2); 
      same = dish[row].substring(i - 1, i) + dish[row].substring(i + 1, i + 2); 
      //no one below if on the bottom row 
      //otherwise grab the neighbors from below 
      below = (row == dish.length - 1) ? null : dish[row + 1].substring(i - 1, i + 2); 
     } 

     // here is the interesting part for you: 
     int neighbors = 0; 
     if(above != null){//no one above 
      for(char x: above.toCharArray()){ //each neighbor from above 
      if(x == 'x') neighbors++; //count it if someone is here 
      } 
     } 
     for(char x: same.toCharArray()){ //two on either side 
      if(x == 'x') neighbors++;//count it if someone is here 
     } 
     if(below != null){ //no one below 
      for(char x: below.toCharArray()){//each neighbor below 
      if(x == 'x') neighbors++;//count it if someone is here 
      } 
     }; 
     //here ends the interesting part for you 
     if(neighbors < 2 || neighbors > 3){ 
      newGen[row]+= "o"; // If the amount of neighbors is < 2 or >3 neighbors -> they die 
     }else if(neighbors == 3){ 
      newGen[row]+= "x"; // If the amount of neighbors is exactly 3 neighbors -> they spawn/live 
     }else{ 
      newGen[row]+= dish[row].charAt(i); // 2 neighbors -> stay 
     } 
    } 
} 

return newGen; 

}