[hoonjichoi1] WEEK 03 solutions

combination-sum/hoonjichoi1.java

@@ -0,0 +1,35 @@
+/*
+Time Complexity : O(c^t)
+Space Complexity : O(t)
+ */
+
+class Solution {
+
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        List<List<Integer>> output = new ArrayList<>();
+        Stack<Integer> nums = new Stack<>();
+        dfs (candidates, output, target, nums, 0, 0);
+        return output;
+    }
+
+    private void dfs(int[] candidates, List<List<Integer>> output, int target, Stack<Integer> nums, int start, int total) {
+        // base case : pass
+        if (target == total) {
+            output.add(new ArrayList<>(nums));
+            return;
+        }
+        // base case : fail
+        if (target < total) {
+            return;
+        }
+
+        for (int i = start ; i < candidates.length ; i++) {
+            int num = candidates[i];
+            nums.push(num);
+            dfs(candidates, output, target, nums, i, total + num);
+            nums.pop();
+        }
+
+
+    }
+}

number-of-1-bits/hoonjichoi1.java

@@ -0,0 +1,19 @@
+class Solution {
+    public int hammingWeight(int n) {
+
+        if (n == 1) {
+            return 1;
+        }
+
+        int curr = n, result = 1;
+        while (curr > 1) {
+            if (curr % 2 == 1) {
+                result++;
+            }
+            curr = curr / 2;
+        }
+
+        return result;
+    }
+}
+

valid-palindrome/hoonjichoi1.java

@@ -0,0 +1,23 @@
+class Solution {
+    public boolean isPalindrome(String s) {
+
+        // removing all non-alphanumeric characters and convert them to lower case
+        String conveted = s.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();
+
+        // early return of the empty string case
+        if (conveted.length() == 0) {
+            return true;
+        }
+
+        // check the symmetry
+        int left = 0, right = conveted.length() - 1;
+        while (left <= right) {
+            if (conveted.charAt(left) != conveted.charAt(right)) {
+                return false;
+            }
+            left++;
+            right--;
+        }
+        return true;
+    }
+}