Added tasks 38 - 40.

Author: javadev

src/main/java/s0038_count_and_say/Solution.java

@@ -0,0 +1,19 @@
+package s0038_count_and_say;
+
+public class Solution {
+    public String countAndSay(int n) {
+        if (n == 1) return "1";
+        StringBuilder res = new StringBuilder();
+        String prev = countAndSay(n - 1);
+        int count = 1;
+        for (int i = 1; i < prev.length(); i++) {
+            if (prev.charAt(i) == prev.charAt(i - 1)) count++;
+            else {
+                res.append(count).append(prev.charAt(i - 1));
+                count = 1;
+            }
+        }
+        res.append(count).append(prev.charAt(prev.length() - 1));
+        return res.toString();
+    }
+}

src/main/java/s0039_combination_sum/Solution.java

@@ -0,0 +1,32 @@
+package s0039_combination_sum;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public List<List<Integer>> combinationSum(int[] coins, int amount) {
+        List<List<Integer>> ans = new ArrayList<>();
+        List<Integer> subList = new ArrayList<>();
+        combinationSumRec(coins.length, coins, amount, subList, ans);
+        return ans;
+    }
+
+    private void combinationSumRec(
+            int n, int[] coins, int amount, List<Integer> subList, List<List<Integer>> ans) {
+        if (amount == 0 || n == 0) {
+            if (amount == 0) {
+                List<Integer> base = new ArrayList<>(subList);
+                ans.add(base);
+            }
+            return;
+        }
+
+        if (amount - coins[n - 1] >= 0) {
+            subList.add(coins[n - 1]);
+            combinationSumRec(n, coins, amount - coins[n - 1], subList, ans);
+            subList.remove(subList.size() - 1);
+        }
+
+        combinationSumRec(n - 1, coins, amount, subList, ans);
+    }
+}

src/main/java/s0040_combination_sum_ii/Solution.java

@@ -0,0 +1,40 @@
+package s0040_combination_sum_ii;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+public class Solution {
+    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        List<List<Integer>> sums = new ArrayList<>();
+        Arrays.sort(candidates); // optimize
+        combinationSum(candidates, target, 0, sums, new LinkedList<>());
+        return sums;
+    }
+
+    private void combinationSum(
+            int[] candidates,
+            int target,
+            int start,
+            List<List<Integer>> sums,
+            LinkedList<Integer> sum) {
+        if (target == 0) {
+            // make a deep copy of the current combination
+            sums.add(new ArrayList<>(sum));
+            return;
+        }
+        for (int i = start; i < candidates.length && target >= candidates[i]; i++) {
+            // If candidate[i] equals candidate[i-1], then solutions for i is subset of
+            // solution of i-1
+            // Refer:
+            // https://leetcode.com/problems/combination-sum-ii/discuss/16861/Java-solution-using-dfs-easy-understand/977097
+            if (i == start || (i > start && candidates[i] != candidates[i - 1])) {
+                sum.addLast(candidates[i]);
+                // call on 'i+1' (not i) to avoid duplicate usage of same element
+                combinationSum(candidates, target - candidates[i], i + 1, sums, sum);
+                sum.removeLast();
+            }
+        }
+    }
+}

src/test/java/s0038_count_and_say/SolutionTest.java

@@ -0,0 +1,13 @@
+package s0038_count_and_say;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void countAndSay() {
+        assertThat(new Solution().countAndSay(1), equalTo("1"));
+    }
+}

src/test/java/s0039_combination_sum/SolutionTest.java

@@ -0,0 +1,30 @@
+package s0039_combination_sum;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void combinationSum() {
+        List<List<Integer>> expected = new ArrayList<List<Integer>>();
+
+        List<Integer> sublist1 = new ArrayList<Integer>();
+        sublist1.add(7);
+        List<Integer> sublist2 = new ArrayList<Integer>();
+        sublist2.addAll(Arrays.asList(3, 2, 2));
+
+        expected.add(sublist1);
+        expected.add(sublist2);
+
+        List<List<Integer>> actual = new Solution().combinationSum(new int[] {2, 3, 6, 7}, 7);
+
+        for (int i = 0; i < expected.size(); i++) {
+            assertThat(actual.get(i).toArray(), equalTo(expected.get(i).toArray()));
+        }
+    }
+}

src/test/java/s0040_combination_sum_ii/SolutionTest.java

@@ -0,0 +1,40 @@
+package s0040_combination_sum_ii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void combinationSumII() {
+        List<List<Integer>> expected = new ArrayList<>();
+
+        List<Integer> sub1 = new ArrayList<Integer>();
+        sub1.addAll(Arrays.asList(1, 1, 6));
+
+        List<Integer> sub2 = new ArrayList<Integer>();
+        sub2.addAll(Arrays.asList(1, 2, 5));
+
+        List<Integer> sub3 = new ArrayList<Integer>();
+        sub3.addAll(Arrays.asList(1, 7));
+
+        List<Integer> sub4 = new ArrayList<Integer>();
+        sub4.addAll(Arrays.asList(2, 6));
+
+        expected.add(sub1);
+        expected.add(sub2);
+        expected.add(sub3);
+        expected.add(sub4);
+
+        List<List<Integer>> actual =
+                new Solution().combinationSum2(new int[] {10, 1, 2, 7, 6, 1, 5}, 8);
+
+        for (int i = 0; i < expected.size(); i++) {
+            assertThat(actual.get(i).toArray(), equalTo(expected.get(i).toArray()));
+        }
+    }
+}