thảo luận Leetcode mỗi ngày

  • Người tạo chủ đề Người tạo chủ đề _Gia_Cat_Luong_
  • Ngày bắt đầu Ngày bắt đầu
Trạng thái
Không mở để trả lời thêm.
Brute force cho nó tam giác, mất công nghĩ nhiều làm gì :ah:
JavaScript: 
function numMagicSquaresInside(grid: number[][]): number {
    const isMagic = (grid, x, y) => {
        const digits = new Array(10).fill(0);
        for (let i = 0; i < 3; i++) {
            for (let j = 0; j < 3; j++) {
                const num = grid[x + i][y + j];
                if (num < 1 || num > 9 || digits[num]) {
                    return false;
                }
                digits[num] = 1;
            }
        }

        return (grid[x][y] + grid[x][y + 1] + grid[x][y + 2] === 15 &&
                grid[x + 1][y] + grid[x + 1][y + 1] + grid[x + 1][y + 2] === 15 &&
                grid[x + 2][y] + grid[x + 2][y + 1] + grid[x + 2][y + 2] === 15 &&
                grid[x][y] + grid[x + 1][y] + grid[x + 2][y] === 15 &&
                grid[x][y + 1] + grid[x + 1][y + 1] + grid[x + 2][y + 1] === 15 &&
                grid[x][y + 2] + grid[x + 1][y + 2] + grid[x + 2][y + 2] === 15 &&
                grid[x][y] + grid[x + 1][y + 1] + grid[x + 2][y + 2] === 15 &&
                grid[x][y + 2] + grid[x + 1][y + 1] + grid[x + 2][y] === 15);
    };

    let count = 0;
    for (let i = 0; i < grid.length - 2; i++) {
        for (let j = 0; j < grid[0].length - 2; j++) {
            if (isMagic(grid, i, j)) {
                count++;
            }
        }
    }
    return count;
};
 
Code xong thấy mình đần hơn hẳn
Python: 
class Solution:
    def numMagicSquaresInside(self, grid: List[List[int]]) -> int:
        ans = 0
        for x in range(len(grid) - 2):
            for y in range(len(grid[x]) - 2):
                isMagic = True
                prev_sum = sum(grid[x][y:y+3])
                for i in range(1,3):
                    row_sum = sum(grid[x+i][y:y+3])
                    if row_sum != prev_sum:
                        isMagic = False
                        break
                for i in range(3):
                    col_sum = sum([grid[x+j][y+i] for j in range(3)])
                    if col_sum != prev_sum:
                        isMagic = False
                        break
                diagons = [[grid[x+i][y+i] for i in range(3)],[grid[x+j][y+2-j] for j in range(3)]]
                for d in diagons:
                    if sum(d) != prev_sum:
                        isMagic = False
                        break
                if isMagic:
                    square = []
                    for i in range(3):
                        for j in range(3):
                            square.append(grid[x+i][y+j])
                    if all(num in square for num in range(1, 10)):
                        ans += 1
                            
        return ans
 
Java: 
class Solution {
    public int numMagicSquaresInside(int[][] grid) {
        int rows = grid.length;
        int cols = grid[0].length;
        int cnt = 0;
        for (int i = 0; i <= rows - 3; i++) {
            for (int j = 0; j <= cols - 3; j++) {
                if (isMagicSquare(grid, i, j))
                    cnt++;
            }
        }
        return cnt;
    }

    public boolean isMagicSquare(int [][] grid, int rStart, int cStart){
        Set<Integer> set = new HashSet<>();
        int mainDiagonal =0;
        int secDiagonal =0;
        for(int i = 0;i<3;i++){
            int sumRow =0;
            int sumCol =0;
            for(int j =0 ; j<3;j++){
                int num = grid[rStart+i][cStart+j];
                if(num >9 || num <1) return false;
                set.add(num);
                sumRow+= num;
                sumCol += grid[rStart+j][cStart+i];
            }
            if(sumRow != 15 || sumCol !=15) return false;
            mainDiagonal += grid[rStart+i][cStart+i];
            secDiagonal += grid[rStart+i][cStart+2-i];
        }
        return set.size()==9 && mainDiagonal ==15 &&  secDiagonal==15;
    }

}
 
