Add solutions

Author: andrewbayd

src/com/andrewbayd/MergeSortedArrays.java

@@ -0,0 +1,43 @@
+package com.andrewbayd;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/*
+You are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n,
+representing the number of elements in nums1 and nums2 respectively.
+Merge nums1 and nums2 into a single array sorted in non-decreasing order.
+
+https://leetcode.com/problems/merge-sorted-array/
+ */
+
+public class MergeSortedArrays {
+    public static void merge(int[] nums1, int m, int[] nums2, int n) {
+        if (nums2.length == 0) return;
+
+        List<Integer> temp = new ArrayList<>();
+
+        int first = 0;
+        int second = 0;
+
+        for (int i = 0; i < n + m; i++) {
+            if (first < m && (second == n || nums1[first] <= nums2[second])) {
+                temp.add(nums1[first++]);
+            } else {
+                temp.add(nums2[second++]);
+            }
+        }
+
+        for (int i = 0; i < n + m; i++) {
+            nums1[i] = temp.get(i);
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] nums1 = {1, 2, 3, 0, 0, 0};
+        int[] nums2 = {2, 5, 6};
+        merge(nums1, 3, nums2, 3);
+        System.out.println(Arrays.toString(nums1)); //-> [1, 2, 2, 3, 5, 6]
+    }
+}

src/com/andrewbayd/PlusOne.java

@@ -0,0 +1,52 @@
+package com.andrewbayd;
+
+import java.util.Arrays;
+
+/*
+You are given a large integer represented as an integer array digits, where each digits[i] is the ith digit of the integer.
+Increment the large integer by one and return the resulting array of digits.
+
+https://leetcode.com/problems/plus-one/
+ */
+
+public class PlusOne {
+    public static int[] plusOne(int[] digits) {
+        if (digits[digits.length - 1] < 9) {
+            digits[digits.length - 1]++;
+            return digits;
+        }
+
+        int add = 0;
+        for (int i = digits.length - 1; i >= 0; i--) {
+            if (i == digits.length - 1) {
+                digits[i]++;
+            }
+            if (add == 1) {
+                digits[i]++;
+                add--;
+            }
+            if (digits[i] >= 10) {
+                digits[i] = digits[i] % 10;
+                add++;
+            }
+        }
+
+        if (add == 0) {
+            return digits;
+        }
+
+        int[] result = new int[digits.length + 1];
+        result[0] = 1;
+        for (int i = 1; i < result.length - 1; i++) {
+            result[i] = digits[i - 1];
+        }
+
+        return result;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(Arrays.toString(plusOne(new int[]{1, 2, 4}))); //-> [1, 2, 5]
+        System.out.println(Arrays.toString(plusOne(new int[]{2, 6, 9}))); //-> [2, 7, 0]
+        System.out.println(Arrays.toString(plusOne(new int[]{9, 9}))); //-> [1, 0, 0]
+    }
+}

src/com/andrewbayd/ReverseString.java

@@ -0,0 +1,26 @@
+package com.andrewbayd;
+
+import java.util.Arrays;
+
+/*
+Write a function that reverses a string. The input string is given as an array of characters s.
+You must do this by modifying the input array in-place with O(1) extra memory.
+
+https://leetcode.com/problems/reverse-string/
+ */
+
+public class ReverseString {
+    public static void reverseString(char[] s) {
+        for (int i = 0; i < s.length / 2; i++) {
+            char temp = s[i];
+            s[i] = s[s.length - 1 - i];
+            s[s.length - 1 - i] = temp;
+        }
+    }
+
+    public static void main(String[] args) {
+        char[] string = {'h', 'e', 'l', 'l', 'o'};
+        reverseString(string);
+        System.out.println(Arrays.toString(string)); //-> ["o","l","l","e","h"]
+    }
+}

src/com/andrewbayd/RotateImage.java

@@ -0,0 +1,44 @@
+package com.andrewbayd;
+
+/*
+You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise).
+You have to rotate the image in-place, which means you have to modify the input 2D matrix directly.
+DO NOT allocate another 2D matrix and do the rotation.
+
+https://leetcode.com/problems/rotate-image/
+ */
+
+import java.util.Arrays;
+
+public class RotateImage {
+    // rotate = transpose + reflect
+    public static void rotate(int[][] matrix) {
+        int n = matrix.length;
+        // base case
+        if (n <= 1) {
+            return;
+        }
+        //transpose
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                int temp = matrix[i][j];
+                matrix[i][j] = matrix[j][i];
+                matrix[j][i] = temp;
+            }
+        }
+        //reflect
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n / 2; j++) {
+                int temp = matrix[i][j];
+                matrix[i][j] = matrix[i][n-1-j];
+                matrix[i][n-1-j] = temp;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        int[][] matrix = {{1,2,3},{4,5,6},{7,8,9}};
+        rotate(matrix);
+        Arrays.stream(matrix).map(Arrays::toString).forEach(System.out::println);
+    }
+}

src/com/andrewbayd/SetMatrixZeroes.java

