Added solutions and tests for problems 52 - 71.

Author: IvanMenov

src/main/java/s0052_n_queens_ii/Solution.java

@@ -0,0 +1,32 @@
+package s0052_n_queens_ii;
+
+public class Solution {
+    public int totalNQueens(int n) {
+        boolean[] row = new boolean[n];
+        boolean[] col = new boolean[n];
+        boolean[] diagonal = new boolean[n + n - 1];
+        boolean[] antiDiagonal = new boolean[n + n - 1];
+
+        return totalNQueens(n, 0, row, col, diagonal, antiDiagonal);
+    }
+
+    public static int totalNQueens(
+            int n,
+            int r,
+            boolean[] row,
+            boolean[] col,
+            boolean[] diagonal,
+            boolean[] antiDiagonal) {
+        if (r == n) return 1;
+
+        int count = 0;
+        for (int c = 0; c < n; c++) {
+            if (!row[r] && !col[c] && !diagonal[r + c] && !antiDiagonal[r - c + n - 1]) {
+                row[r] = col[c] = diagonal[r + c] = antiDiagonal[r - c + n - 1] = true;
+                count += totalNQueens(n, r + 1, row, col, diagonal, antiDiagonal);
+                row[r] = col[c] = diagonal[r + c] = antiDiagonal[r - c + n - 1] = false;
+            }
+        }
+        return count;
+    }
+}

src/main/java/s0053_maximum_subarray/Solution.java

@@ -0,0 +1,18 @@
+package s0053_maximum_subarray;
+
+public class Solution {
+    public int maxSubArray(int[] nums) {
+        int maxi = Integer.MIN_VALUE;
+        int sum = 0;
+        for (int i = 0; i < nums.length; i++) {
+            // calculating sub-array sum
+            sum += nums[i];
+            maxi = Math.max(sum, maxi);
+            if (sum < 0) {
+                // there is no point to carry a -ve subarray sum. hence setting to 0
+                sum = 0;
+            }
+        }
+        return maxi;
+    }
+}

src/main/java/s0054_spiral_matrix/Solution.java

@@ -0,0 +1,33 @@
+package s0054_spiral_matrix;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public List<Integer> spiralOrder(int[][] matrix) {
+        List<Integer> list = new ArrayList<>();
+        int r = 0;
+        int c = 0;
+        int bigR = matrix.length - 1;
+        int bigC = matrix[0].length - 1;
+        while (r <= bigR && c <= bigC) {
+            for (int i = c; i <= bigC; i++) {
+                list.add(matrix[r][i]);
+            }
+            r++;
+            for (int i = r; i <= bigR; i++) {
+                list.add(matrix[i][bigC]);
+            }
+            bigC--;
+            for (int i = bigC; i >= c && r <= bigR; i--) {
+                list.add(matrix[bigR][i]);
+            }
+            bigR--;
+            for (int i = bigR; i >= r && c <= bigC; i--) {
+                list.add(matrix[i][c]);
+            }
+            c++;
+        }
+        return list;
+    }
+}

src/main/java/s0055_jump_game/Solution.java

@@ -0,0 +1,38 @@
+package s0055_jump_game;
+
+public class Solution {
+    public boolean canJump(int[] nums) {
+        int sz = nums.length;
+        // we set 1 so it won't break on the first iteration
+        int tmp = 1;
+        for (int i = 0; i < sz; i++) {
+            // we always deduct tmp for every iteration
+            tmp--;
+            if (tmp < 0) {
+                // if from previous iteration tmp is already 0, it will be <0 here
+                // leading to false value
+                return false;
+            }
+            // we get the maximum value because this value is supposed
+            // to be our iterator, if both values are 0, then the next
+            // iteration we will return false
+            // if either both or one of them are not 0 then we will keep doing this and check.
+
+            // We can stop the whole iteration with this condition. without this condition the code
+            // runs in 2ms 79.6%, adding this condition improves the performance into 1ms 100%
+            // because if the test case jump value is quite large, instead of just iterate, we can
+            // just check using this condition
+            // example: [10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] -> we can just jump to the end without
+            // iterating whole array
+            tmp = Math.max(tmp, nums[i]);
+            if (i + tmp >= sz - 1) {
+                return true;
+            }
+        }
+        // we can just return true at the end, because if tmp is 0 on previous
+        // iteration,
+        // even though the next iteration index is the last one, it will return false under the
+        // tmp<0 condition
+        return true;
+    }
+}

src/main/java/s0056_merge_intervals/Solution.java

@@ -0,0 +1,46 @@
+package s0056_merge_intervals;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution {
+    public int[][] merge(int[][] intervals) {
+        // sorting
+        // so that we can perform the task linearly
+        Arrays.sort(
+                intervals,
+                (int[] a, int[] b) -> {
+                    if (a[0] == b[0]) return Integer.compare(a[1], b[1]);
+                    return Integer.compare(a[0], b[0]);
+                });
+
+        List<List<Integer>> list = new ArrayList<>();
+        int i = 0;
+        while (i < intervals.length) {
+            // storing start
+            int start = intervals[i][0];
+            int end = intervals[i][1];
+            i++;
+            while (i < intervals.length && intervals[i][0] <= end) {
+                // making sure range is not shrinking
+                if (intervals[i][1] > end) {
+                    end = intervals[i][1];
+                }
+                i++;
+            }
+            List<Integer> temp = new ArrayList<>();
+            temp.add(start);
+            temp.add(end);
+            list.add(temp);
+        }
+        int[][] arr = new int[list.size()][2];
+        i = 0;
+        for (List<Integer> l : list) {
+            arr[i][0] = l.get(0);
+            arr[i][1] = l.get(1);
+            i++;
+        }
+        return arr;
+    }
+}