Mã: 
func hashGrid(grid [][]int, R int, C int) int64{
    var hash int64
    var k int64
    k = 1
    for c := 0; c < 3; c++ {
        for r := 0; r < 3; r++ {
            hash = hash + int64(grid[R+r][C+c])*k
            k = k*10
        }
    }
    return hash
}

func numMagicSquaresInside(grid [][]int) int {
    cols := len(grid[0])
    rows := len(grid)
    if cols < 3 || rows < 3 {
        return 0
    }
    hash_map := map[int64]int{
        816357492: 1,
        294753618: 1,
        834159672: 1,
        276951438: 1,
        438951276: 1,
        672159834: 1,
        492357816: 1,
        618753294: 1,
    }
    count := 0
    for c := 0; c < cols-2; c++ {
        for r := 0; r < rows-2; r++ {
            hash := hashGrid(grid, r, c)
            if _, exist := hash_map[hash]; exist {
                count++
            }
        }
    }
    return count
}
 
JavaScript: 
var numMagicSquaresInside = function(grid) {
    const ROWS = grid.length;
    const COLS = grid[0].length;

    if (ROWS < 3 || COLS < 3) return 0;

    const check = (r, c) => {
        const nums = new Set();
        const rowSum = Array(3).fill(0);
        const colSum = Array(3).fill(0);
        let [dSum, rSum] = [0, 0];
        for (let i = 0; i < 3; i++) {
            for (let j = 0; j < 3; j++) {
                const nr = r + i;
                const nc = c + j;
                if (grid[nr][nc] < 1 || grid[nr][nc] > 9) return false;
                rowSum[i] += grid[nr][nc];
                colSum[j] += grid[nr][nc];
                nums.add(grid[nr][nc]);
            }
            dSum += grid[r + i][c + i];
            rSum += grid[r + i][c + 2 - i];
        }

        for (let i = 1; i < 3; i++) {
            if (rowSum[i] != rowSum[i-1] || colSum[i] != colSum[i-1]) return false;
        }

        if (nums.size !== 9 || dSum != rSum) return false;
        return true;
    }

    let ans = 0;
    for (let r = 0; r < ROWS - 2; r++) {
        for (let c = 0; c < COLS - 2; c++) {
            if (check(r, c)) ans++;
        }
    }
    return ans;
};
 
Mã: 
class Solution:
    def numMagicSquaresInside(self, grid: List[List[int]]) -> int:
        m , n = len(grid),len(grid[0])
        def checkMagicSquare(i , j):
            if not (i + 2 < m and j + 2 < n and j + 2 < m and i + 2 < n): return False
            row , col , d1 , d2 = 0 , 0 , 0 , 0
            vis = set()
            for k in range(i , i + 3):
                rowSum = 0
                for h in range(j , j + 3):
                    if grid[k][h] == 0 or grid[k][h] > 10: return False
                    vis.add(grid[k][h])
                    rowSum += grid[k][h]
                if rowSum != 15: return False
            
            for k in range(j , j + 3):
                colSum = 0
                for h in range(i , i + 3):
                    colSum += grid[h][k]
                
                if colSum != 15: return False

            for k in range(0 , 3):
                d1 += grid[k + i][k + j]
                d2 += grid[k + i][j + 2 - k]
            
            if len(vis) != 9: return False
            return d1 == d2
        cnt = 0
        for i in range(m - 2):
            for j in range(n - 2):
                if checkMagicSquare(i , j): cnt += 1
        
        return cnt
cứ vào matrix là rối vcl
HR4W6DU.png
 
