Additional questions

Author: Zanger67

.gitignore

@@ -1,3 +1,5 @@
 .vscode/
 temp.py
-tools/
+tools/
+
+temp/

README.md

@@ -0,0 +1,32 @@
+class Solution:
+    def countSubIslands(self, grid1: List[List[int]], grid2: List[List[int]]) -> int:
+        def helper(r: int, c: int, voidIt: bool) -> bool :
+            if not (0 <= r < len(grid1)) or not (0 <= c < len(grid1[0])) :
+                return True
+
+            if not grid2[r][c] :
+                return True
+
+            grid2[r][c] = 0
+
+            if not grid1[r][c] or voidIt :
+                helper(r, c + 1, True)
+                helper(r, c - 1, True)
+                helper(r + 1, c, True)
+                helper(r - 1, c, True)
+
+                return False
+
+            temp = helper(r, c + 1, False) 
+            temp &= helper(r, c - 1, False)
+            temp &= helper(r + 1, c, False)
+            temp &= helper(r - 1, c, False)
+            return temp 
+
+        counter = 0
+        for r in range(len(grid1)) :
+            for c in range(len(grid1[0])) :
+                if grid2[r][c] and helper(r, c, False) :
+                    counter += 1
+
+        return counter

my-submissions/h995.c my-submissions/h995 Daily.c

@@ -0,0 +1,39 @@
+class Solution {
+    public int[][] findFarmland(int[][] land) {
+        ArrayList<int[]> output = new ArrayList<>();
+
+        for (int r = 0; r < land.length; r++) {
+            for (int c = 0; c < land[0].length; c++) {
+                if (land[r][c] == 1                         // Corner found
+                    && (r == 0 || land[r - 1][c] == 0)
+                    && (c == 0 || land[r][c - 1] == 0)) {
+                    int[] group = new int[4];
+                    group[0] = r;
+                    group[1] = c;
+
+                    for (int i = r + 1;; i++) {
+                        if (i >= land.length || land[i][c] == 0) {
+                            group[2] = i - 1;
+                            break;
+                        }
+                    }
+                    for (int i = c + 1;; i++) {
+                        if (i >= land[0].length || land[r][i] == 0) {
+                            group[3] = i - 1;
+                            break;
+                        }
+                    }
+
+                    output.add(group);
+                }
+            }
+        }
+
+        int[][] actualOutput = new int[output.size()][];
+        for (int i = 0; i < output.size(); i++) {
+            actualOutput[i] = output.get(i);
+        }
+
+        return actualOutput;
+    }
+}

my-submissions/m1052.py my-submissions/m1052 Daily.py

@@ -0,0 +1,24 @@
+class Solution:
+    def findFarmland(self, land: List[List[int]]) -> List[List[int]]:
+        output:List[List[int]] = []
+
+        for r in range(len(land)) :
+            for c in range(len(land[0])) :
+                if land[r][c] \
+                    and (r == 0 or not land[r - 1][c]) \
+                    and (c == 0 or not land[r][c - 1]) :
+                    output.append([r, c, r, c])
+                    
+                    rRight, cRight = r, c
+                    while True :
+                        if rRight >= len(land) or land[rRight][c] == 0 :
+                            output[-1][2] = rRight - 1
+                            break
+                        rRight += 1
+                    while True :
+                        if cRight >= len(land[0]) or land[r][cRight] == 0 :
+                            output[-1][3] = cRight - 1
+                            break
+                        cRight += 1
+        
+        return output

my-submissions/m1438.java my-submissions/m1438 Daily.java

@@ -0,0 +1,13 @@
+class Solution:
+    def countBattleships(self, board: List[List[str]]) -> int:
+        counter = 0
+
+        # find corners
+        for r in range(len(board)) :
+            for c in range(len(board[0])) :
+                if board[r][c] == 'X' \
+                    and (c == 0 or board[r][c - 1] == '.') \
+                    and (r == 0 or board[r - 1][c] == '.'):
+                    counter += 1
+
+        return counter

my-submissions/m1905.py

@@ -0,0 +1,14 @@
+int countBattleships(char** board, int boardSize, int* boardColSize) {
+    int counter = 0;
+
+    for (int r = 0; r < boardSize; r++) {
+        for (int c = 0; c < boardColSize[0]; c++) {
+            if (board[r][c] == 'X'
+                && (c == 0 || board[r][c - 1] == '.')
+                && (r == 0 || board[r - 1][c] == '.'))
+                counter++;
+        }
+    }
+    return counter;
+}
+

my-submissions/m1992.java

@@ -0,0 +1,26 @@
+void removeShip(char** board, int boardSize, int* boardColSize, int x, int y) {
+    if (x < 0 || x >= boardSize || y < 0 || y >= boardColSize[0] || board[x][y] == '.') {
+        return;
+    }
+
+    board[x][y] = '.';
+
+    removeShip(board, boardSize, boardColSize, x + 1, y);
+    removeShip(board, boardSize, boardColSize, x - 1, y);
+    removeShip(board, boardSize, boardColSize, x, y + 1);
+    removeShip(board, boardSize, boardColSize, x, y - 1);
+}
+
+int countBattleships(char** board, int boardSize, int* boardColSize) {
+    int counter = 0;
+
+    for (int i = 0; i < boardSize; i++) {
+        for (int j = 0; j < boardColSize[0]; j++) {
+            if (board[i][j] == 'X') {
+                counter++;
+                removeShip(board, boardSize, boardColSize, i, j);
+            }
+        }
+    }
+    return counter;
+}

my-submissions/m1992.py

@@ -0,0 +1,28 @@
+int getAreaAndVoid(int** grid, int gridSize, int* gridColSize, int x, int y) {
+    if (x < 0 || y < 0 || x >= gridSize || y >= gridColSize[0] || grid[x][y] == 0) {
+        return 0;
+    }
+
+    grid[x][y] = 0;
+
+    return 1 + getAreaAndVoid(grid, gridSize, gridColSize, x + 1, y)
+             + getAreaAndVoid(grid, gridSize, gridColSize, x - 1, y)
+             + getAreaAndVoid(grid, gridSize, gridColSize, x, y + 1)
+             + getAreaAndVoid(grid, gridSize, gridColSize, x, y - 1);
+}
+
+int maxAreaOfIsland(int** grid, int gridSize, int* gridColSize) {
+    int max = 0;
+
+    for (int i = 0; i < gridSize; i++) {
+        for (int j = 0; j < gridColSize[0]; j++) {
+            if (grid[i][j]) {
+                int islandArea = getAreaAndVoid(grid, gridSize, gridColSize, i, j);
+                max = (islandArea > max) ? islandArea : max;
+            }
+        }
+    }
+    return max;
+
+    
+}