Added solutions and tests for problems 41 - 51.

Author: IvanMenov

Diff for: src/main/java/s0041_first_missing_positive/Solution.java

@@ -0,0 +1,25 @@
+package s0041_first_missing_positive;
+
+public class Solution {
+    public int firstMissingPositive(int[] nums) {
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] <= 0 || nums[i] > nums.length || nums[i] == i + 1) continue;
+
+            dfs(nums, nums[i]);
+        }
+
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] != i + 1) return i + 1;
+        }
+
+        return nums.length + 1;
+    }
+
+    private void dfs(int[] nums, int val) {
+        if (val <= 0 || val > nums.length || val == nums[val - 1]) return;
+
+        int temp = nums[val - 1];
+        nums[val - 1] = val;
+        dfs(nums, temp);
+    }
+}

Diff for: src/main/java/s0042_trapping_rain_water/Solution.java

@@ -0,0 +1,22 @@
+package s0042_trapping_rain_water;
+
+public class Solution {
+    public int trap(int[] height) {
+        if (height == null || height.length <= 2) return 0;
+        int l = 0;
+        int r = height.length - 1;
+        int maxL = height[l];
+        int maxR = height[r];
+        int res = 0;
+        while (l < r) {
+            if (maxL < maxR) {
+                maxL = Math.max(height[++l], maxL);
+                res += maxL - height[l];
+            } else {
+                maxR = Math.max(height[--r], maxR);
+                res += maxR - height[r];
+            }
+        }
+        return res;
+    }
+}

Diff for: src/main/java/s0043_multiple_strings/Solution.java

@@ -0,0 +1,59 @@
+package s0043_multiple_strings;
+
+public class Solution {
+    private int[] getIntArray(String s) {
+        char[] chars = s.toCharArray();
+        int[] arr = new int[chars.length];
+        for (int i = 0; i < chars.length; i++) {
+            arr[i] = chars[i] - '0';
+        }
+
+        return arr;
+    }
+
+    private String convertToStr(int[] res, int i) {
+        char[] chars = new char[res.length - i];
+        int k = 0;
+
+        for (; i < res.length; i++) {
+            chars[k] = (char) (res[i] + '0');
+            k++;
+        }
+
+        return new String(chars);
+    }
+
+    public String multiply(String num1, String num2) {
+        int[] arr1 = getIntArray(num1);
+        int[] arr2 = getIntArray(num2);
+        int[] res = new int[arr1.length + arr2.length];
+        int index = arr1.length + arr2.length - 1;
+
+        for (int i = arr2.length - 1; i >= 0; i--) {
+            int k = index--;
+            for (int j = arr1.length - 1; j >= 0; j--) {
+                res[k] += arr2[i] * arr1[j];
+                k--;
+            }
+        }
+        index = arr1.length + arr2.length - 1;
+        int carry = 0;
+
+        for (int i = index; i >= 0; i--) {
+            int temp = res[i] + carry;
+            res[i] = temp % 10;
+            carry = temp / 10;
+        }
+
+        int i = 0;
+        while (i < res.length && res[i] == 0) {
+            i++;
+        }
+
+        if (i > index) {
+            return "0";
+        } else {
+            return convertToStr(res, i);
+        }
+    }
+}

Diff for: src/main/java/s0044_wildcard_matching/Solution.java

@@ -0,0 +1,40 @@
+package s0044_wildcard_matching;
+
+public class Solution {
+    public boolean isMatch(String inputString, String pattern) {
+        int i = 0;
+        int j = 0;
+        int starIdx = -1;
+        int lastMatch = -1;
+
+        while (i < inputString.length()) {
+            if (j < pattern.length()
+                    && (inputString.charAt(i) == pattern.charAt(j) || pattern.charAt(j) == '?')) {
+                i++;
+                j++;
+            } else if (j < pattern.length() && pattern.charAt(j) == '*') {
+                starIdx = j;
+                lastMatch = i;
+                j++;
+            } else if (starIdx != -1) {
+                // there is a no match and there was a previous star, we will reset the j to indx
+                // after star_index
+                // lastMatch will tell from which index we start comparing the string if we
+                // encounter * in pattern
+                j = starIdx + 1;
+                lastMatch++; // we are saying we included more characters in * so we incremented the
+                // index
+                i = lastMatch;
+
+            } else {
+                return false;
+            }
+        }
+        boolean isMatch = true;
+        while (j < pattern.length() && pattern.charAt(j) == '*') j++;
+
+        if (i != inputString.length() || j != pattern.length()) isMatch = false;
+
+        return isMatch;
+    }
+}

Diff for: src/main/java/s0045_jump_game_ii/Solution.java

@@ -0,0 +1,25 @@
+package s0045_jump_game_ii;
+
+public class Solution {
+    public int jump(int[] nums) {
+        int length = 0;
+        int maxLength = 0;
+        int minJump = 0;
+
+        for (int i = 0; i < nums.length - 1; ++i) {
+            length--;
+            maxLength--;
+
+            maxLength = Math.max(maxLength, nums[i]);
+
+            if (length <= 0) {
+                length = maxLength;
+                minJump++;
+            }
+
+            if (length >= nums.length - i - 1) return minJump;
+        }
+
+        return minJump;
+    }
+}

Diff for: src/main/java/s0046_permutations/Solution.java