Python: 
class Solution:
    def numMagicSquaresInside(self, grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])
        ans = 0
        def is_valid(r, c) -> bool:
            expected = grid[r][c] + grid[r + 1][c + 1] + grid[r + 2][c + 2]
            if grid[r][c + 2] + grid[r + 1][c + 1] + grid[r + 2][c] != expected:
                return False
            # check rows:
            for i in range(3):
                if grid[r + i][c] + grid[r + i][c + 1] + grid[r + i][c + 2] == expected and grid[r + i][c] != grid[r + i][c + 1] != grid[r + i][c + 2] and 1<=  grid[r + i][c] <= 9 and 1<=  grid[r + i][c + 1] <= 9 and 1<=  grid[r + i][c + 2] <= 9 :
                    continue
                else:
                    return False
            # check cols:
            for i in range(3):
                if grid[r][c + i] + grid[r + 1][c + i] + grid[r + 2][c + i] != expected:
                    return False
            return True
        for i in range(m - 2):
            for j in range(n - 2):
                if grid[i+1][j+1] == 5:
                    ans += is_valid(i, j)
       
        return ans
 
freedom.9 đã nói:
Python: 
class Solution:
    def numMagicSquaresInside(self, grid: List[List[int]]) -> int:
            return len(tracker) == 9 and rows[0] == rows[1] == rows[2] == cols[0] == cols[1] == cols[2] == diagonal == antiDiagonal
Nhấp để mở rộng...
Thử dùng bit manipulation cho đoạn này xem, :beauty:
Bài này cứ vét máng mà chơi thôi ae. Thêm tí bit manipulation cho nó nguy hiểm, :doubt:
C++: 
class Solution {
public:
    int numMagicSquaresInside(vector<vector<int>>& grid) {
        auto IsMagicSquare = [&grid] (int i, int j) {
            array<int, 3> sumRows = {0}, sumCols = {0};
            int diag1 = 0, diag2 = 0;
            int bit_mask = 0;
            for (int x = 0; x < 3; ++x) {
                for (int y = 0; y < 3; ++y) {
                    int val = grid[i + x][j + y];
                    if (val < 1 || val > 9) continue;
                    bit_mask |= 1 << (val - 1);
                  
                    sumRows[x] += val;
                    sumCols[y] += val;
                }
                diag1 += grid[i+x][j+x];
                diag2 += grid[i+2-x][j+x];
            }
          
            if (bit_mask != 0x1FF) {
                return false; 
            }
          
            bit_mask = (1 << diag1 ) | (1 << diag2);
            for (auto x : sumRows) bit_mask |= (1 << x);
            for (auto x : sumCols) bit_mask |= (1 << x);
            if ((bit_mask & (bit_mask - 1)) != 0) return false;
            return true;
        };
      
        int ret = 0;
        for (int i = 0; i + 2 < grid.size(); ++i) {
            for (int j = 0; j + 2 < grid[0].size(); ++j) {
                ret += IsMagicSquare(i, j);
            }
        }
      
        return ret;
    }
};
 
C++: 
class Solution {
public:
    vector<vector<int>> get3x3(vector<vector<int>> a, int row, int col) {
        vector<vector<int>> ans(3, vector<int> (3));
        for(int i = row; i < row + 3; i++) {
            for(int j = col; j < col + 3; j++) {
                ans[i - row][j - col] = a[i][j];
            }
        }
        return ans;
    }
    bool valid(vector<vector<int>> a) {
        set<int> st;
        vector<int> v(9, 0);
        for(int i = 0; i < 3; i++) {
            int sum = 0;
            for(int j = 0; j < 3; j++) {
                sum += a[i][j];
                if(a[i][j] == 0 || a[i][j] > 9) {
                    return false;
                }
                v[a[i][j] - 1]++;
                if(v[a[i][j] - 1] > 1) {
                    return false;
                }
            }
            st.insert(sum);
        }
        for(int j = 0; j < 3; j++) {
            int sum = 0;
            for(int i = 0; i < 3; i++) {
                sum += a[i][j];
            }
            st.insert(sum);
        }
        st.insert(a[0][0] + a[1][1] + a[2][2]);
        st.insert(a[2][0] + a[1][1] + a[0][2]);
        return st.size() == 1;
    }
    int numMagicSquaresInside(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size(), ans = 0;
        if(n < 3 || m < 3)  return 0;
        for(int i = 0; i < n - 2; i++) {
            for(int j = 0; j < m - 2; j++) {
                vector<vector<int>> v = get3x3(grid, i, j);
                ans += valid(v);
            }
        }
        return ans;
    }
};
 
