adding new problems

Author: Kevin Naughton Jr

company/amazon/LongestPalindromicSubstring.java

@@ -0,0 +1,42 @@
+//Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.
+
+//Example:
+//Input: "babad"
+//Output: "bab"
+
+//Note: "aba" is also a valid answer.
+
+//Example:
+//Input: "cbbd"
+//Output: "bb"
+
+class LongestPalindromicSubstring {
+    public String longestPalindrome(String s) {
+        if(s == null || s.length() == 0) {
+            return "";
+        }
+        
+        String longestPalindromicSubstring = "";
+        for(int i = 0; i < s.length(); i++) {
+            for(int j = i + 1; j <= s.length(); j++) {
+                if(j - i > longestPalindromicSubstring.length() && isPalindrome(s.substring(i, j))) {
+                    longestPalindromicSubstring = s.substring(i, j);
+                }
+            }
+        }
+        
+        return longestPalindromicSubstring;
+    }
+    
+    public boolean isPalindrome(String s) {
+        int i = 0;
+        int j = s.length() - 1;
+        while(i <= j) {
+            if(s.charAt(i++) != s.charAt(j--)) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+}

company/bloomberg/LongestPalindromicSubstring.java

@@ -0,0 +1,43 @@
+//Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.
+
+//Example:
+//Input: "babad"
+//Output: "bab"
+
+//Note: "aba" is also a valid answer.
+
+//Example:
+//Input: "cbbd"
+//Output: "bb"
+
+class LongestPalindromicSubstring {
+    public String longestPalindrome(String s) {
+        if(s == null || s.length() == 0) {
+            return "";
+        }
+        
+        String longestPalindromicSubstring = "";
+        for(int i = 0; i < s.length(); i++) {
+            for(int j = i + 1; j <= s.length(); j++) {
+                if(j - i > longestPalindromicSubstring.length() && isPalindrome(s.substring(i, j))) {
+                    longestPalindromicSubstring = s.substring(i, j);
+                }
+            }
+        }
+        
+        return longestPalindromicSubstring;
+    }
+    
+    public boolean isPalindrome(String s) {
+        int i = 0;
+        int j = s.length() - 1;
+        while(i <= j) {
+            if(s.charAt(i++) != s.charAt(j--)) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+}
+

company/facebook/MinStack.java

@@ -0,0 +1,49 @@
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * MinStack obj = new MinStack();
+ * obj.push(x);
+ * obj.pop();
+ * int param_3 = obj.top();
+ * int param_4 = obj.getMin();
+ */
+class MinStack {
+    class Node {
+        int data;
+        int min;
+        Node next;
+        
+        public Node(int data, int min) {
+            this.data = data;
+            this.min = min;
+            this.next = null;
+        }
+    }
+    Node head;
+    
+    /** initialize your data structure here. */
+    public MinStack() {
+        
+    }
+    
+    public void push(int x) {
+        if(head == null) {
+            head = new Node(x, x);
+        } else {
+            Node newNode = new Node(x, Math.min(x, head.min));
+            newNode.next = head;
+            head = newNode;
+        }
+    }
+    
+    public void pop() {
+        head = head.next;
+    }
+    
+    public int top() {
+        return head.data;
+    }
+    
+    public int getMin() {
+        return head.min;
+    }
+}

company/microsoft/LongestPalindromicSubstring.java

@@ -0,0 +1,42 @@
+//Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.
+
+//Example:
+//Input: "babad"
+//Output: "bab"
+
+//Note: "aba" is also a valid answer.
+
+//Example:
+//Input: "cbbd"
+//Output: "bb"
+
+class LongestPalindromicSubstring {
+    public String longestPalindrome(String s) {
+        if(s == null || s.length() == 0) {
+            return "";
+        }
+        
+        String longestPalindromicSubstring = "";
+        for(int i = 0; i < s.length(); i++) {
+            for(int j = i + 1; j <= s.length(); j++) {
+                if(j - i > longestPalindromicSubstring.length() && isPalindrome(s.substring(i, j))) {
+                    longestPalindromicSubstring = s.substring(i, j);
+                }
+            }
+        }
+        
+        return longestPalindromicSubstring;
+    }
+    
+    public boolean isPalindrome(String s) {
+        int i = 0;
+        int j = s.length() - 1;
+        while(i <= j) {
+            if(s.charAt(i++) != s.charAt(j--)) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+}

leetcode/array/BestTimeToBuyAndSellStock.java

@@ -20,8 +20,8 @@ public int maxProfit(int[] prices) {
             return 0;
         }
 
-        int max = 0;
         int min = prices[0];
+        int max = 0;
 
         for(int i = 1; i < prices.length; i++) {
             if(prices[i] > min) {

leetcode/greedy/BestTimeToBuyAndSellStockII.java

@@ -0,0 +1,21 @@
+//Say you have an array for which the ith element is the price of a given stock on day i.
+//Design an algorithm to find the maximum profit. You may complete as many transactions as you 
+//like (ie, buy one and sell one share of the stock multiple times). However, you may not engage 
+//in multiple transactions at the same time (ie, you must sell the stock before you buy again).
+
+class BestTimeToBuyAndSellStockII {
+    public int maxProfit(int[] prices) {
+        if(prices == null || prices.length == 0) {
+            return 0;
+        }
+        
+        int profit = 0;
+        for(int i = 0; i < prices.length - 1; i++) {
+            if(prices[i] < prices[i + 1]) {
+                profit += prices[i + 1] - prices[i];
+            }
+        }
+        
+        return profit;
+    }
+}

leetcode/hash-table/FindAnagramMappings.java

@@ -0,0 +1,28 @@
+//Given two lists Aand B, and B is an anagram of A. B is an anagram of A means B is made by randomizing the order of the elements in A.
+//We want to find an index mapping P, from A to B. A mapping P[i] = j means the ith element in A appears in B at index j.
+//These lists A and B may contain duplicates. If there are multiple answers, output any of them.
+
+//For example, given
+//A = [12, 28, 46, 32, 50]
+//B = [50, 12, 32, 46, 28]
+
+//We should return
+//[1, 4, 3, 2, 0]
+//as P[0] = 1 because the 0th element of A appears at B[1], and P[1] = 4 because the 1st element of A appears at B[4], and so on.
+
+class FindAnagramMappings {
+    public int[] anagramMappings(int[] A, int[] B) {
+        int[] mapping = new int[A.length];
+        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
+        
+        for(int i = 0; i < B.length; i++) {
+            map.put(B[i], i);
+        }
+        
+        for(int i = 0; i < A.length; i++) {
+            mapping[i] = map.get(A[i]);
+        }
+        
+        return mapping;
+    }
+}

leetcode/hash-table/JewelsAndStones.java

@@ -0,0 +1,23 @@
+//You're given strings J representing the types of stones that are jewels, and S representing the stones you have.  
+//Each character in S is a type of stone you have.  You want to know how many of the stones you have are also jewels.
+
+//The letters in J are guaranteed distinct, and all characters in J and S are letters. Letters are case sensitive, 
+//so "a" is considered a different type of stone from "A".
+
+class JewelsAndStones {
+    public int numJewelsInStones(String J, String S) {
+        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
+        for(char c: J.toCharArray()) {
+            map.put(c, 1);
+        }
+        
+        int numberOfJewels = 0;
+        for(char c: S.toCharArray()) {
+            if(map.containsKey(c)) {
+                numberOfJewels++;
+            }
+        }
+        
+        return numberOfJewels;
+    }
+}

leetcode/hash-table/ValidAnagram.java

@@ -0,0 +1,30 @@
+class ValidAnagram {
+    public boolean isAnagram(String s, String t) {
+        HashMap<Character, Integer> map = new HashMap<Character, Integer>();
+        for(char c: s.toCharArray()) {
+            if(map.containsKey(c)) {
+                map.put(c, map.get(c) + 1);
+            }
+            else {
+                map.put(c, 1);
+            }
+        }
+        
+        for(char c: t.toCharArray()) {
+            if(map.containsKey(c)) {
+                map.put(c, map.get(c) - 1);
+            }
+            else {
+                return false;
+            }
+        }
+        
+        for(char c: map.keySet()) {
+            if(map.get(c) != 0) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+}

leetcode/math/PalindromeNumber.java

@@ -0,0 +1,19 @@
+//Determine whether an integer is a palindrome. Do this without extra space.
+
+class PalindromeNumber {
+    public boolean isPalindrome(int x) {
+        if(x < 0) {
+            return false;
+        }
+        
+        int num = x;
+        int reversed = 0;
+        
+        while(num != 0) {
+            reversed = reversed * 10 + num % 10;
+            num /= 10;
+        }
+        
+        return x == reversed;
+    }
+}

leetcode/math/PoorPigs.java

@@ -0,0 +1,20 @@
+//There are 1000 buckets, one and only one of them contains poison, the rest are filled with water. 
+//They all look the same. If a pig drinks that poison it will die within 15 minutes. What is the 
+//minimum amount of pigs you need to figure out which bucket contains the poison within one hour.
+
+//Answer this question, and write an algorithm for the follow-up general case.
+
+//Follow-up:
+//If there are n buckets and a pig drinking poison will die within m minutes, how many pigs (x) 
+//you need to figure out the "poison" bucket within p minutes? There is exact one bucket with poison.
+
+class PoorPigs {
+    public int poorPigs(int buckets, int minutesToDie, int minutesToTest) {    
+        int numPigs = 0;
+        while (Math.pow(minutesToTest / minutesToDie + 1, numPigs) < buckets) {
+            numPigs++;
+        }
+        
+        return numPigs;
+    }
+}

leetcode/stack/MinStack.java

@@ -0,0 +1,56 @@
+//Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
+//push(x) -- Push element x onto stack.
+//pop() -- Removes the element on top of the stack.
+//top() -- Get the top element.
+//getMin() -- Retrieve the minimum element in the stack.
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * MinStack obj = new MinStack();
+ * obj.push(x);
+ * obj.pop();
+ * int param_3 = obj.top();
+ * int param_4 = obj.getMin();
+ */
+class MinStack {
+    class Node {
+        int data;
+        int min;
+        Node next;
+        
+        public Node(int data, int min) {
+            this.data = data;
+            this.min = min;
+            this.next = null;
+        }
+    }
+    Node head;
+    
+    /** initialize your data structure here. */
+    public MinStack() {
+        
+    }
+    
+    public void push(int x) {
+        if(head == null) {
+            head = new Node(x, x);
+        } else {
+            Node newNode = new Node(x, Math.min(x, head.min));
+            newNode.next = head;
+            head = newNode;
+        }
+    }
+    
+    public void pop() {
+        head = head.next;
+    }
+    
+    public int top() {
+        return head.data;
+    }
+    
+    public int getMin() {
+        return head.min;
+    }
+}
+