add more problem solutions

Author: Kevin Naughton Jr

.DS_Store

@@ -0,0 +1,23 @@
+//Given a non-negative integer num, repeatedly add all its digits until the result has only one digit.
+
+//For example:
+//Given num = 38, the process is like: 3 + 8 = 11, 1 + 1 = 2. Since 2 has only one digit, return it.
+
+//Follow up:
+//Could you do it without any loop/recursion in O(1) runtime?
+
+class AddDigits {
+    public int addDigits(int num) {
+        while(num >= 10) {
+            int temp = 0;
+            while(num > 0) {
+                temp += num % 10;
+                num /= 10;
+            }
+            num = temp;
+        }
+        
+        return num;
+    }
+}
+

company/adobe/AddDigits.java

@@ -0,0 +1,19 @@
+//Given an array of integers and an integer k, find out whether there are two distinct indices i and 
+//j in the array such that nums[i] = nums[j] and the absolute difference between i and j is at most k.
+
+class ContainsDuplicatesII {
+    public boolean containsNearbyDuplicate(int[] nums, int k) {
+        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
+        for(int i = 0; i < nums.length; i++) {
+            int current = nums[i];
+            if(map.containsKey(current) && i - map.get(current) <= k) {
+                return true;
+            } else {
+                map.put(current, i);
+            }
+        }
+        
+        return false;
+    }
+}
+

company/airbnb/ContainsDuplicatesII.java

@@ -0,0 +1,31 @@
+//Given a linked list, determine if it has a cycle in it.
+//Follow up:
+//Can you solve it without using extra space?
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public boolean hasCycle(ListNode head) {
+        if(head == null || head.next == null) {
+            return false;
+        }
+        
+        ListNode slow = head;
+        ListNode fast = head.next;
+        while(fast != null && fast.next != null && fast != slow) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        
+        return fast == slow;
+    }
+}
+

company/amazon/LinkedListCycle.java

@@ -0,0 +1,31 @@
+//Given a linked list, determine if it has a cycle in it.
+//Follow up:
+//Can you solve it without using extra space?
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public boolean hasCycle(ListNode head) {
+        if(head == null || head.next == null) {
+            return false;
+        }
+        
+        ListNode slow = head;
+        ListNode fast = head.next;
+        while(fast != null && fast.next != null && fast != slow) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        
+        return fast == slow;
+    }
+}
+

company/bloomberg/LinkedListCycle.java

@@ -0,0 +1,23 @@
+//Given a non-negative integer num, repeatedly add all its digits until the result has only one digit.
+
+//For example:
+//Given num = 38, the process is like: 3 + 8 = 11, 1 + 1 = 2. Since 2 has only one digit, return it.
+
+//Follow up:
+//Could you do it without any loop/recursion in O(1) runtime?
+
+class AddDigits {
+    public int addDigits(int num) {
+        while(num >= 10) {
+            int temp = 0;
+            while(num > 0) {
+                temp += num % 10;
+                num /= 10;
+            }
+            num = temp;
+        }
+        
+        return num;
+    }
+}
+

company/microsoft/AddDigits.java

@@ -0,0 +1,31 @@
+//Given a linked list, determine if it has a cycle in it.
+//Follow up:
+//Can you solve it without using extra space?
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public boolean hasCycle(ListNode head) {
+        if(head == null || head.next == null) {
+            return false;
+        }
+        
+        ListNode slow = head;
+        ListNode fast = head.next;
+        while(fast != null && fast.next != null && fast != slow) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        
+        return fast == slow;
+    }
+}
+

company/microsoft/LinkedListCycle.java

@@ -0,0 +1,19 @@
+//Given an array of integers and an integer k, find out whether there are two distinct indices i and 
+//j in the array such that nums[i] = nums[j] and the absolute difference between i and j is at most k.
+
+class ContainsDuplicatesII {
+    public boolean containsNearbyDuplicate(int[] nums, int k) {
+        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
+        for(int i = 0; i < nums.length; i++) {
+            int current = nums[i];
+            if(map.containsKey(current) && i - map.get(current) <= k) {
+                return true;
+            } else {
+                map.put(current, i);
+            }
+        }
+        
+        return false;
+    }
+}
+

company/palantir/ContainsDuplicatesII.java

@@ -0,0 +1,31 @@
+//Given a linked list, determine if it has a cycle in it.
+//Follow up:
+//Can you solve it without using extra space?
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public boolean hasCycle(ListNode head) {
+        if(head == null || head.next == null) {
+            return false;
+        }
+        
+        ListNode slow = head;
+        ListNode fast = head.next;
+        while(fast != null && fast.next != null && fast != slow) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        
+        return fast == slow;
+    }
+}
+