Giải hệ phương trình thì thấy 5 chắc chắn phải ở giữa. Thêm 1 vài chứng minh thì thấy chỉ có 2 ma trận thỏa mãn (và các ma trận xoay từ nó). Không biết cách này có nhanh hơn Brute-Force check sum không :burn_joss_stick: vì nó cũng là Brute-Force kiểu khác thôi.
Java: 
class Solution {
    private void rotate(int[][] grid, int time)
    {
        int m = grid.length;
        int n = grid[0].length;
        for (int k = 0; k < time; k++)
        {
            for (int i = 0; i < m - 1; i++)
                for (int j = i + 1; j < n; j++)
                {
                    int temp = grid[i][j];
                    grid[i][j] = grid[j][i];
                    grid[j][i] = temp;
                }
           
            for (int i = 0; i < m; i++)
                for (int j = 0; j < n / 2; j++)
                {
                    int temp = grid[i][j];
                    grid[i][j] = grid[i][n - 1 - j];
                    grid[i][n - 1 - j] = temp;
                }
        }
    }
   
    private boolean isEqual(int[][] m1, int [][] m2)
    {
        int m = m1.length;
        int n = m1[0].length;
        if (m != m2.length || n != m2[0].length)
            return false;
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                if (m1[i][j] != m2[i][j])
                    return false;
        return true;
    }
   
    public int numMagicSquaresInside(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        if (m < 3 || n < 3)
            return 0;
        int count = 0;
        int[][] m1 = {{2,9,4},{7,5,3},{6,1,8}};
        int[][] m2 = {{2,7,6},{9,5,1},{4,3,8}};
   
        for (int i = 1; i < m - 1; i++)
            for (int j = 1; j < n - 1; j++)
            {
                if (grid[i][j] != 5)
                    continue;
                int[][] cur = new int[3][];
                for (int k = 0; k < 3; k++)
                    cur[k] = Arrays.copyOfRange(grid[i - 1 + k], j - 1, j + 2);
               
                for (int time = 0; time < 4; time++)
                {
                    if (isEqual(m1, cur) || isEqual(m2, cur))
                    {
                        count++;
                        j++;
                        break;
                    }
                    rotate(cur, 1);
                }
            }
        return count;
    }
}
 
Someone... đã nói:
Giải hệ phương trình thì thấy 5 chắc chắn phải ở giữa. Thêm 1 vài chứng minh thì thấy chỉ có 2 ma trận thỏa mãn (và các ma trận xoay từ nó). Không biết cách này có nhanh hơn Brute-Force check sum không :burn_joss_stick: vì nó cũng là Brute-Force kiểu khác thôi.
Java: 
class Solution {
    private void rotate(int[][] grid, int time)
    {
        int m = grid.length;
        int n = grid[0].length;
        for (int k = 0; k < time; k++)
        {
            for (int i = 0; i < m - 1; i++)
                for (int j = i + 1; j < n; j++)
                {
                    int temp = grid[i][j];
                    grid[i][j] = grid[j][i];
                    grid[j][i] = temp;
                }
          
            for (int i = 0; i < m; i++)
                for (int j = 0; j < n / 2; j++)
                {
                    int temp = grid[i][j];
                    grid[i][j] = grid[i][n - 1 - j];
                    grid[i][n - 1 - j] = temp;
                }
        }
    }
  
