Java - Wie löst man dieses 2D-Array-Stundenglas?

Question

Ich arbeite an einem Problem, wo ich die größte Summe unter allen Sanduhren im Array drucken muss. Sie können die Details über das Problem here-

finden, was ich versucht:

public class Solution { 
    public static void main(String[] args) { 
     Scanner in = new Scanner(System.in); 
     int arr[][] = new int[6][6]; 
     for (int arr_i = 0; arr_i < 6; arr_i++) { 
      for (int arr_j = 0; arr_j < 6; arr_j++) { 
       arr[arr_i][arr_j] = in.nextInt(); 
      } 
     } 

     int sum = 0; 
     int tmp_sum = 0; 
     for (int arr_i = 0; arr_i < 4; arr_i++) { 
      for (int arr_j = 0; arr_j < 4; arr_j++) { 
       if (arr[arr_i][arr_j] > 0) { 
        sum = sum + (arr[arr_i][arr_j]) + (arr[arr_i][arr_j + 1]) + (arr[arr_i][arr_j + 2]); 
        sum = sum + (arr[arr_i + 1][arr_j + 1]); 
        sum = sum + (arr[arr_i + 2][arr_j]) + (arr[arr_i + 2][arr_j + 1]) + (arr[arr_i + 2][arr_j + 2]); 
        if (tmp_sum < sum) { 
         tmp_sum = sum; 
        } 
        sum = 0; 
       } 
      } 
     } 
     System.out.println(tmp_sum); 
    } 
} 

Eingang:

1 1 1 0 0 0 
0 1 0 0 0 0 
1 1 1 0 0 0 
0 9 2 -4 -4 0 
0 0 0 -2 0 0 
0 0 -1 -2 -4 0 

Ausgang:

12 

Erwartete Ausgabe:

13 

Screenshot:

Ich weiß nicht, wo ich falsch mache. Ich kann nicht verstehen, warum die erwartete Ausgabe 13 ist. Laut der Beschreibung in dem Problem sollte es 10 sein. Ist das eine falsche Frage oder ist mein Verständnis falsch?

Answer 1

Entfernen Sie die if (arr[arr_i][arr_j] > 0) Anweisung. Es verhindert, die Antwort in Zeile 1, Spalte 0 zu finden, da diese Zelle 0 ist.

Kommentare für weitere Verbesserungen, um Ihren Code:

• Was passiert, wenn die beste Summe Sanduhr ist -4? Sie sollten tmp_sum zu Integer.MIN_VALUE initialisieren. Und nennen Sie es maxSum, um seinen Zweck besser zu beschreiben.

• Sie sollten sum nicht außerhalb der Schleife definieren. Deklarieren Sie es, wenn es zum ersten Mal zugewiesen wird, und Sie es anschließend nicht auf 0 zurücksetzen müssen.

• Ihre Iteratoren sollten nur i und j sein. Dies sind Standardnamen für Ganzzahl-Iteratoren und halten den Code sauberer.
  Wenn Sie längere Namen bevorzugen, verwenden Sie row und col, da das ist, was sie darstellen.

• Sie benötigen keine Klammern um die Array-Lookups.

• Aus Gründen der Übersichtlichkeit habe ich den folgenden Code formatiert, um die Sanduhrform in den Array-Lookups anzuzeigen.

Scanner in = new Scanner(System.in); 
int arr[][] = new int[6][6]; 
for (int i = 0; i < 6; i++){ 
    for (int j = 0; j < 6; j++){ 
     arr[i][j] = in.nextInt(); 
    } 
} 

int maxSum = Integer.MIN_VALUE; 
for (int i = 0; i < 4; i++) { 
    for (int j = 0; j < 4; j++) { 
     int sum = arr[i ][j] + arr[i ][j + 1] + arr[i ][j + 2] 
           + arr[i + 1][j + 1] 
       + arr[i + 2][j] + arr[i + 2][j + 1] + arr[i + 2][j + 2]; 
     if (maxSum < sum) { 
      maxSum = sum; 
     } 
    } 
} 
System.out.println(maxSum); 

Answer 2

import java.io.*; 
import java.util.Scanner; 

public class Solution { 

    public static void main(String[] args) { 
     Scanner in = new Scanner(System.in); 
     int low = -9,high = 5; 
     int lh = low * high; 
     int sum = 0, i, j; 
     int max = 0; 
     int a[][] = new int[6][6]; 
     for (i = 0; i < 6; i++) { 
      for (j = 0; j < 6; j++) { 
       a[i][j] = in.nextInt(); 
      } 
     } 

     for (i = 0; i < 4; i++) { 
      for (j = 0; j < 4; j++) { 
       sum = (a[i][j] + a[i][j+1] + a[i][j+2]); 
       sum = sum + a[i+1][j+1]; 
       sum = sum + (a[i+2][j] + a[i+2][j+1] + a[i+2][j+2]); 

       if (sum > lh) lh = sum; 
      } 
     } 
     System.out.print(lh); 
    } 
} 

