Reformat files

company/amazon/ThreeSum.java

@@ -0,0 +1,52 @@
+// Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
+
+// Note: The solution set must not contain duplicate triplets.
+
+// For example, given array S = [-1, 0, 1, 2, -1, -4],
+
+// A solution set is:
+// [
+// [-1, 0, 1],
+// [-1, -1, 2]
+// ]
+
+public class ThreeSum {
+ public List<List<Integer>> threeSum(int[] nums) {
+ List<List<Integer>> result = new ArrayList<>();
+ Arrays.sort(nums);
+ for(int i = 0; i < nums.length - 2; i++) {
+ if(i > 0 && nums[i] == nums[i - 1]) {
+ continue;
+ }
+
+ int j = i + 1;
+ int k = nums.length - 1;
+ int target = -nums[i];
+
+ while(j < k) {
+ if(nums[j] + nums[k] == target) {
+ ArrayList<Integer> temp = new ArrayList<Integer>();
+ temp.add(nums[i]);
+ temp.add(nums[j]);
+ temp.add(nums[k]);
+
+ result.add(temp);
+
+ j++;
+ k--;
+
+ while(j < k && nums[j] == nums[j - 1]) j++;
+ while(j < k && nums[k] == nums[k + 1]) k--;
+ }
+ else if(nums[j] + nums[k] > target) {
+ k--;
+ }
+ else {
+ j++;
+ }
+ }
+ }
+
+ return result;
+ }
+}

company/facebook/PowerOfXToTheN.java

@@ -0,0 +1,20 @@
+// Implement pow(x, n).
+
+public class PowerOfXToTheN {
+ public double myPow(double x, int n) {
+ if(n == 0) {
+ return 1;
+ }
+
+ if(Double.isInfinite(x)) {
+ return 0;
+ }
+
+ if(n < 0) {
+ n = -n;
+ x = 1 / x;
+ }
+
+ return n % 2 == 0 ? myPow(x * x, n / 2) : x * myPow(x * x, n / 2);
+ }
+}

company/facebook/SquareRootX.java

@@ -0,0 +1,28 @@
+// Implement int sqrt(int x).
+
+// Compute and return the square root of x.
+
+public class SquareRootX {
+ public int mySqrt(int x) {
+ if(x == 0) {
+ return 0;
+ }
+
+ int left = 1;
+ int right = x;
+
+ while(left <= right) {
+ int mid = left + (right - left) / 2;
+
+ if(mid == x / mid) {
+ return mid;
+ } else if(mid > x / mid) {
+ right = mid - 1;
+ } else if(mid < x / mid) {
+ left = mid + 1;
+ }
+ }
+
+ return right;
+ }
+}

company/google/LoggerRateLimit.java

@@ -0,0 +1,60 @@
+// Design a logger system that receive stream of messages along with its timestamps, each message should be printed if and only if it is not printed in the last 10 seconds.
+
+// Given a message and a timestamp (in seconds granularity), return true if the message should be printed in the given timestamp, otherwise returns false.
+
+// It is possible that several messages arrive roughly at the same time.
+
+// Example:
+
+// Logger logger = new Logger();
+
+// // logging string "foo" at timestamp 1
+// logger.shouldPrintMessage(1, "foo"); returns true; 
+
+// // logging string "bar" at timestamp 2
+// logger.shouldPrintMessage(2,"bar"); returns true;
+
+// // logging string "foo" at timestamp 3
+// logger.shouldPrintMessage(3,"foo"); returns false;
+
+// // logging string "bar" at timestamp 8
+// logger.shouldPrintMessage(8,"bar"); returns false;
+
+// // logging string "foo" at timestamp 10
+// logger.shouldPrintMessage(10,"foo"); returns false;
+
+// // logging string "foo" at timestamp 11
+// logger.shouldPrintMessage(11,"foo"); returns true;
+
+public class LoggerRateLimit {
+ HashMap<String, Integer> messages;
+
+ /** Initialize your data structure here. */
+ public Logger() {
+ this.messages = new HashMap<String, Integer>(); 
+ }
+
+ /** Returns true if the message should be printed in the given timestamp, otherwise returns false.
+ If this method returns false, the message will not be printed.
+ The timestamp is in seconds granularity. */
+ public boolean shouldPrintMessage(int timestamp, String message) {
+ if(messages.containsKey(message)) {
+ if(timestamp - messages.get(message) >= 10) {
+ messages.put(message, timestamp);
+
+ return true;
+ } else {
+ return false;
+ }
+ } else {
+ messages.put(message, timestamp);
+ return true;
+ }
+ }
+}
+
+/**
+ * Your Logger object will be instantiated and called as such:
+ * Logger obj = new Logger();
+ * boolean param_1 = obj.shouldPrintMessage(timestamp,message);
+ */

company/google/PowerOfXToTheN.java

@@ -0,0 +1,20 @@
+// Implement pow(x, n).
+
+public class PowerOfXToTheN {
+ public double myPow(double x, int n) {
+ if(n == 0) {
+ return 1;
+ }
+
+ if(Double.isInfinite(x)) {
+ return 0;
+ }
+
+ if(n < 0) {
+ n = -n;
+ x = 1 / x;
+ }
+
+ return n % 2 == 0 ? myPow(x * x, n / 2) : x * myPow(x * x, n / 2);
+ }
+}

company/google/Utf8Validation.java

