Remove README from solutions branch

Arrays/118_Pascale_Triangle.java

@@ -0,0 +1,18 @@
+class Solution {
+    public List<List<Integer>> generate(int numRows) {
+        List<List<Integer>> result = new ArrayList<>();
+        List<Integer> row = new ArrayList<>();
+
+        for (int i = 0; i < numRows; i++) {
+            row.add(0, 1);
+
+            for (int j = 1; j < row.size() - 1; j++) {
+                row.set(j, row.get(j) + row.get(j + 1));
+            }
+
+            result.add(new ArrayList<Integer>(row));
+        }
+
+        return result;
+    }
+}

Arrays/119_Pascale_Triangle_II.java

@@ -0,0 +1,15 @@
+class Solution {
+    public List<Integer> getRow(int rowIndex) {
+        List<Integer> row = new ArrayList<>();
+
+        for (int i = 0; i <= rowIndex; i++) {
+            row.add(0, 1);
+
+            for (int j = 1; j < row.size() - 1; j++) {
+                row.set(j, row.get(j) + row.get(j + 1));
+            }
+        }
+
+        return row;
+    }
+}

Arrays/121_Best_Time_to_Buy_and_Sell_Stock.java

@@ -0,0 +1,19 @@
+class Solution {
+    public int maxProfit(int[] prices) {
+        if (prices == null || prices.length == 0) {
+            return 0;
+        }
+
+        int minPrices = prices[0], profit = 0;
+
+        for (int i = 1; i < prices.length; i++) {
+            if (prices[i] < minPrices) {
+                minPrices = Math.min(minPrices, prices[i]);
+            }
+
+            profit = Math.max(profit, prices[i] - minPrices);
+        }
+
+        return profit;
+    }
+}

Arrays/122_Best_Time_to_Buy_and_Sell_Stock_II.java

@@ -0,0 +1,28 @@
+class Solution {
+    public int maxProfit(int[] prices) {
+        if (prices == null || prices.length == 0) {
+            return 0;
+        }
+
+        int idx = 0, buy = prices[idx], sell = prices[idx], profit = 0;
+        int N = prices.length - 1;
+
+        while (idx < N) {
+            while (idx < N && prices[idx + 1] <= prices[idx]) {
+                idx++;
+            }
+
+            buy = prices[idx];
+
+            while (idx < N && prices[idx + 1] > prices[idx]) {
+                idx++;
+            }
+
+            sell = prices[idx];
+
+            profit += sell - buy;
+        }
+
+        return profit;
+    }
+}

Arrays/128_Longest_Consecutive_Sequence.java

@@ -0,0 +1,27 @@
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
+
+        int max = 0;
+        Set<Integer> set = new HashSet<>();
+        for (int num : nums) {
+            set.add(num);
+        }
+
+        for (int startingNum : nums) {
+            if (!set.contains(startingNum - 1)) {
+                int nextVal = startingNum;
+
+                while (set.contains(nextVal)) {
+                    ++nextVal;
+                }
+
+                max = Math.max(max, nextVal - startingNum);
+            }
+        }
+
+        return max;
+    }
+}

Arrays/169_Majority_Element.java

@@ -0,0 +1,16 @@
+class Solution {
+    public int majorityElement(int[] nums) {
+        Map<Integer, Integer> hm = new HashMap<>();
+        int n = nums.length;
+        int result = 0;
+
+        for (int i = 0; i < n; i++) {
+            hm.put(nums[i], hm.getOrDefault(nums[i], 0) + 1);
+            if (hm.get(nums[i]) > n / 2) {
+                result = nums[i];
+            }
+        }
+
+        return result;
+    }
+}

Arrays/238_Product_Of_Array_Except_Itself.java

@@ -0,0 +1,24 @@
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return new int[] {};
+        }
+
+        int[] result = new int[nums.length];
+        int productSoFar = 1;
+
+        for (int i = 0; i < nums.length; i++) {
+            result[i] = productSoFar;
+            productSoFar *= nums[i];
+        }
+
+        productSoFar = 1;
+
+        for (int i = nums.length - 1; i >= 0; i--) {
+            result[i] *= productSoFar;
+            productSoFar *= nums[i];
+        }
+
+        return result;
+    }
+}

Arrays/268_Missing_Number.java

@@ -0,0 +1,15 @@
+class Solution {
+    public int missingNumber(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
+
+        long sum = nums.length;
+
+        for (int i = 0; i < nums.length; i++) {
+            sum += (i - nums[i]);
+        }
+
+        return (int) sum;
+    }
+}

Arrays/283_Move_Zeroes.java

@@ -0,0 +1,19 @@
+class Solution {
+    public void moveZeroes(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return;
+        }
+
+        int curr = 0;
+
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] != 0) {
+                nums[curr++] = nums[i];
+            }
+        }
+
+        for (int j = curr; j < nums.length; j++) {
+            nums[j] = 0;
+        }
+    }
+}

Arrays/287_Find_the_Duplicate_Number.java