@@ -0,0 +1,60 @@
+package com.andrewbayd;
+
+import java.util.Arrays;
+
+/*
+Given an m x n integer matrix, if an element is 0, set its entire row and column to 0's.
+You must do it in place.
+
+https://leetcode.com/problems/set-matrix-zeroes/
+ */
+
+public class SetMatrixZeroes {
+    public static void setZeroes(int[][] matrix) {
+        int n = matrix.length;
+        int m = matrix[0].length;
+        boolean isFirstRow = false;
+        boolean isFirstColumn = false;
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (matrix[i][j] == 0) {
+                    if (i == 0 && !isFirstRow) {
+                        isFirstRow = true;
+                    }
+                    if (j == 0 && !isFirstColumn) {
+                        isFirstColumn = true;
+                    }
+                    matrix[0][j] = 0;
+                    matrix[i][0] = 0;
+                }
+            }
+        }
+
+        for (int i = 1; i < n; i++) {
+            for (int j = 1; j < m; j++) {
+                if (matrix[0][j] == 0 || matrix[i][0] == 0) {
+                    matrix[i][j] = 0;
+                }
+            }
+        }
+
+        if (isFirstRow) {
+            for (int j = 0; j < m; j++) {
+                matrix[0][j] = 0;
+            }
+        }
+
+        if (isFirstColumn) {
+            for (int i = 0; i < n; i++) {
+                matrix[i][0] = 0;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        int[][] matrix = {{1,2,3,4},{5,0,7,8}, {0,10,11,12},{13,14,15,0}};
+        setZeroes(matrix);
+        Arrays.stream(matrix).map(Arrays::toString).forEach(System.out::println);
+    }
+}

src/com/andrewbayd/SpiralMatrix.java

@@ -0,0 +1,54 @@
+package com.andrewbayd;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/*
+Given an m x n matrix, return all elements of the matrix in spiral order.
+
+https://leetcode.com/problems/spiral-matrix/
+ */
+
+public class SpiralMatrix {
+    public static List<Integer> spiralOrder(int[][] matrix) {
+        List<Integer> elements = new ArrayList<>();
+
+        int topRow = 0;
+        int bottomRow = matrix.length - 1;
+        int leftColumn = 0;
+        int rightColumn = matrix[0].length - 1;
+
+        while (topRow <= bottomRow && leftColumn <= rightColumn) {
+            for (int i = leftColumn; i <= rightColumn; i++) {
+                elements.add(matrix[topRow][i]);
+            }
+            topRow++;
+
+            for (int i = topRow; i <= bottomRow; i++) {
+                elements.add(matrix[i][rightColumn]);
+            }
+            rightColumn--;
+
+            if (topRow <= bottomRow) {
+                for (int i = rightColumn; i >= leftColumn; i--) {
+                    elements.add(matrix[bottomRow][i]);
+                }
+            }
+            bottomRow--;
+
+            if (leftColumn <= rightColumn) {
+                for (int i = bottomRow; i >= topRow; i--) {
+                    elements.add(matrix[i][leftColumn]);
+                }
+            }
+            leftColumn++;
+        }
+
+        return elements;
+    }
+
+    public static void main(String[] args) {
+        int[][] matrix = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
+        System.out.println(spiralOrder(matrix)); //-> [1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7]
+    }
+}

src/com/andrewbayd/StrStr.java

@@ -0,0 +1,29 @@
+package com.andrewbayd;
+
+/*
+Given two strings needle and haystack, return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.
+
+https://leetcode.com/problems/implement-strstr/
+ */
+
+public class StrStr {
+    public int strStr(String haystack, String needle) {
+        if (needle.length() == 0) return 0;
+        if (needle.length() > haystack.length()) return -1;
+
+        for (int i = 0; i < haystack.length(); i++) {
+            if (i + needle.length() <= haystack.length() && haystack.startsWith(needle, i)) return i;
+        }
+
+        return -1;
+    }
+
+    public static void main(String[] args) {
+        StrStr str = new StrStr();
+        System.out.println(str.strStr("hello", "ll")); //->2
+        System.out.println(str.strStr("a", "a")); //->0
+        System.out.println(str.strStr("mississippi", "issip")); //->4
+        System.out.println(str.strStr("aa", "aaa")); //->-1
+        System.out.println(str.strStr("aaa", "")); //->0
+    }
+}

src/com/andrewbayd/binaryTreeInOrderTraversal/Solution.java

@@ -0,0 +1,27 @@
+package com.andrewbayd.binaryTreeInOrderTraversal;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/*
+Given the root of a binary tree, return the inorder traversal of its nodes' values.
+
+https://leetcode.com/problems/binary-tree-inorder-traversal/
+ */
+
+public class Solution {
+    public List<Integer> inorderTraversal(TreeNode root) {
+        List<Integer> result = new ArrayList<>();
+        traversalRecursive(root, result);
+        return result;
+    }
+
+    private void traversalRecursive(TreeNode root, List<Integer> result) {
+        if (root == null) {
+            return;
+        }
+        traversalRecursive(root.left, result);
+        result.add(root.val);
+        traversalRecursive(root.right, result);
+    }
+}

src/com/andrewbayd/binaryTreeInOrderTraversal/TreeNode.java

@@ -0,0 +1,20 @@
+package com.andrewbayd.binaryTreeInOrderTraversal;
+
+public class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+
+    TreeNode() {
+    }
+
+    TreeNode(int val) {
+        this.val = val;
+    }
+
+    TreeNode(int val, TreeNode left, TreeNode right) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+}

src/com/andrewbayd/deleteNodeInLinkedList/ListNode.java

@@ -0,0 +1,10 @@
+package com.andrewbayd.deleteNodeInLinkedList;
+
+public class ListNode {
+    int val;
+    ListNode next;
+
+    ListNode(int x) {
+        val = x;
+    }
+}

src/com/andrewbayd/deleteNodeInLinkedList/Solution.java

@@ -0,0 +1,15 @@
+package com.andrewbayd.deleteNodeInLinkedList;
+
+/*
+Write a function to delete a node in a singly-linked list. You will not be given access to the head of the list, instead you will be given access to the node to be deleted directly.
+It is guaranteed that the node to be deleted is not a tail node in the list.
+
+https://leetcode.com/problems/delete-node-in-a-linked-list/
+ */
+
+public class Solution {
+    public void deleteNode(ListNode node) {
+        node.val = node.next.val;
+        node.next = node.next.next;
+    }
+}