@@ -0,0 +1,59 @@
+// A character in UTF8 can be from 1 to 4 bytes long, subjected to the following rules:
+
+// For 1-byte character, the first bit is a 0, followed by its unicode code.
+// For n-bytes character, the first n-bits are all one's, the n+1 bit is 0, followed by n-1 bytes with most significant 2 bits being 10.
+// This is how the UTF-8 encoding would work:
+
+// Char. number range | UTF-8 octet sequence
+// (hexadecimal) | (binary)
+// --------------------+---------------------------------------------
+// 0000 0000-0000 007F | 0xxxxxxx
+// 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
+// 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
+// 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+// Given an array of integers representing the data, return whether it is a valid utf-8 encoding.
+
+// Note:
+// The input is an array of integers. Only the least significant 8 bits of each integer is used to store the data. This means each integer represents only 1 byte of data.
+
+// Example 1:
+
+// data = [197, 130, 1], which represents the octet sequence: 11000101 10000010 00000001.
+
+// Return true.
+// It is a valid utf-8 encoding for a 2-bytes character followed by a 1-byte character.
+// Example 2:
+
+// data = [235, 140, 4], which represented the octet sequence: 11101011 10001100 00000100.
+
+// Return false.
+// The first 3 bits are all one's and the 4th bit is 0 means it is a 3-bytes character.
+// The next byte is a continuation byte which starts with 10 and that's correct.
+// But the second continuation byte does not start with 10, so it is invalid.
+
+public class Utf8Validation {
+ public boolean validUtf8(int[] data) {
+ int count = 0;
+ for(int i : data) {
+ if(count == 0) {
+ if((i >> 5) == 0b110) {
+ count = 1;
+ } else if((i >> 4) == 0b1110) {
+ count = 2;
+ } else if((i >> 3) == 0b11110) {
+ count = 3;
+ } else if((i >> 7) == 0b1) {
+ return false;
+ }
+ } else {
+ if((i >> 6) != 0b10) {
+ return false;
+ }
+
+ count--;
+ }
+ }
+
+ return count == 0;
+ }
+}

company/linkedin/PowerOfXToTheN.java

@@ -0,0 +1,20 @@
+// Implement pow(x, n).
+
+public class PowerOfXToTheN {
+ public double myPow(double x, int n) {
+ if(n == 0) {
+ return 1;
+ }
+
+ if(Double.isInfinite(x)) {
+ return 0;
+ }
+
+ if(n < 0) {
+ n = -n;
+ x = 1 / x;
+ }
+
+ return n % 2 == 0 ? myPow(x * x, n / 2) : x * myPow(x * x, n / 2);
+ }
+}

company/uber/PadlindromePermutation.java

@@ -0,0 +1,23 @@
+public class PalindromePermutation {
+ public boolean canPermutePalindrome(String s) {
+ char[] characters = new char[256];
+
+ for(int i = 0; i < s.length(); i++) {
+ characters[s.charAt(i)]++;
+ }
+
+ int oddCount = 0;
+
+ for(int i = 0; i < characters.length; i++) {
+ if(!(characters[i] % 2 == 0)) {
+ oddCount++;
+
+ if(oddCount > 1) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+}

cracking-the-coding-interview/Chapter1ArraysAndStrings/DeleteDups.java

@@ -0,0 +1,18 @@
+//Write code to remove duplicates from an unsorted linked list
+
+public class RemoveDups {
+ void deleteDups(LinkedListNode n) {
+ HashSet<Integer> set = new HashSet<Integer>();
+ LinkedListNode previous = null;
+ while(n != null) {
+ if(set.contains(n.data)) {
+ previous.next = n.next;
+ }
+ else {
+ set.add(n.data);
+ previous = n;
+ }
+ n = n.next;
+ }
+ }
+}

cracking-the-coding-interview/Chapter1ArraysAndStrings/IsRotation.java

@@ -0,0 +1,17 @@
+// Assume you have a method isSubstring which checks if one word is a isSubstring of another.
+// Given two strings, s1 and s2, write code to check if s2 is a rotation of s1 using only
+// one call to isSubstring(e.g., "waterbottle" is a rotation of "erbottlewat").
+
+public class IsRotation {
+ public boolean isRotation(String s1, String s2) {
+ int len = s1.length();
+ /*check that s1 and s2 are equal length and not empty */
+ if(len == s2.length() && len > 0) {
+ /* concatenate s1 and s1 within new buffer */
+ String s1s1 = s1 + s1;
+ return isSubstring(s1s1, s2);
+ }
+
+ return false;
+ }
+}

cracking-the-coding-interview/Chapter1ArraysAndStrings/IsUniqueChars.java

@@ -0,0 +1,15 @@
+//Implement an algorithm to determine if a string has all unique characters. What if you cannot use additional data structures?
+
+public class isUniqueChars {
+ public boolean isUniqueChars(String str) {
+ int checker = 0;
+ for(int i = 0; i < str.length(); i++) {
+ int val = str.charAt(i) - 'a';
+ if((checker & (1 << val)) > 0) {
+ return false;
+ }
+ checker |= (1 << val));
+ }
+ return true;
+ }
+}

cracking-the-coding-interview/Chapter1ArraysAndStrings/NthToLast.java

@@ -0,0 +1,27 @@
+//Implement an algorithm to find the kth to last element of a single linked list
+
+public class NthToLast {
+ LinkedListNode nthToLast(LinkedListNode head, int k) {
+ if(k <= 0) return null;
+
+ LinkedListNode p1 = head;
+ LinkedListNode p2 = head;
+
+ //move p2 forward k nodes into the list
+ for(int i = 0; i < k - 1; i++) {
+ if(p2 == null) return null; //error check
+ p2 = p2.next;
+ }
+
+ if(p2 == null) return null;
+
+ /* now, move p1 and p2 at the same speed. When p2 hits the end,
+ * p1 will be at the right element */
+ while(p2.next != null) {
+ p1 = p1.next;
+ p2 = p2.next;
+ }
+
+ return p1;
+ }
+}