@@ -0,0 +1,23 @@
+class Solution {
+    public int findDuplicate(int[] nums) {
+        if (nums == null || nums.length <= 1) {
+            return -1;
+        }
+
+        int slow = nums[0], fast = nums[nums[0]];
+
+        while (nums[slow] != nums[fast]) {
+            slow = nums[slow];
+            fast = nums[nums[fast]];
+        }
+
+        fast = 0;
+
+        while (slow != fast) {
+            slow = nums[slow];
+            fast = nums[fast];
+        }
+
+        return slow;
+    }
+}

Arrays/31_Next_Permutation.java

@@ -0,0 +1,44 @@
+class Solution {
+    public void nextPermutation(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return;
+        }
+
+        int n = nums.length - 1, idx = -1;
+
+        for (int i = n - 1; i >= 0; i--) {
+            if (nums[i] < nums[i + 1]) {
+                idx = i;
+                break;
+            }
+        }
+
+        if (idx == -1) {
+            reverseArray(nums, 0, n);
+            return;
+        }
+
+        for (int i = n; i >= 0; i--) {
+            if (nums[i] > nums[idx]) {
+                swap(nums, i, idx);
+                break;
+            }
+        }
+
+        reverseArray(nums, idx + 1, n);
+    }
+
+    private void reverseArray(int[] nums, int start, int end) {
+        while (start < end) {
+            swap(nums, start, end);
+            ++start;
+            --end;
+        }
+    }
+
+    private void swap(int[] nums, int i, int j) {
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+}

Arrays/334_Increasing_Triplet_Subsequence.java

@@ -0,0 +1,21 @@
+class Solution {
+    public boolean increasingTriplet(int[] nums) {
+        if (nums == null || nums.length < 3) {
+            return false;
+        }
+
+        int small = Integer.MAX_VALUE, big = Integer.MAX_VALUE;
+
+        for (int num : nums) {
+            if (num <= small) {
+                small = num;
+            } else if (num <= big) {
+                big = num;
+            } else {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

Arrays/349_Intersection_of_Two_Arrays.java

@@ -0,0 +1,24 @@
+class Solution {
+    public int[] intersection(int[] nums1, int[] nums2) {
+        Set<Integer> set = new HashSet<>();
+        Set<Integer> intersection = new HashSet<>();
+
+        for (int i = 0; i < nums1.length; i++) {
+            set.add(nums1[i]);
+        }
+
+        for (int i = 0; i < nums2.length; i++) {
+            if (set.contains(nums2[i])) {
+                intersection.add(nums2[i]);
+            }
+        }
+
+        int[] result = new int[intersection.size()];
+        int idx = 0;
+        for (int i : intersection) {
+            result[idx++] = i;
+        }
+
+        return result;
+    }
+}

Arrays/350_Intersection_of_Two_Arrays_II.java

@@ -0,0 +1,26 @@
+class Solution {
+    public int[] intersect(int[] nums1, int[] nums2) {
+        HashMap<Integer, Integer> hm = new HashMap<>();
+        ArrayList<Integer> intersection = new ArrayList<>();
+
+        for (int i = 0; i < nums1.length; i++) {
+            hm.put(nums1[i], hm.getOrDefault(nums1[i], 0) + 1);
+        }
+
+        for (int i = 0; i < nums2.length; i++) {
+            int freq = hm.getOrDefault(nums2[i], 0);
+            if (freq > 0) {
+                intersection.add(nums2[i]);
+                hm.put(nums2[i], --freq);
+            }
+        }
+
+        int[] result = new int[intersection.size()];
+        int idx = 0;
+        for (int commonVal : intersection) {
+            result[idx++] = commonVal;
+        }
+
+        return result;
+    }
+}

Arrays/41_First_Missing_Positive.java

@@ -0,0 +1,39 @@
+class Solution {
+    public int firstMissingPositive(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return 1;
+        }
+
+        int len = nums.length;
+
+        for (int i = 0; i < len; i++) {
+            if (nums[i] <= 0 || nums[i] > len) {
+                nums[i] = len + 1;
+            }
+
+            System.out.println(nums[i]);
+        }
+
+        for (int i = 0; i < len; i++) {
+            int idx = Math.abs(nums[i]);
+
+            if (idx > len) {
+                continue;
+            }
+
+            --idx;
+
+            if (nums[idx] > 0) {
+                nums[idx] = -nums[idx];
+            }
+        }
+
+        for (int i = 0; i < len; i++) {
+            if (nums[i] >= 0) {
+                return i + 1;
+            }
+        }
+
+        return len + 1;
+    }
+}

Arrays/442_Find_All_Duplicates_in_an_Array.java

@@ -0,0 +1,21 @@
+class Solution {
+    public List<Integer> findDuplicates(int[] nums) {
+        List<Integer> result = new ArrayList<>();
+
+        if (nums == null || nums.length <= 1) {
+            return result;
+        }
+
+        for (int i = 0; i < nums.length; i++) {
+            int idx = Math.abs(nums[i]) - 1;
+
+            if (nums[idx] < 0) {
+                result.add(idx + 1);
+            }
+
+            nums[idx] = -nums[idx];
+        }
+
+        return result;
+    }
+}