@@ -0,0 +1,37 @@
+package s0046_permutations;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public List<List<Integer>> permute(int[] nums) {
+
+        if (nums == null || nums.length == 0) {
+            return new ArrayList<>();
+        }
+
+        List<List<Integer>> finalResult = new ArrayList<>();
+        permuteRecur(nums, finalResult, new ArrayList<>(), new boolean[nums.length]);
+        return finalResult;
+    }
+
+    private void permuteRecur(
+            int[] nums, List<List<Integer>> finalResult, List<Integer> currResult, boolean[] used) {
+
+        if (currResult.size() == nums.length) {
+            finalResult.add(new ArrayList<>(currResult));
+            return;
+        }
+
+        for (int i = 0; i < nums.length; i++) {
+            if (used[i]) {
+                continue;
+            }
+            currResult.add(nums[i]);
+            used[i] = true;
+            permuteRecur(nums, finalResult, currResult, used);
+            used[i] = false;
+            currResult.remove(currResult.size() - 1);
+        }
+    }
+}

Diff for: src/main/java/s0047_permutations_ii/Solution.java

@@ -0,0 +1,41 @@
+package s0047_permutations_ii;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    private List<List<Integer>> ans;
+
+    public List<List<Integer>> permuteUnique(int[] nums) {
+        ans = new ArrayList<>();
+        permute(nums, 0);
+        return ans;
+    }
+
+    private void permute(int[] nums, int p) {
+        if (p >= nums.length - 1) {
+            List<Integer> t = new ArrayList<>(nums.length);
+            for (int n : nums) {
+                t.add(n);
+            }
+            ans.add(t);
+            return;
+        }
+        permute(nums, p + 1);
+        boolean[] used = new boolean[30];
+        for (int i = p + 1; i < nums.length; i++) {
+            if (nums[i] != nums[p] && !used[10 + nums[i]]) {
+                used[10 + nums[i]] = true;
+                swap(nums, p, i);
+                permute(nums, p + 1);
+                swap(nums, p, i);
+            }
+        }
+    }
+
+    private void swap(int[] nums, int i, int j) {
+        int t = nums[i];
+        nums[i] = nums[j];
+        nums[j] = t;
+    }
+}

Diff for: src/main/java/s0048_rotate_image/Solution.java

@@ -0,0 +1,22 @@
+package s0048_rotate_image;
+
+public class Solution {
+    public void rotate(int[][] matrix) {
+        int n = matrix.length;
+        for (int i = 0; i < n / 2; i++) {
+            for (int j = i; j < n - i - 1; j++) {
+                int[][] pos =
+                        new int[][] {
+                            {i, j}, {j, n - 1 - i}, {n - 1 - i, n - 1 - j}, {n - 1 - j, i}
+                        };
+                int t = matrix[pos[0][0]][pos[0][1]];
+                for (int k = 1; k < pos.length; k++) {
+                    int temp = matrix[pos[k][0]][pos[k][1]];
+                    matrix[pos[k][0]][pos[k][1]] = t;
+                    t = temp;
+                }
+                matrix[pos[0][0]][pos[0][1]] = t;
+            }
+        }
+    }
+}

Diff for: src/main/java/s0049_group_anagrams/Solution.java

@@ -0,0 +1,25 @@
+package s0049_group_anagrams;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        Map<String, List<String>> hm = new HashMap<>();
+
+        for (String s : strs) {
+            char[] ch = s.toCharArray();
+
+            Arrays.sort(ch);
+            String temp = new String(ch);
+
+            hm.computeIfAbsent(temp, k -> new ArrayList<>());
+            hm.get(temp).add(s);
+        }
+
+        return (new ArrayList<>(hm.values()));
+    }
+}

Diff for: src/main/java/s0050_powx_n/Solution.java

@@ -0,0 +1,28 @@
+package s0050_powx_n;
+
+public class Solution {
+    public double myPow(double x, int n) {
+        long nn = n;
+        double res = 1;
+
+        if (n < 0) {
+            nn *= -1;
+        }
+
+        while (nn > 0) {
+            if (nn % 2 == 1) {
+                nn--;
+                res *= x;
+            } else {
+                x *= x;
+                nn /= 2;
+            }
+        }
+
+        if (n < 0) {
+            return (1.0 / res);
+        }
+
+        return res;
+    }
+}

Diff for: src/main/java/s0051_n_queens/Solution.java

@@ -0,0 +1,44 @@
+package s0051_n_queens;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution {
+    public List<List<String>> solveNQueens(int n) {
+        boolean[] pos = new boolean[n + 2 * n - 1 + 2 * n - 1];
+        int[] pos2 = new int[n];
+        List<List<String>> ans = new ArrayList<>();
+        helper(n, 0, pos, pos2, ans);
+        return ans;
+    }
+
+    private void helper(int n, int row, boolean[] pos, int[] pos2, List<List<String>> ans) {
+        if (row == n) {
+            construct(n, pos2, ans);
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            if (pos[i] || pos[n + i + row] || pos[n + 2 * n - 1 + n - 1 + i - row]) continue;
+            pos[i] = true;
+            pos[n + i + row] = true;
+            pos[n + 2 * n - 1 + n - 1 + i - row] = true;
+            pos2[row] = i;
+            helper(n, row + 1, pos, pos2, ans);
+            pos[i] = false;
+            pos[n + i + row] = false;
+            pos[n + 2 * n - 1 + n - 1 + i - row] = false;
+        }
+    }
+
+    private void construct(int n, int[] pos, List<List<String>> ans) {
+        List<String> sol = new ArrayList<>();
+        for (int r = 0; r < n; r++) {
+            char[] queenRow = new char[n];
+            Arrays.fill(queenRow, '.');
+            queenRow[pos[r]] = 'Q';
+            sol.add(new String(queenRow));
+        }
+        ans.add(sol);
+    }
+}

Diff for: src/test/java/s0041_first_missing_positive/SolutionTest.java

@@ -0,0 +1,13 @@
+package s0041_first_missing_positive;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void firstMissingPositive() {
+        assertThat(new Solution().firstMissingPositive(new int[] {1, 2, 0}), equalTo(3));
+    }
+}