company/yahoo/LinkedListCycle.java

@@ -0,0 +1,18 @@
+//Given an array of integers and an integer k, find out whether there are two distinct indices i and 
+//j in the array such that nums[i] = nums[j] and the absolute difference between i and j is at most k.
+
+class ContainsDuplicatesII {
+    public boolean containsNearbyDuplicate(int[] nums, int k) {
+        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
+        for(int i = 0; i < nums.length; i++) {
+            int current = nums[i];
+            if(map.containsKey(current) && i - map.get(current) <= k) {
+                return true;
+            } else {
+                map.put(current, i);
+            }
+        }
+        
+        return false;
+    }
+}

leetcode/.DS_Store

@@ -0,0 +1,20 @@
+//Given an array and a value, remove all instances of that value in-place and return the new length.
+//Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.
+//The order of elements can be changed. It doesn't matter what you leave beyond the new length.
+
+//Example:
+//Given nums = [3,2,2,3], val = 3,
+//Your function should return length = 2, with the first two elements of nums being 2.
+
+class RemoveElement {
+    public int removeElement(int[] nums, int val) {
+        int index = 0;
+        for(int i = 0; i < nums.length; i++) {
+            if(nums[i] != val) {
+                nums[index++] = nums[i];
+            }
+        }
+        
+        return index;
+    }
+}

leetcode/array/ContainsDuplicatesII.java

@@ -0,0 +1,19 @@
+//Given an array of integers and an integer k, find out whether there are two distinct indices i and 
+//j in the array such that nums[i] = nums[j] and the absolute difference between i and j is at most k.
+
+class ContainsDuplicatesII {
+    public boolean containsNearbyDuplicate(int[] nums, int k) {
+        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
+        for(int i = 0; i < nums.length; i++) {
+            int current = nums[i];
+            if(map.containsKey(current) && i - map.get(current) <= k) {
+                return true;
+            } else {
+                map.put(current, i);
+            }
+        }
+        
+        return false;
+    }
+}
+

leetcode/array/RemoveElement.java

@@ -0,0 +1,27 @@
+//Given an array of integers, every element appears three times except for one, 
+//which appears exactly once. Find that single one.
+
+//Note:
+//Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
+
+class SingleNumberII {
+    public int singleNumber(int[] nums) {
+        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
+        for(int i: nums) {
+            if(map.containsKey(i)) {
+                map.put(i, map.get(i) + 1);
+            } else {
+                map.put(i, 1);
+            }
+        }
+        
+        for(int key: map.keySet()) {
+            if(map.get(key) == 1) {
+                return key;
+            }
+        }
+        
+        //no unique integer in nums
+        return -1;
+    }
+}

leetcode/hash-table/ContainsDuplicatesII.java

@@ -0,0 +1,31 @@
+//Given a linked list, determine if it has a cycle in it.
+//Follow up:
+//Can you solve it without using extra space?
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public boolean hasCycle(ListNode head) {
+        if(head == null || head.next == null) {
+            return false;
+        }
+        
+        ListNode slow = head;
+        ListNode fast = head.next;
+        while(fast != null && fast.next != null && fast != slow) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        
+        return fast == slow;
+    }
+}
+

leetcode/hash-table/SingleNumberII.java

@@ -0,0 +1,22 @@
+//Given a non-negative integer num, repeatedly add all its digits until the result has only one digit.
+
+//For example:
+//Given num = 38, the process is like: 3 + 8 = 11, 1 + 1 = 2. Since 2 has only one digit, return it.
+
+//Follow up:
+//Could you do it without any loop/recursion in O(1) runtime?
+
+class AddDigits {
+    public int addDigits(int num) {
+        while(num >= 10) {
+            int temp = 0;
+            while(num > 0) {
+                temp += num % 10;
+                num /= 10;
+            }
+            num = temp;
+        }
+        
+        return num;
+    }
+}

leetcode/linked-list/LinkedListCycle.java

@@ -0,0 +1,30 @@
+//Given a linked list, determine if it has a cycle in it.
+//Follow up:
+//Can you solve it without using extra space?
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public boolean hasCycle(ListNode head) {
+        if(head == null || head.next == null) {
+            return false;
+        }
+        
+        ListNode slow = head;
+        ListNode fast = head.next;
+        while(fast != null && fast.next != null && fast != slow) {
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        
+        return fast == slow;
+    }
+}