Answer 3

Hier gehen Sie ..

public static void main(String[] args) { 
    Scanner in = new Scanner(System.in); 
    int a[][] = new int[6][6]; 
    int max = 0; 
    for (int i = 0; i < 6; i++) { 
     for (int j = 0; j < 6; j++) { 
      a[i][j] = in.nextInt(); 
     } 
    } 
    for (int i = 0; i < 4; i++) { 
     for (int j = 0; j < 4; j++) { 
      int sum = a[i][j] + a[i][j + 1] + a[i][j + 2] + a[i + 1][j + 1] 
        + a[i + 2][j] + a[i + 2][j + 1] + a[i + 2][j + 2]; 
      if (sum > max || (i == 0 && j == 0)) { 
       max = sum; 
      } 
     } 
    } 
    System.out.println(max); 
} 

Answer 4

Dies war meine Lösung. Ich habe eine if-Anweisung um den Code gewickelt, der die Summe berechnet, die sicherstellt, dass wir nicht außerhalb der Grenzen bleiben.

public static void main(String[] args) { 
    Scanner in = new Scanner(System.in); 
    int arr[][] = new int[6][6]; 
    int max = Integer.MIN_VALUE; 
    int tempMax = 0; 

    for(int i=0; i < 6; i++){ 
     for(int j=0; j < 6; j++){ 
      arr[i][j] = in.nextInt(); 
     } 
    } 

    for(int i=0; i < 6; i++){ 
     for(int j=0; j < 6; j++){ 
      if (i + 2 < 6 && j + 2 < 6) { 
       tempMax += arr[i][j] + arr[i][j + 1] + arr[i][j + 2]; 
       tempMax += arr[i + 1][j + 1]; 
       tempMax += arr[i + 2][j] + arr[i + 2][j + 1] + arr[i + 2][j + 2]; 

       if (max < tempMax) { 
        max = tempMax; 
       } 

       tempMax = 0; 
      }   
     } 
    } 

    System.out.println(max); 
} 

Answer 5

Hier ist der einfache und leicht verständliche C# äquivalente Code für Ihr Sanduhrproblem.

class Class1 
{ 
    static int[][] CreateHourGlassForIndex(int p, int q, int[][] arr) 
    { 
     int[][] hourGlass = new int[3][]; 

     int x = 0, y = 0; 
     for (int i = p; i <= p + 2; i++) 
     { 
      hourGlass[x] = new int[3]; 
      int[] temp = new int[3]; 
      int k = 0; 
      for (int j = q; j <= q + 2; j++) 
      { 
       temp[k] = arr[i][j]; 
       k++; 
      } 
      hourGlass[x] = temp; 
      x++; 
     } 

     return hourGlass; 
    } 

    static int findSumOfEachHourGlass(int[][] arr) 
    { 
     int sum = 0; 
     for (int i = 0; i < arr.Length; i++) 
     { 
      for (int j = 0; j < arr.Length; j++) 
      { 
       if (!((i == 1 && j == 0) || (i == 1 && j == 2))) 
        sum += arr[i][j]; 
      } 

     } 

     return sum; 
    } 

    static void Main(string[] args) 
    { 
     int[][] arr = new int[6][]; 
     for (int arr_i = 0; arr_i < 6; arr_i++) 
     { 
      string[] arr_temp = Console.ReadLine().Split(' '); 
      arr[arr_i] = Array.ConvertAll(arr_temp, Int32.Parse); 
     } 

     int[] sum = new int[16]; 
     int k = 0; 
     for (int i = 0; i < 4; i++) 
     { 
      for (int j = 0; j < 4; j++) 
      { 
       int[][] hourGlass = CreateHourGlassForIndex(i, j, arr); 
       sum[k] = findSumOfEachHourGlass(hourGlass); 
       k++; 
      } 
     } 
     //max in sum array 
     Console.WriteLine(sum.Max()); 

    } 
} 

Glückliche Kodierung. Danke, Ankit Bajpai

Answer 6

Sie diesen Code versuchen:
Ich denke, das einfach für Anfänger zu verstehen.

public class Solution { 
    public static void main(String[] args) { 
     Scanner in = new Scanner(System.in); 
     int arr[][] = new int[6][6]; 
     for(int arr_i=0; arr_i < 6; arr_i++){ 
      for(int arr_j=0; arr_j < 6; arr_j++){ 
       arr[arr_i][arr_j] = in.nextInt(); 
      } 
     } 
     int sum = 0; 
     int sum2 = 0; 
     int sum3 = 0; 
     int x = 0; 
     int max = Integer.MIN_VALUE; 
     for(int i = 0; i < 4; i++){ 
      for(int j = 0; j < 4; j++){ 
       for(int k = 0; k < 3; k++){ 
        sum += arr[i][j+k]; //top elements of hour glass 
        sum2 += arr[i+2][j+k]; //bottom elements of hour glass 
        sum3 = arr[i+1][j+1]; //middle elements of hour glass 
        x = sum + sum2 + sum3; //add all elements of hour glass 
       } 
       if(max < x){ 
        max = x; 
       } 
       sum = 0; 
       sum2 = 0; 
       sum3 = 0; 
       x = 0; 
      }    
     } 
     System.out.println(max); 
    } 
} 

