Java - Làm thế nào để giải quyết kính 2D Array Hour này?

Question

Tôi đang làm việc trên một vấn đề mà tôi đã in số tiền lớn nhất trong số tất cả các đồng hồ cát trong mảng. Bạn có thể tìm thấy những thông tin chi tiết về vấn đề này here-

gì tôi đã cố gắng:

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); 
    } 
} 

Input:

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 

Output:

12 

Output dự kiến:

13 

Ảnh chụp màn hình:

Tôi không biết nơi tôi đang làm sai. Tôi không thể hiểu tại sao sản lượng dự kiến ​​là 13. Theo mô tả được đưa ra trong bài toán, nó phải là 10. Đây có phải là một câu hỏi sai hoặc sự hiểu biết của tôi về điều này là sai?

Answer 1

Xóa câu lệnh if (arr[arr_i][arr_j] > 0). Nó ngăn không cho tìm câu trả lời ở hàng 1, cột 0, bởi vì ô đó là 0.

Bình luận cho cải tiến khác để mã của bạn:

• gì nếu tổng đồng hồ cát tốt nhất là -4? Bạn nên khởi tạo tmp_sum thành Integer.MIN_VALUE. Và đặt tên nó là maxSum, để mô tả tốt hơn mục đích của nó.

• Bạn không nên xác định sum ngoài vòng lặp. Khai báo nó khi nó được gán lần đầu tiên, sau đó bạn không phải đặt lại nó thành 0 sau đó.

• Trình lặp của bạn phải là i và j. Đó là những tên chuẩn cho các vòng lặp nguyên, và giữ mã ... sạch hơn.
  Nếu bạn thích tên dài hơn, hãy sử dụng row và col, vì đó là những gì chúng đại diện.

• Bạn không cần dấu ngoặc đơn xung quanh tra cứu mảng.

• Để rõ ràng, tôi đã định dạng mã bên dưới để hiển thị hình dạng đồng hồ cát trong tra cứu mảng.

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

Ở đây bạn đi ..

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

Đây là giải pháp của tôi. Tôi đã bọc một câu lệnh if xung quanh mã để tính toán số tiền, điều đó đảm bảo chúng ta không vượt quá giới hạn.

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

Đây là mã C# tương đương đơn giản và dễ hiểu cho vấn đề đồng hồ cát của bạn.

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()); 

    } 
} 

Mã hóa hạnh phúc. Cảm ơn, Ankit Bajpai

Answer 6

Bạn có thể thử mã này:
Tôi nghĩ rằng đây sẽ là dễ hiểu cho người mới bắt đầu.

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

Dưới đây là một lựa chọn dễ dàng, hy vọng nó sẽ giúp:

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

có một opetion trong trường hợp - (trừ) và không ra chúng ta có thể sử dụng dịch ngắn mạch TreeSet cho cùng. bên dưới là mã sameple

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

Được giải quyết bằng PHP, có thể hữu ích.

<?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

Passes all trường hợp thử nghiệm

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; 
} 
}