Add new solutions

Author: andrewbayd

src/BinarySearch.java

@@ -0,0 +1,35 @@
+public class BinarySearch {
+
+    /*
+    Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1.
+    You must write an algorithm with O(log n) runtime complexity.
+
+    https://leetcode.com/problems/binary-search/
+     */
+
+    public static int search(int[] nums, int target) {
+        int min = 0;
+        int max = nums.length - 1;
+
+        while (min <= max) {
+            int mid = (min + max) / 2;
+
+            if (nums[mid] == target) {
+                return mid;
+            } else if (nums[mid] < target) {
+                min = mid + 1;
+            } else {
+                max = mid - 1;
+            }
+        }
+
+        return -1;
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {-1,0,3,5,9,12};
+
+        System.out.println(search(arr, 9)); //-> 4
+        System.out.println(search(arr, 2)); //-> -1
+    }
+}

src/com/andrewbayd/BestTimeToBuyAndSellStock.java

@@ -0,0 +1,33 @@
+package com.andrewbayd;
+
+public class BestTimeToBuyAndSellStock {
+
+    /*
+    You are given an array prices where prices[i] is the price of a given stock on the ith day.
+    You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock.
+    Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.
+
+    https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+     */
+
+    public static int maxProfit(int[] prices) {
+
+        int minPrice = prices[0];
+        int maxProfit = 0;
+
+        for (int i = 1; i < prices.length; i++) {
+            if (prices[i] <= minPrice) {
+                minPrice = prices[i];
+            } else  {
+                maxProfit = Math.max(maxProfit, prices[i] - minPrice);
+            }
+        }
+
+        return maxProfit;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(maxProfit(new int[]{7,1,5,3,6,4})); //-> 5
+        System.out.println(maxProfit(new int[]{7,6,4,3,1})); //-> 0
+    }
+}

src/com/andrewbayd/ClimbStairs.java

@@ -0,0 +1,30 @@
+package com.andrewbayd;
+
+public class ClimbStairs {
+
+    /*
+    You are climbing a staircase. It takes n steps to reach the top.
+    Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
+
+    https://leetcode.com/problems/climbing-stairs/
+     */
+
+    public static int climbStairs(int n) {
+        int x = 1;
+        int y = 1;
+
+        for (int i = 0; i < n - 1; i++) {
+            int temp = x;
+            x = x + y;
+            y = temp;
+        }
+
+        return x;
+    }
+
+    public static void main(String[] args) {
+        assert climbStairs(2) == 2;
+        assert climbStairs(3) == 3;
+        assert climbStairs(5) == 8;
+    }
+}

src/com/andrewbayd/ContainsDuplicate.java

@@ -0,0 +1,29 @@
+package com.andrewbayd;
+
+import java.util.HashSet;
+
+public class ContainsDuplicate {
+
+    /*
+    Given an integer array nums, return true if any value appears at least twice in the array, and return false if every element is distinct.
+
+    https://leetcode.com/problems/contains-duplicate/
+     */
+
+    public static boolean containsDuplicate(int[] nums) {
+        HashSet<Integer> passedElements = new HashSet<>();
+        for (int num : nums) {
+            if (passedElements.contains(num)) {
+                return true;
+            }
+            passedElements.add(num);
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+        assert containsDuplicate(new int[]{1, 2, 3, 1});
+        assert !containsDuplicate(new int[]{1, 2, 3, 4});
+        assert containsDuplicate(new int[]{1,1,1,3,3,4,3,2,4,2});
+    }
+}

src/com/andrewbayd/MissingNumber.java

@@ -0,0 +1,30 @@
+package com.andrewbayd;
+
+public class MissingNumber {
+
+    /*
+    Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array.
+
+    https://leetcode.com/problems/missing-number/
+     */
+
+    public static int missingNumber(int[] nums) {
+
+        int n = nums.length;
+        int sumArr = 0;
+        int sumFull = n;
+
+        for (int i = 0; i < n; i++) {
+            sumArr += nums[i];
+            sumFull += i;
+        }
+
+        return sumFull - sumArr;
+    }
+
+    public static void main(String[] args) {
+        assert missingNumber(new int[]{3,0,1}) == 2;
+        assert missingNumber(new int[]{0,1}) == 3;
+        assert missingNumber(new int[]{9,6,4,2,3,5,7,0,1}) == 8;
+    }
+}

src/com/andrewbayd/ValidPalindrome.java

@@ -0,0 +1,39 @@
+package com.andrewbayd;
+
+public class ValidPalindrome {
+
+    /*
+    A phrase is a palindrome if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters,
+    it reads the same forward and backward. Alphanumeric characters include letters and numbers.
+    Given a string s, return true if it is a palindrome, or false otherwise.
+
+    https://leetcode.com/problems/valid-palindrome/
+     */
+
+    public static boolean isPalindrome(String s) {
+
+        int left = 0;
+        int right = s.length() - 1;
+
+        while (left < right) {
+            if (!Character.isLetterOrDigit(s.charAt(left))) {
+                left++;
+            } else if (!Character.isLetterOrDigit(s.charAt(right))) {
+                right--;
+            } else if (Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))) {
+                return false;
+            } else {
+                left++;
+                right--;
+            }
+        }
+
+        return true;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(isPalindrome("A man, a plan, a canal: Panama"));//-> true
+        System.out.println(isPalindrome("race a car"));//-> false
+        System.out.println(isPalindrome(" "));//-> true
+    }
+}

src/com/andrewbayd/ValidParentheses.java

@@ -0,0 +1,40 @@
+package com.andrewbayd;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Stack;
+
+public class ValidParentheses {
+
+    /*
+    Given a string s containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.
+
+    https://leetcode.com/problems/valid-parentheses/
+     */
+
+    public static boolean isValid(String s) {
+
+        Map<Character, Character> map = Map.of(
+                '(', ')',
+                '{', '}',
+                '[', ']'
+        );
+        Stack<Character> stack = new Stack<>();
+
+        for (int i = 0; i < s.length(); i++) {
+            char current = s.charAt(i);
+            if (map.containsKey(current)) {
+                stack.push(current);
+            } else if (stack.isEmpty() || map.get(stack.pop()) != current) {
+                return false;
+            }
+        }
+
+        return stack.isEmpty();
+    }
+
+    public static void main(String[] args) {
+        System.out.println(isValid("()[]{}")); //-> true
+        System.out.println(isValid("([)]")); //-> false
+    }
+}