    private boolean isEqual(int[][] m1, int [][] m2)
    {
        int m = m1.length;
        int n = m1[0].length;
        if (m != m2.length || n != m2[0].length)
            return false;
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                if (m1[i][j] != m2[i][j])
                    return false;
        return true;
    }
  
    public int numMagicSquaresInside(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        if (m < 3 || n < 3)
            return 0;
        int count = 0;
        int[][] m1 = {{2,9,4},{7,5,3},{6,1,8}};
        int[][] m2 = {{2,7,6},{9,5,1},{4,3,8}};
  
        for (int i = 1; i < m - 1; i++)
            for (int j = 1; j < n - 1; j++)
            {
                if (grid[i][j] != 5)
                    continue;
                int[][] cur = new int[3][];
                for (int k = 0; k < 3; k++)
                    cur[k] = Arrays.copyOfRange(grid[i - 1 + k], j - 1, j + 2);
              
                for (int time = 0; time < 4; time++)
                {
                    if (isEqual(m1, cur) || isEqual(m2, cur))
                    {
                        count++;
                        j++;
                        break;
                    }
                    rotate(cur, 1);
                }
            }
        return count;
    }
}
Nhấp để mở rộng...
giả sử nó tìm ma phương bậc 4 trở lên thì code này phải tìm thủ công các ma trận thoả mãn lại
 
Matrix dùng python cho tiện, Java với scala hơi khổ dâm
Python: 
import numpy as np

class Solution:
    def generate_magic_squares(self):
        base_magic_square = [
            [4, 9, 2],
            [3, 5, 7],
            [8, 1, 6]
        ]
       
        magic_squares = set()
       
        def add_variations(square):
            square_np = np.array(square)
            for _ in range(4):
                square_np = np.rot90(square_np)
                magic_squares.add(tuple(map(tuple, square_np)))
                magic_squares.add(tuple(map(tuple, np.fliplr(square_np))))
       
        add_variations(base_magic_square)
       
        return magic_squares

    def numMagicSquaresInside(self, grid: List[List[int]]) -> int:
        rows = len(grid)
        cols = len(grid[0])
        count = 0
        magic_squares = self.generate_magic_squares()
       
        for i in range(rows - 2):
            for j in range(cols - 2):
                subgrid = tuple(tuple(grid[i + x][j:j + 3]) for x in range(3))
                if subgrid in magic_squares:
                    count += 1
       
        return count
 
lâu lâu lôi cái sat solver ra xài để check hết matrix thỏa mãn

Python: 
from z3 import *
import numpy as np

solver = Solver()

variables = [Int(ch) for ch in range(ord('a'), ord('j'))]
[a, b, c, d, e, f, g, h, i] = variables

# row sums
solver.add(a + b + c == 15)
solver.add(d + e + f == 15)
solver.add(g + h + i == 15)

# column sums
solver.add(a + d + g == 15)
solver.add(b + e + h == 15)
solver.add(c + f + i == 15)

# diagonal sums
solver.add(c + e + g == 15)
solver.add(a + e + i == 15)

solver.add(Distinct([a, b, c, d, e, f, g, h, i]))

for variable in variables:
    solver.add(And(variable >= 1, variable <= 9))

while solver.check() == sat:
    model = solver.model()

    vals = [val for val in map(lambda variable: model.evaluate(variable).as_long(), variables)]

    [a, b, c, d, e, f, g, h, i] = vals

    square = np.matrix([
        [a, b, c],
        [d, e, f],
        [g, h, i]
    ])

    print(square, "\n")

    solver.add(Or([sym() != model[sym] for sym in model.decls()]))
 
Sửa lần cuối:
Java: 
class Solution {
    public int numMagicSquaresInside(int[][] grid) {
        int count = 0;
        for(int i = 0;i<grid.length-2;i++)
            for(int j = 0;j<grid[0].length-2;j++)
                if(isMagic(grid,i,j))   
                    count++;
            
        return count;
    }

