leetcode: DecryptIntegerAlphabet: passed

leetcode: FindTheDifference: passed
leetcode: GoalParserInterpretation: passed
leetcode: MatrixDiagonalSum: passed
leetcode: MergeStringsAlternately: passed
leetcode: VerifyingAlienDictionary: passed

Author: unrealwork

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

@@ -0,0 +1,19 @@
+package com.leetcode.array;
+
+public final class MatrixDiagonalSum {
+    private MatrixDiagonalSum() {
+
+    }
+
+    public static int diagonalSum(int[][] mat) {
+        int sum = 0;
+        for (int i = 0; i < mat.length; i++) {
+            for (int j = 0; j < mat[i].length; j++) {
+                if (i == j || i + j == mat.length - 1) {
+                    sum += mat[i][j];
+                }
+            }
+        }
+        return sum;
+    }
+}

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

@@ -0,0 +1,26 @@
+package com.leetcode.array;
+
+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 MatrixDiagonalSumTest {
+
+    static Stream<Arguments> testCases() {
+        return Stream.of(
+                Arguments.of(new int[][] {{1, 2, 3},
+                        {4, 5, 6},
+                        {7, 8, 9}}, 25)
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("testCases")
+    void testDiagonalSum(int[][] mat, int expected) {
+        int actual = MatrixDiagonalSum.diagonalSum(mat);
+        Assertions.assertEquals(expected, actual);
+    }
+}

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

@@ -0,0 +1,31 @@
+package com.leetcode.string;
+
+public final class DecryptIntegerAlphabet {
+
+    private static final int BASE = 10;
+
+    private DecryptIntegerAlphabet() {
+    }
+
+    public static String freqAlphabets(String s) {
+        StringBuilder sb = new StringBuilder();
+        int i = 0;
+        while (i < s.length()) {
+            final int code;
+            if (i + 2 < s.length() && s.charAt(i + 2) == '#') {
+                code = readDigit(s, i) * BASE + readDigit(s, i + 1);
+                i += 3;
+            } else {
+                code = readDigit(s, i);
+                i++;
+            }
+
+            sb.append((char) ('a' + code - 1));
+        }
+        return sb.toString();
+    }
+
+    private static int readDigit(String s, int i) {
+        return s.charAt(i) - '0';
+    }
+}

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

@@ -0,0 +1,17 @@
+package com.leetcode.string;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+class DecryptIntegerAlphabetTest {
+
+    @ParameterizedTest
+    @CsvSource( {
+            "10#11#12,jkab"
+    })
+    void testFreqAlphabets(String s, String expected) {
+        String actual = DecryptIntegerAlphabet.freqAlphabets(s);
+        Assertions.assertEquals(expected, actual);
+    }
+}

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

@@ -0,0 +1,29 @@
+package com.leetcode.string;
+
+public final class FindTheDifference {
+
+    private static final int ALPHABET_SIZE = 26;
+
+    private FindTheDifference() {
+    }
+
+    public static char findTheDifference(String s, String t) {
+        char[] dict1 = dict(s);
+        char[] dict2 = dict(t);
+        for (int i = 0; i < ALPHABET_SIZE; i++) {
+            if (dict2[i] != dict1[i]) {
+                return (char) ('a' + i);
+            }
+        }
+        throw new IllegalStateException();
+    }
+
+    private static char[] dict(String s) {
+        char[] dict = new char[ALPHABET_SIZE];
+        for (int i = 0; i < s.length(); i++) {
+            int index = s.charAt(i) - 'a';
+            dict[index]++;
+        }
+        return dict;
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.leetcode.string;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+class FindTheDifferenceTest {
+
+    @ParameterizedTest
+    @CsvSource( {
+            "abcd,abcde,e",
+            "'',y,y"
+    })
+    void testFindTheDifference(String s, String t, char expected) {
+        char actual = FindTheDifference.findTheDifference(s, t);
+        Assertions.assertEquals(expected, actual);
+    }
+}

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

@@ -0,0 +1,26 @@
+package com.leetcode.string;
+
+public final class GoalParserInterpretation {
+    private GoalParserInterpretation() {
+    }
+
+    public static String interpret(String command) {
+        int i = 0;
+        StringBuilder sb = new StringBuilder();
+        while (i < command.length()) {
+            if (command.charAt(i) == 'G') {
+                sb.append('G');
+                i++;
+            } else {
+                if (command.charAt(i) == '(' && command.charAt(i + 1) == ')') {
+                    sb.append('o');
+                    i += 2;
+                } else {
+                    sb.append("al");
+                    i += 4;
+                }
+            }
+        }
+        return sb.toString();
+    }
+}

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

@@ -0,0 +1,19 @@
+package com.leetcode.string;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+class GoalParserInterpretationTest {
+
+    @ParameterizedTest
+    @CsvSource( {
+            "G()(al),Goal",
+            "G()()()()(al),Gooooal",
+            "(al)G(al)()()G,alGalooG"
+    })
+    void testInterpret(String s, String expected) {
+        String actual = GoalParserInterpretation.interpret(s);
+        Assertions.assertEquals(expected, actual);
+    }
+}

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

@@ -0,0 +1,26 @@
+package com.leetcode.string;
+
+public final class MergeStringsAlternately {
+    private MergeStringsAlternately() {
+    }
+
+    public static String mergeAlternately(String word1, String word2) {
+        char[] res = new char[word1.length() + word2.length()];
+        int j = 0;
+        int i = 0;
+        int k = 0;
+        while (k < res.length) {
+            if (i < word1.length()) {
+                res[k] = word1.charAt(i);
+                i++;
+                k++;
+            }
+            if (j < word2.length()) {
+                res[k] = word2.charAt(j);
+                j++;
+                k++;
+            }
+        }
+        return new String(res);
+    }
+}

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

@@ -0,0 +1,18 @@
+package com.leetcode.string;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+class MergeStringsAlternatelyTest {
+
+    @ParameterizedTest
+    @CsvSource( {
+            "abc,pqr,apbqcr",
+            "ab,pqrs,apbqrs"
+    })
+    void testMergeAlternately(String s1, String s2, String expected) {
+        String actual = MergeStringsAlternately.mergeAlternately(s1, s2);
+        Assertions.assertEquals(expected, actual);
+    }
+}