add 840

fishercoder1534 · fishercoder1534 · commit d941657379cc · 2019-02-23T15:05:56.000-08:00
diff --git a/README.md b/README.md
@@ -61,6 +61,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |859|[Buddy Strings](https://leetcode.com/problems/buddy-strings/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_859.java) | O(n) | O(n) | |Easy|
 |852|[Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_852.java) | O(n) | O(1) | |Easy|
 |844|[Backspace String Compare](https://leetcode.com/problems/backspace-string-compare/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_844.java) | O(n) | O(1) | |Easy|
+|840|[Magic Squares In Grid](https://leetcode.com/problems/magic-squares-in-grid/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_840.java) | O(1) | O(1) | |Easy|
 |832|[Flipping an Image](https://leetcode.com/problems/flipping-an-image/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_832.java) | O(n) | O(1) | |Easy|
 |830|[Positions of Large Groups](https://leetcode.com/problems/positions-of-large-groups/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_830.java) | O(n) | O(n) | |Easy|
 |824|[Goat Latin](https://leetcode.com/problems/goat-latin/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_824.java) | O(n) | O(1) | |Easy| 
diff --git a/src/main/java/com/fishercoder/solutions/_840.java b/src/main/java/com/fishercoder/solutions/_840.java
@@ -0,0 +1,81 @@
+package com.fishercoder.solutions;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * 840. Magic Squares In Grid
+ *
+ * A 3 x 3 magic square is a 3 x 3 grid filled with distinct numbers from 1 to 9 such that each row,
+ * column, and both diagonals all have the same sum.
+ *
+ * Given an grid of integers, how many 3 x 3 "magic square" subgrids are there?  (Each subgrid is contiguous).
+ *
+ * Example 1:
+ *
+ * Input: [[4,3,8,4],
+ *         [9,5,1,9],
+ *         [2,7,6,2]]
+ *
+ * Output: 1
+ *
+ * Explanation:
+ * The following subgrid is a 3 x 3 magic square:
+ * 438
+ * 951
+ * 276
+ *
+ * while this one is not:
+ * 384
+ * 519
+ * 762
+ *
+ * In total, there is only one magic square inside the given grid.
+ * Note:
+ *
+ * 1 <= grid.length <= 10
+ * 1 <= grid[0].length <= 10
+ * 0 <= grid[i][j] <= 15
+ */
+public class _840 {
+  public static class Solution1 {
+    public int numMagicSquaresInside(int[][] grid) {
+      int m = grid.length;
+      int n = grid[0].length;
+      int count = 0;
+      for (int i = 0; i < m - 2; i++) {
+        for (int j = 0; j < n - 2; j++) {
+          Set<Integer> set = new HashSet<>();
+          int sum = grid[i][j] + grid[i][j + 1] + grid[i][j + 2];
+          if (sum == grid[i + 1][j] + grid[i + 1][j + 1] + grid[i + 1][j + 2]
+              && sum == grid[i + 2][j] + grid[i + 2][j + 1] + grid[i + 2][j + 2]
+
+              && sum == grid[i][j] + grid[i + 1][j] + grid[i + 2][j]
+              && sum == grid[i][j + 1] + grid[i + 1][j + 1] + grid[i + 2][j + 1]
+              && sum == grid[i][j + 2] + grid[i + 1][j + 2] + grid[i + 2][j + 2]
+
+              && sum == grid[i][j] + grid[i + 1][j + 1] + grid[i + 2][j + 2]
+              && sum == grid[i][j + 2] + grid[i + 1][j + 1] + grid[i + 2][j]
+
+              && set.add(grid[i][j]) && isLegit(grid[i][j])
+              && set.add(grid[i][j + 1]) && isLegit(grid[i][j + 1])
+              && set.add(grid[i][j + 2]) && isLegit(grid[i][j + 2])
+              && set.add(grid[i + 1][j]) && isLegit(grid[i + 1][j])
+              && set.add(grid[i + 1][j + 1]) && isLegit(grid[i + 1][j + 1])
+              && set.add(grid[i + 1][j + 2]) && isLegit(grid[i + 1][j + 2])
+              && set.add(grid[i + 2][j]) && isLegit(grid[i + 2][j])
+              && set.add(grid[i + 2][j + 1]) && isLegit(grid[i + 2][j + 1])
+              && set.add(grid[i + 2][j + 2]) && isLegit(grid[i + 2][j + 2])
+          ) {
+            count++;
+          }
+        }
+      }
+      return count;
+    }
+
+    private boolean isLegit(int num) {
+      return num <= 9 && num >= 1;
+    }
+  }
+}
diff --git a/src/test/java/com/fishercoder/_840Test.java b/src/test/java/com/fishercoder/_840Test.java
@@ -0,0 +1,48 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._840;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _840Test {
+    private static _840.Solution1 test;
+    private static int[][] grid;
+
+    @BeforeClass
+    public static void setUp() {
+        test = new _840.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        grid = new int[][]{
+            {4,3,8,4},
+            {9,5,1,9},
+            {2,7,6,2}
+        };
+        assertEquals(1, test.numMagicSquaresInside(grid));
+    }
+
+    @Test
+    public void test2() {
+        grid = new int[][]{
+            {5,5,5},
+            {5,5,5},
+            {5,5,5}
+        };
+        assertEquals(0, test.numMagicSquaresInside(grid));
+    }
+
+    @Test
+    public void test3() {
+        grid = new int[][]{
+            {10,3,5},
+            {1,6,11},
+            {7,9,2}
+        };
+        assertEquals(0, test.numMagicSquaresInside(grid));
+    }
+
+}