    public boolean isMagic(int[][] grid, int col, int row){
        Set<Integer> set = new HashSet();
        for(int i = col; i<col+3;i++){
            int sum = 0;
            for(int j = row; j<row+3;j++){
                if(grid[i][j]<1 || grid[i][j]>9) return false;
                if(set.contains(grid[i][j])) return false;
                sum+=grid[i][j];
                set.add(grid[i][j]);
            }
            if (sum!= 15) return false;
        }

        for(int i = row; i<row+3;i++){
            int sum = 0;
            for(int j = col; j<col+3;j++)
                sum+=grid[j][i];
            if (sum!= 15) return false;
        }

        if(grid[col][row]+grid[col+1][row+1]+grid[col+2][row+2] != 15) return false;
        if(grid[col][row+2]+grid[col+1][row+1]+grid[col+2][row] != 15) return false;
        return true;
    }

}
 
Someone... đã nói:
Giải hệ phương trình thì thấy 5 chắc chắn phải ở giữa. Thêm 1 vài chứng minh thì thấy chỉ có 2 ma trận thỏa mãn (và các ma trận xoay từ nó). Không biết cách này có nhanh hơn Brute-Force check sum không :burn_joss_stick: vì nó cũng là Brute-Force kiểu khác thôi.
Java: 
class Solution {
    private void rotate(int[][] grid, int time)
    {
        int m = grid.length;
        int n = grid[0].length;
        for (int k = 0; k < time; k++)
        {
            for (int i = 0; i < m - 1; i++)
                for (int j = i + 1; j < n; j++)
                {
                    int temp = grid[i][j];
                    grid[i][j] = grid[j][i];
                    grid[j][i] = temp;
                }
          
            for (int i = 0; i < m; i++)
                for (int j = 0; j < n / 2; j++)
                {
                    int temp = grid[i][j];
                    grid[i][j] = grid[i][n - 1 - j];
                    grid[i][n - 1 - j] = temp;
                }
        }
    }
  
    private boolean isEqual(int[][] m1, int [][] m2)
    {
        int m = m1.length;
        int n = m1[0].length;
        if (m != m2.length || n != m2[0].length)
            return false;
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                if (m1[i][j] != m2[i][j])
                    return false;
        return true;
    }
  
    public int numMagicSquaresInside(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        if (m < 3 || n < 3)
            return 0;
        int count = 0;
        int[][] m1 = {{2,9,4},{7,5,3},{6,1,8}};
        int[][] m2 = {{2,7,6},{9,5,1},{4,3,8}};
  
        for (int i = 1; i < m - 1; i++)
            for (int j = 1; j < n - 1; j++)
            {
                if (grid[i][j] != 5)
                    continue;
                int[][] cur = new int[3][];
                for (int k = 0; k < 3; k++)
                    cur[k] = Arrays.copyOfRange(grid[i - 1 + k], j - 1, j + 2);
              
                for (int time = 0; time < 4; time++)
                {
                    if (isEqual(m1, cur) || isEqual(m2, cur))
                    {
                        count++;
                        j++;
                        break;
                    }
                    rotate(cur, 1);
                }
            }
        return count;
    }
}
Nhấp để mở rộng...
code dài hơn mà chạy chậm như bruteforce lol :amazed:
 
