leetcode: CanMakeArithmeticProgression: passed

leetcode: NumberClosedIslands: passed
leetcode: OneSwapEqual: passed
leetcode SignOfProduct: passed

Author: unrealwork

src/main/java/com/leetcode/array/CanMakeArithmeticProgression.java

@@ -0,0 +1,20 @@
+package com.leetcode.array;
+
+import java.util.Arrays;
+
+public final class CanMakeArithmeticProgression {
+    private CanMakeArithmeticProgression() {
+
+    }
+
+    public static boolean canMakeArithmeticProgression(int[] arr) {
+        Arrays.sort(arr);
+        int d = arr[1] - arr[0];
+        for (int i = 2; i < arr.length; i++) {
+            if (arr[i] - arr[i - 1] != d) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

src/main/java/com/leetcode/array/SignOfProduct.java

@@ -0,0 +1,20 @@
+package com.leetcode.array;
+
+public final class SignOfProduct {
+    private SignOfProduct() {
+    }
+
+    public static int arraySign(int[] nums) {
+        int sign = 1;
+        for (int n : nums) {
+            if (n == 0) {
+                return 0;
+            } else {
+                if (n < 0) {
+                    sign *= -1;
+                }
+            }
+        }
+        return sign;
+    }
+}

src/main/java/com/leetcode/graph/NumberClosedIslands.java

@@ -0,0 +1,65 @@
+package com.leetcode.graph;
+
+public final class NumberClosedIslands {
+    private NumberClosedIslands() {
+    }
+
+    public static int closedIsland(int[][] grid) {
+        return new Solver(grid).solve();
+    }
+
+
+    private static final class Solver {
+        private final int[][] grid;
+        private final boolean[][] explored;
+        private final boolean[][] processing;
+
+        private Solver(int[][] grid) {
+            this.grid = grid;
+            this.explored = new boolean[grid.length][grid[0].length];
+            this.processing = new boolean[grid.length][grid[0].length];
+        }
+
+        public int solve() {
+            int count = 0;
+            for (int i = 0; i < grid.length; i++) {
+                for (int j = 0; j < grid[i].length; j++) {
+                    if (!explored[i][j] && isClosed(i, j)) {
+                        count++;
+                    }
+                }
+            }
+            return count;
+        }
+
+        private boolean isEdge(int i, int j) {
+            return !(i > 0 && j > 0 && i < grid.length - 1 && j < grid[0].length - 1);
+        }
+
+        private boolean isClosed(int i, int j) {
+            explored[i][j] = true;
+            if (isLand(i, j)) {
+                processing[i][j] = true;
+                boolean res = !isEdge(i, j)
+                        && isValidAdjacent(i - 1, j)
+                        && isValidAdjacent(i + 1, j)
+                        && isValidAdjacent(i, j + 1)
+                        && isValidAdjacent(i, j - 1);
+                processing[i][j] = false;
+                return res;
+            }
+            return false;
+        }
+
+        private boolean isValidAdjacent(int i, int j) {
+            if (processing[i][j]) {
+                return true;
+            }
+            return !isLand(i, j) || isClosed(i, j);
+        }
+
+        private boolean isLand(int i, int j) {
+            return grid[i][j] == 0;
+        }
+    }
+}

src/main/java/com/leetcode/string/OneSwapEqual.java

@@ -0,0 +1,41 @@
+package com.leetcode.string;
+
+public final class OneSwapEqual {
+    private OneSwapEqual() {
+    }
+
+    @SuppressWarnings("squid:S3776")
+    public static boolean areAlmostEqual(String s1, String s2) {
+        int i = 0;
+        int j = s1.length() - 1;
+        int swappedElement = 0;
+        while (i <= j) {
+            char leftS1 = s1.charAt(i);
+            char leftS2 = s2.charAt(i);
+            char rightS1 = s1.charAt(j);
+            char rightS2 = s2.charAt(j);
+            if (leftS1 != leftS2 && rightS1 != rightS2) {
+                if (leftS1 == rightS2 && rightS1 == leftS2) {
+                    i++;
+                    j--;
+                    swappedElement++;
+                } else {
+                    return false;
+                }
+            }
+            if (leftS1 == leftS2) {
+                i++;
+            }
+            if (rightS1 == rightS2) {
+                j--;
+            }
+            if (swappedElement > 1) {
+                return false;
+            }
+        }
+        if (s1.length() == 1) {
+            return true;
+        }
+        return swappedElement != 0 || s1.charAt(i) == s2.charAt(i);
+    }
+}

src/test/java/com/leetcode/array/CanMakeArithmeticProgressionTest.java

@@ -0,0 +1,20 @@
+package com.leetcode.array;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.converter.ConvertWith;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class CanMakeArithmeticProgressionTest {
+
+    @ParameterizedTest
+    @CsvSource( {
+            "'3,5,1', true",
+            "'1,2,4', false"
+    }
+    )
+    void testCanMakeArithmeticProgression(@ConvertWith(IntArrayConverter.class) int[] nums, boolean expected) {
+        assertEquals(expected, CanMakeArithmeticProgression.canMakeArithmeticProgression(nums));
+    }
+}

src/test/java/com/leetcode/array/SignOfProductTest.java

@@ -0,0 +1,19 @@
+package com.leetcode.array;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.converter.ConvertWith;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class SignOfProductTest {
+    @ParameterizedTest
+    @CsvSource( {
+            "'-1,-2,-3,-4,3,2,1', 1",
+            "'1,5,0,2,-3', 0",
+            "'-1,1,-1,1,-1', -1"
+    })
+    void testArraySign(@ConvertWith(IntArrayConverter.class) int[] nums, int sign) {
+        assertEquals(sign, SignOfProduct.arraySign(nums));
+    }
+}

src/test/java/com/leetcode/graph/NumberClosedIslandsTest.java

@@ -0,0 +1,55 @@
+package com.leetcode.graph;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.stream.Stream;
+
+class NumberClosedIslandsTest {
+
+    static Stream<Arguments> testCases() {
+        return Stream.of(
+                Arguments.of(new int[][] {
+                        {1, 1, 1, 1, 1, 1, 1, 0},
+                        {1, 0, 0, 0, 0, 1, 1, 0},
+                        {1, 0, 1, 0, 1, 1, 1, 0},
+                        {1, 0, 0, 0, 0, 1, 0, 1},
+                        {1, 1, 1, 1, 1, 1, 1, 0}
+                }, 2),
+                Arguments.of(new int[][] {
+                        {0, 0, 1, 0, 0},
+                        {0, 1, 0, 1, 0},
+                        {0, 1, 1, 1, 0}
+                }, 1),
+                Arguments.of(new int[][] {
+                        {1, 1, 1, 1, 1, 1, 1},
+                        {1, 0, 0, 0, 0, 0, 1},
+                        {1, 0, 1, 1, 1, 0, 1},
+                        {1, 0, 1, 0, 1, 0, 1},
+                        {1, 0, 1, 1, 1, 0, 1},
+                        {1, 0, 0, 0, 0, 0, 1},
+                        {1, 1, 1, 1, 1, 1, 1}
+                }, 2),
+                Arguments.of(new int[][] {
+                                {0, 0, 1, 1, 0, 1, 0, 0, 1, 0},
+                                {1, 1, 0, 1, 1, 0, 1, 1, 1, 0},
+                                {1, 0, 1, 1, 1, 0, 0, 1, 1, 0},
+                                {0, 1, 1, 0, 0, 0, 0, 1, 0, 1},
+                                {0, 0, 0, 0, 0, 0, 1, 1, 1, 0},
+                                {0, 1, 0, 1, 0, 1, 0, 1, 1, 1},
+                                {1, 0, 1, 0, 1, 1, 0, 0, 0, 1},
+                                {1, 1, 1, 1, 1, 1, 0, 0, 0, 0},
+                                {1, 1, 1, 0, 0, 1, 0, 1, 0, 1},
+                                {1, 1, 1, 0, 1, 1, 0, 1, 1, 0}},
+                        5)
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("testCases")
+    void testClosedIsland(int[][] grid, int expected) {
+        Assertions.assertEquals(expected, NumberClosedIslands.closedIsland(grid));
+    }
+}

src/test/java/com/leetcode/string/OneSwapEqualTest.java

@@ -0,0 +1,23 @@
+package com.leetcode.string;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class OneSwapEqualTest {
+
+    @ParameterizedTest
+    @CsvSource( {
+            "bank,kanb,true",
+            "attack,defend,false",
+            "kelb,kelb,true",
+            "kelb,kekb,false",
+            "bank,kanr,false",
+            "siyolsdcjthwsiplccpbuceoxmjjgrauocx,siyolsdcjthwsiplccjbuceoxmpjgrauocx,true",
+            "glb,bdg,false"
+    })
+    void testAreAlmostEqual(String s1, String s2, boolean expected) {
+        assertEquals(expected, OneSwapEqual.areAlmostEqual(s1, s2));
+    }
+}