src/main/java/s0057_insert_interval/Solution.java

@@ -0,0 +1,29 @@
+package s0057_insert_interval;
+
+import java.util.Arrays;
+
+public class Solution {
+    public int[][] insert(int[][] intervals, int[] newInterval) {
+        int n = intervals.length;
+        int l = 0;
+        int r = n - 1;
+        while (l < n && newInterval[0] > intervals[l][1]) {
+            l++;
+        }
+        while (r >= 0 && newInterval[1] < intervals[r][0]) {
+            r--;
+        }
+
+        int[][] res = new int[l + n - r][2];
+        for (int i = 0; i < l; i++) {
+            res[i] = Arrays.copyOf(intervals[i], intervals[i].length);
+        }
+        res[l][0] = Math.min(newInterval[0], l == n ? newInterval[0] : intervals[l][0]);
+        res[l][1] = Math.max(newInterval[1], r == -1 ? newInterval[1] : intervals[r][1]);
+        for (int i = l + 1, j = r + 1; j < n; i++, j++) {
+            res[i] = intervals[j];
+        }
+
+        return res;
+    }
+}

src/main/java/s0058_length_of_last_word/Solution.java

@@ -0,0 +1,16 @@
+package s0058_length_of_last_word;
+
+public class Solution {
+    public int lengthOfLastWord(String str) {
+        int len = 0;
+        for (int i = str.length() - 1; i >= 0; i--) {
+            char ch = str.charAt(i);
+            if (ch == ' ' && len > 0) {
+                break;
+            } else if (ch != ' ') {
+                len++;
+            }
+        }
+        return len;
+    }
+}

src/main/java/s0059_spiral_matrix_ii/Solution.java

@@ -0,0 +1,35 @@
+package s0059_spiral_matrix_ii;
+
+public class Solution {
+    public int[][] generateMatrix(int n) {
+        int num = 1;
+        int rStart = 0;
+        int rEnd = n - 1;
+        int cStart = 0;
+        int cEnd = n - 1;
+        int[][] spiral = new int[n][n];
+        while (rStart <= rEnd && cStart <= cEnd) {
+            for (int k = cStart; k <= cEnd; k++) {
+                spiral[rStart][k] = num++;
+            }
+            rStart++;
+            for (int k = rStart; k <= rEnd; k++) {
+                spiral[k][cEnd] = num++;
+            }
+            cEnd--;
+            if (rStart <= rEnd) {
+                for (int k = cEnd; k >= cStart; k--) {
+                    spiral[rEnd][k] = num++;
+                }
+            }
+            rEnd--;
+            if (cStart <= cEnd) {
+                for (int k = rEnd; k >= rStart; k--) {
+                    spiral[k][cStart] = num++;
+                }
+            }
+            cStart++;
+        }
+        return spiral;
+    }
+}

src/main/java/s0060_permutation_sequence/Solution.java

@@ -0,0 +1,26 @@
+package s0060_permutation_sequence;
+
+public class Solution {
+    public String getPermutation(int n, int k) {
+        char[] res = new char[n];
+        k = k - 1; // We want the permutation sequence to be zero-indexed
+
+        int a = (1 << n) - 1; // The set bits indicate the available digits
+        int m = 1;
+        for (int i = 2; i < n; i++) m *= i; // m = (n - 1)!
+
+        for (int i = 0; i < n; i++) {
+            int b = a;
+            for (int j = 0; j < k / m; j++) b &= b - 1;
+            b &= ~b + 1; // b is the bit corresponding to the digit we want
+
+            res[i] = (char) ('1' + Integer.bitCount(b - 1));
+
+            a &= ~b; // Remove b from the set of available digits
+            k %= m;
+            m /= Math.max(1, n - i - 1);
+        }
+
+        return String.valueOf(res);
+    }
+}

src/main/java/s0061_rotate_list/Solution.java

@@ -0,0 +1,35 @@
+package s0061_rotate_list;
+
+import com_github_leetcode.ListNode;
+
+public class Solution {
+    public ListNode rotateRight(ListNode head, int k) {
+        if (head == null || k == 0) return head;
+        ListNode tail = head;
+        // find the count and let tail points to last node
+        int count = 1;
+        while (tail != null && tail.next != null) {
+            count++;
+            tail = tail.next;
+        }
+
+        // calculate number of times to rotate by count modulas
+        int times = k % count;
+        // if K=0 then return original
+        if (times == 0) return head;
+        ListNode temp = head;
+        // iterate and go to the K+1 th node from the end or count - K - 1 node from
+        // start
+        for (int i = 1; i <= count - times - 1 && temp != null; i++) {
+            temp = temp.next;
+        }
+        ListNode newHead = null;
+        if (temp != null && tail != null) {
+            newHead = temp.next;
+            temp.next = null;
+            tail.next = head;
+        }
+
+        return newHead;
+    }
+}