Answer 7

Hier ist eine weitere einfache Möglichkeit ist, hoffe, es hilft:

import java.io.*; 
import java.util.*; 
import java.text.*; 
import java.math.*; 
import java.util.regex.*; 

public class Solution { 

    public static void main(String[] args) { 
     Scanner in = new Scanner(System.in); 
     int a[][] = new int[6][6]; 
     for(int i=0; i < 6; i++){ 
      for(int j=0; j < 6; j++){ 
       a[i][j] = in.nextInt(); 
      } 
     } 
     int hg = Integer.MIN_VALUE, sum; 
     for(int i=0; i<4; i++){ 
      for(int j=0; j<4; j++){ 
       sum = 0; 
       sum = sum + a[i][j] + a[i][j+1] + a[i][j+2]; 
       sum = sum + a[i+1][j+1]; 
       sum = sum + a[i+2][j] + a[i+2][j+1] + a[i+2][j+2]; 
       if(sum>hg) 
        hg = sum; 
      } 
     } 
     System.out.println(hg); 
     in.close(); 
    } 
} 

Answer 8

es eine andere opetion bei ist - (minus) und Null-Ausgang wir kurzgeschlossenen ser TreeSet für die gleiche verwenden können. Unten ist der gleiche Code

public class Solution { 

    public static void main(String[] args) { 
     Scanner in = new Scanner(System.in); 
     int arr[][] = new int[6][6]; 

     for(int i=0; i < 6; i++){ 
      for(int j=0; j < 6; j++){ 
       arr[i][j] = in.nextInt(); 
      } 
     } 

     int sum=0;int output=0; 
     Set<Integer> set=new TreeSet<Integer>(); 

     for(int k=0;k<4;k++) 
     { 
      for(int y=0;y<4;y++) 
      { 
       sum=arr[k][y]+arr[k][y+1]+arr[k][y+2]+arr[k+1][y+1]+arr[k+2][y]+arr[k+2][y+1]+arr[k+2][y+2];           set.add(sum); 
      } 
     } 

     int p=0; 

     for(int u:set) 
     { 
      p++; 
      if(p==set.size()) 
      output=u; 
     } 

     System.out.println(output); 
    } 
} 

Answer 9

Gelöst in PHP, kann hilfreich sein.

<?php 

$handle = fopen ("php://stdin","r"); 
$input = []; 

while(!feof($handle)) 
{ 
    $temp = fgets($handle); 
    $input[] = explode(" ",$temp); 
} 

$maxSum = PHP_INT_MIN; 
for($i=0; $i<4; $i++) 
{ 
    for($j=0; $j<4; $j++) 
    { 
     $sum = $input[$i][$j] + $input[$i][$j + 1] + $input[$i][$j + 2] 
            + $input[$i + 1][$j + 1] + 
        $input[$i + 2][$j] + $input[$i + 2][$j + 1] + $input[$i + 2][$j + 2]; 

     if($sum > $maxSum) 
     { 
      $maxSum = $sum; 
     } 
    } 
} 
echo $maxSum; 

?> 

Answer 10

Pässe alle Testfälle

import java.io.*; 
import java.util.*; 

public class Solution { 

public static void main(String[] args) { 
    Scanner read = new Scanner(System.in); 
    int rowSize = 6; 
    int colSize = 6; 
    int[][] array = new int[rowSize][colSize]; 
    for(int row = 0; row < rowSize; row++) { 
     for(int col = 0; col < colSize; col++) { 
      array[row][col] = read.nextInt(); 
     } 
    } 
    read.close(); 
    int max = Integer.MIN_VALUE; 
    for(int row = 0; row < 4; row++) { 
     for(int col = 0; col < 4; col++) { 
      int sum = calculateHourglassSum(array, row, col); 
      if(sum > max) { 
       max = sum; 
      } 
     } 
    } 
    System.out.println(max); 
} 

private static int calculateHourglassSum(int[][] array, int rowIndex, int colIndex) { 
    int sum = 0; 
    for(int row = rowIndex; row < rowIndex + 3; row++) { 
     for(int col = colIndex; col < colIndex + 3; col++) { 
      if(row == rowIndex + 1 && col != colIndex + 1) { 
       continue; 
      } 
      sum += array[row][col]; 
     } 
    } 
    return sum; 
} 
}