seastar đã nói:
Thử dùng bit manipulation cho đoạn này xem, :beauty:
Bài này cứ vét máng mà chơi thôi ae. Thêm tí bit manipulation cho nó nguy hiểm, :doubt:
C++: 
class Solution {
public:
    int numMagicSquaresInside(vector<vector<int>>& grid) {
        auto IsMagicSquare = [&grid] (int i, int j) {
            array<int, 3> sumRows = {0}, sumCols = {0};
            int diag1 = 0, diag2 = 0;
            int bit_mask = 0;
            for (int x = 0; x < 3; ++x) {
                for (int y = 0; y < 3; ++y) {
                    int val = grid[i + x][j + y];
                    if (val < 1 || val > 9) continue;
                    bit_mask |= 1 << (val - 1);
                  
                    sumRows[x] += val;
                    sumCols[y] += val;
                }
                diag1 += grid[i+x][j+x];
                diag2 += grid[i+2-x][j+x];
            }
          
            if (bit_mask != 0x1FF) {
                return false; 
            }
          
            bit_mask = (1 << diag1 ) | (1 << diag2);
            for (auto x : sumRows) bit_mask |= (1 << x);
            for (auto x : sumCols) bit_mask |= (1 << x);
            if ((bit_mask & (bit_mask - 1)) != 0) return false;
            return true;
        };
      
        int ret = 0;
        for (int i = 0; i + 2 < grid.size(); ++i) {
            for (int j = 0; j + 2 < grid[0].size(); ++j) {
                ret += IsMagicSquare(i, j);
            }
        }
      
        return ret;
    }
};
Nhấp để mở rộng...
Hợp lí :sure:

via theNEXTvoz for iPhone
 
Mã: 
public class Solution {
    public bool IsMagicSquare(int[][] grid, int i, int j)
    {
        int sum = 0;
        int temp = 0;
        var set = new HashSet<int>();
        for(int k = 0; k<3; k++)
        {
            sum += grid[i+k][j+k];
            temp += grid[i+k][j+2-k];
        }
        if(sum != temp)
            return false;
        for(int k = i; k<i+3; k++)
        {
            temp = 0;
            for(int p = j; p<j+3; p++)
            {
                temp += grid[k][p];
                if(set.Contains(grid[k][p]))
                    return false;
                else
                    set.Add(grid[k][p]);
            }
            if(temp != sum)
                return false;
        }
        if(set.Contains(0))
            return false;
        for(int k = 10; k<=15; k++)
        {
            if(set.Contains(k))
                return false;
        }
        for(int k = j; k<j+3; k++)
        {
            temp = 0;
            for(int p = i; p<i+3; p++)
            {
                temp += grid[p][k];
            }
            if(temp != sum)
                return false;
        }
        return true;
    }
    public int NumMagicSquaresInside(int[][] grid) {
        int result = 0;
        for(int i = 0; i<=grid.Length-3; i++)
        {
            for(int j = 0; j<=grid[i].Length-3; j++)
            {
                if(IsMagicSquare(grid,i,j))
                    result++;
            }
        }
        return result;
    }
}
 
Trạng thái
Không mở để trả lời thêm.

Chủ đề tương tự

Thach Sanh Mat Riu
Điều gì xảy ra nếu bạn uống nước chè xanh mỗi ngày?
2
Trả lời
22
Lượt xem
2K
dattenmoi
D
megume
thảo luận Hôm nay, buổi bình minh của AI robot đã đến
Trả lời
4
Lượt xem
1K
Toc Hong
Toc Hong
Lộc Tục
(Dịch) Cuộc điều tra của CBC/Radio-Canada tiết lộ công ty Việt Nam nhắm vào người Canada bằng tin giả AI để kiếm lời
2
Trả lời
30
Lượt xem
5K
dukeng995
dukeng995
Ti Amo
[Dịch] Công ty Việt Nam dùng tin giả do AI tạo ra để kiếm tiền — nhắm vào độc giả Canada
Trả lời
0
Lượt xem
1K
Ti Amo
Ti Amo
Gấu Ted
Độc giả ngày càng tin nhà báo hơn thương hiệu báo chí
Trả lời
10
Lượt xem
886
giayasics
giayasics

Thống kê chủ đề

Ngày tạo
_Gia_Cat_Luong_,
Người trả lời cuối
Vipluckystar,
Trả lời
17.755
Lượt xem
1.214.196

Chia sẻ trang này

Quay lại
Lên đầu trang