Squash commit

.editorconfig

@@ -0,0 +1,11 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{js,py}]
+charset = utf-8
+indent_style = space
+indent_size = 4

README.md

@@ -0,0 +1,32 @@
+# Tech Interview Handbook
+
+Handbook to help you ace your next technical interview, with a focus on algorithms and the front end domain. System design questions are in-progress.
+
+This handbook is pretty new and help from you in contributing content would be very much appreciated!
+
+## Motivations
+
+While there are many awesome books like [Cracking the Coding Interview](http://www.crackingthecodinginterview.com/) and interview-related repositories on Github that contain a lot of algorithm questions, for more domain-specific and non-software engineering questions, there seems to be a lack in resources. This handbook aims to cover questions beyond the algorithm coding questions.
+
+## Contents
+
+- **[Algorithms Questions](algorithms)**
+  - Questions categorized by topic.
+- **[Design Questions](design)**
+- **[Domain-specific Questions](domain)**
+- **[Front End Study Notes](front-end)**
+  - Summarized notes on the various aspects of front end.
+  - [Front End Job Interview Questions and Answers](front-end/interview-questions.md) ⭐
+- **[Non-Technical Tips](non-technical)**
+  - Random non-technical tips that cover behavioral and psychological aspects, interview formats and "Do you have any questions for me?".
+  - [Behavioral Questions](non-technical/behavioral.md)
+  - [Interview Formats](non-technical/format.md)
+  - [Psychological Tricks](non-technical/psychological.md)
+  - [Questions to Ask](non-technical/questions-to-ask.md)
+  - [Negotiation Tips](non-technical/negotiation.md)
+- **[Utilities](utilities)**
+  - Snippets of algorithms/code that will help in coding questions.
+
+## Contributing
+
+There are no hard contributing guidelines at the moment as things are still in flux, might find a better approach to structure content, but we will figure out as we go along! Just contribute whatever that you think will help others. If you would like to contribute content for different domains, feel free to create an issue or submit a pull request and we can discuss further.

algorithms/array.md

@@ -0,0 +1,63 @@
+Arrays
+==
+
+- In an arrays of arrays, e.g. given `[[], [1, 2, 3], [4, 5], [], [], [6, 7], [8], [9, 10], [], []]`, print: `1, 2, 3, 4, 5, 6, 7, 8, 9, 10`.
+  - Implement an iterator that supports `hasNext()`, `next()` and `remove()` methods.
+- Given a list of item prices, find all possible combinations of items that sum a particular value `K`.
+- Paginate an array with constraints, such as skipping certain items.
+- Implement a circular buffer using an array.
+- Given array of arrays, sort them in ascending order.
+- Given an array of integers, print out a histogram of using said array; include a base layer (all stars)
+  - E.g. `[5, 4, 0, 3, 4, 1]`
+
+```
+*
+**  *
+** **
+** **
+** ***
+******
+```
+
+- Given an array and an index, find the product of the elements of the array except the element at that index.
+- Given a set of rectangles represented by a height and an interval along the y-axis, determine the size of its union.
+- Given 2 separate arrays, write a method to find the values that exist in both arrays and return them.
+- Given an array of integers find whether there is a sub-sequence that sums to 0 and return it.
+  - E.g. `[1, 2, -3, 1]` => `[1, 2, -3]` or `[2, -3, 1]`.
+- Given an input array and another array that describes a new index for each element, mutate the input array so that each element ends up in their new index. Discuss the runtime of the algorithm and how you can be sure there would not be any infinite loops.
+- Given an array of non-negative numbers, find continuous subarray with sum to S.
+  - [Source](http://blog.gainlo.co/index.php/2016/06/01/subarray-with-given-sum/).
+- Given an array of numbers list out all triplets that sum to 0. Do so with a running time of less than O(n^3).
+  - [Source](http://blog.gainlo.co/index.php/2016/07/19/3sum/).
+- Given an array of numbers list out all quadruplets that sum to 0. Do so with a running time of less than O(n^4).
+- Given an array of integers, move all the zeroes to the end while preserving the order of the other elements. You have to do it in-place and are not allowed to use any extra storage.
+- Given a list of people, and a function `knows(a, b)` that returns `true`/`false` if person `a` knows the person `b`. Write a function that finds a VIP, which everybody knows and he doesn't know anybody else.
+- Given an array of integers, find the subarray with the largest sum. Can you do it in linear time.
+  - Maximum subarray sum problem.
+- You have an array with the heights of an island (at point 1, point 2 etc) and you want to know how much water would remain on this island (without flowing away).
+  - Trapping rain water question.
+- Given a sequence of tasks like `A, B, C` (means 3 different tasks), and a cold time, which means you need to wait for that much time to start the next same task, output the best task-finishing sequence.
+  - E.g. input: `AAABBB, 2`, output: `AB_AB_AB` ( `_` represents do nothing and wait)
+- You are given a list of dominoes. Determine if any two of those dominoes add up to `[6, 6]`.
+  - E.g. `[1, 4]` + `[5, 2]`).
+- Given an array containing only digits `0-9`, add one to the number and return the array.
+  - E.g. Given `[1, 4, 2, 1]` which represents `1421`, return `[1, 4, 2, 2]` which represents `1422`.
+- Find the second maximum value in an array.
+- Given an array, find the longest arithmetic progression.
+- Rotate an array by an offset of k.
+- Remove duplicates in an unsorted array where the duplicates are at a distance of k or less from each other.
+- Given an unsorted list of integers, return true if the list contains any duplicates within k indices of each element. Do it faster than O(n^2).
+- Given an unsorted list of integers, return true if the list contains any fuzzy duplicates within k indices of each element. A fuzzy duplicate is another integer within d of the original integer. Do it faster than O(n^2).
+  - E.g. If d = 4, then 6 is a fuzzy duplicate of 3 but 8 is not.
+- Say you have an unordered list of numbers ranging from 1 to n, and one of the numbers is removed, how do you find that number? What if two numbers are removed?
+- Given an array of string, find the duplicated elements.
+  - [Source](http://blog.gainlo.co/index.php/2016/05/10/duplicate-elements-of-an-array/).
+- Given an array of integers, find a maximum sum of non-adjacent elements.
+  - E.g. `[1, 0, 3, 9, 2]` should return `10 (1 + 9)`.
+  - [Source](http://blog.gainlo.co/index.php/2016/12/02/uber-interview-question-maximum-sum-non-adjacent-elements/)
+- Given an array of integers, modify the array by moving all the zeros to the end (right side). The order of other elements doesn’t matter.
+  - E.g. `[1, 2, 0, 3, 0, 1, 2]`, the program can output `[1, 2, 3, 1, 2, 0, 0]`.
+  - [Source](http://blog.gainlo.co/index.php/2016/11/18/uber-interview-question-move-zeroes/).
+- Given an array, return the length of the longest increasing contiguous subarray.
+  - E.g., `[1, 3, 2, 3, 4, 8, 7, 9]`, should return `4` because the longest increasing array is `[2, 3, 4, 8]`.
+  - [Source](http://blog.gainlo.co/index.php/2017/02/02/uber-interview-questions-longest-increasing-subarray/).

algorithms/dynamic-programming.md

@@ -0,0 +1,27 @@
+Dynamic Programming
+==
+
+- Given a flight itinerary consisting of starting city, destination city, and ticket price (2D list) - find the optimal price flight path to get from start to destination. (A variation of Dynamic Programming Shortest Path)
+- Given some coin denominations and a target value `M`, return the coins combination with the minimum number of coins.
+  - Time complexity: `O(MN)`, where N is the number of distinct type of coins.
+  - Space complexity: `O(M)`.
+- Given a set of numbers in an array which represent number of consecutive days of AirBnb reservation requested, as a host, pick the sequence which maximizes the number of days of occupancy, at the same time, leaving at least a 1 day gap in-between bookings for cleaning.
+  - Problem reduces to finding the maximum sum of non-consecutive array elements.
+  - E.g.
+    ~~~
+    // [5, 1, 1, 5] => 10
+    The above array would represent an example booking period as follows -
+    // Dec 1 - 5
+    // Dec 5 - 6
+    // Dec 6 - 7
+    // Dec 7 - 12
+
+    The answer would be to pick Dec 1-5 (5 days) and then pick Dec 7-12 for a total of 10 days of occupancy, at the same time, leaving at least 1 day gap for cleaning between reservations.
+
+    Similarly,
+    // [3, 6, 4] => 7
+    // [4, 10, 3, 1, 5] => 15
+    ~~~
+- How many string representations are there for an integer where `a->1, b->2, ... z->26`.
+  - E.g. `26 => 2`. Because `26` can be encoded as `"z"` and `"bf"`.
+- Given a list of denominations (e.g., `[1, 2, 5]` means you have coins worth $1, $2, and $5) and a target number `k`, find all possible combinations, if any, of coins in the given denominations that add up to `k`. You can use coins of the same denomination more than once.

algorithms/geometry.md

@@ -0,0 +1,7 @@
+Geometry
+==
+
+- You have a plane with lots of rectangles on it, find out how many of them intersect.
+- Which data structure would you use to query the k-nearest points of a set on a 2D plane?
+- Given many points, find k points that are closest to the origin.
+- How would you triangulate a polygon?

algorithms/graph.md

@@ -0,0 +1,12 @@
+Graph
+==
+
+- Given a list of sorted words from an alien dictionary, find the order of the alphabet.
+  - Alien Dictionary Topological Sort question.
+- Find if a given string matches any path in a labeled graph. A path may contain cycles.
+- Given a friendship graph (an undirected graph where nodes represent people and edges means two people know each other), find all your 2nd degree connections (friends’ friends). Output these 2nd degree connections ranked by number of common friends (i.e 1st degree connections) with you, (example: if 2nd degree connection A has 10 common friends (1st degree connections) with you but 2nd degree connection B has 8 common friends (1st degree connections) with you, then A should be ranked first).
+- Given a bipartite graph, separate the vertices into two sets.
+- Given a list of email addresses, and a similarity function which says whether two email addresses are similar, write a function to separate the list into sets of email addresses that are similar to each other.
+- You are a thief trying to sneak across a rectangular field. There are alarms placed on the fields and they each have a circular sensing radius which will trigger if anyone steps into it. Each alarm may not have the same radius. Determine if you can get from one end of the field to the other end.
+- Given a graph and two nodes, determine if there exists a path between them.
+- Determine if a cycle exists in the graph.

algorithms/hash-table.md

@@ -0,0 +1,7 @@
+Hash Table
+==
+
+- Describe an implementation of a least-used cache, and big-O notation of it.
+- A question involving an API's integration with hash map where the buckets of hash map are made up of linked lists.
+- Implement data structure `Map` storing pairs of integers (key, value) and define following member functions in O(1) runtime: `void insert(key, value)`, `void delete(key)`, `int get(key)`, `int getRandomKey()`.
+  - [Source](http://blog.gainlo.co/index.php/2016/08/14/uber-interview-question-map-implementation/).

algorithms/heap.md

@@ -0,0 +1,5 @@
+Heap
+==
+
+- Merge `K` sorted lists together into a single list.
+- Given a stream of integers, write an efficient function that returns the median value of the integers.

algorithms/interval.md

@@ -0,0 +1,28 @@
+Interval
+==
+
+- Given a list of schedules, provide a list of times that are available for a meeting.
+  ```
+  [
+    [[4,5], [6,10], [12,14]],
+    [[4,5], [5,9], [13,16]],
+    [[11,14]]
+  ]
+
+  Example Output:
+  [[0,4], [11,12], [16,23]]
+  ```
+- You have a number of meetings (with their start and end times). You need to schedule them using the minimum number of rooms. Return the list of meetings in every room.
+- Interval ranges:
+  - Given 2 interval ranges, create a function to tell me if these ranges intersect. Both start and end are inclusive: `[start, end]`
+    - E.g. `[1, 4]` and `[5, 6]` => `false`
+    - E.g. `[1, 4]` and `[3, 6]` => `true`
+  - Given 2 interval ranges that intersect, now create a function to merge the 2 ranges into a single continuous range.
+    - E.g. `[1, 4]` and `[3, 6]` => `[1, 6]`
+  - Now create a function that takes a group of unsorted, unorganized intervals, merge any intervals that intersect and sort them. The result should be a group of sorted, non-intersecting intervals.
+  - Now create a function to merge a new interval into a group of sorted, non-intersecting intervals. After the merge, all intervals should remain
+  non-intersecting.
+- Given a list of meeting times, check if any of them overlap. The follow-up question is to return the minimum number of rooms required to accommodate all the meetings.
+  - [Source](http://blog.gainlo.co/index.php/2016/07/12/meeting-room-scheduling-problem/)
+- If you have a list of intervals, how would you merge them?
+  - E.g. `[1, 3], [8, 11], [2, 6]` => `[1, 6], [8-11]`

algorithms/linked-list.md

@@ -0,0 +1,13 @@
+Linked List
+==
+
+- Given a linked list, in addition to the next pointer, each node has a child pointer that can point to a separate list. With the head node, flatten the list to a single-level linked list.
+  - [Source](http://blog.gainlo.co/index.php/2016/06/12/flatten-a-linked-list/)
+- Reverse a singly linked list. Implement it recursively and iteratively.
+- Convert a binary tree to a doubly circular linked list.
+- Implement an LRU cache with O(1) runtime for all its operations.
+- Check distance between values in linked list.
+- A question involving an API's integration with hash map where the buckets of hash map are made up of linked lists.
+- Given a singly linked list (a list which can only be traversed in one direction), find the item that is located at 'k' items from the end. So if the list is a, b, c, d and k is 2 then the answer is 'c'. The solution should not search the list twice.
+- How can you tell if a Linked List is a Palindrome?
+- Implement a LRU cache with O(1) runtime for all its operations.

algorithms/math.md

@@ -0,0 +1,20 @@
+Math
+==
+
+- Create a square root function.
+- Given a string such as "123" or "67", write a function to output the number represented by the string without using casting.
+- Make a program that can print out the text form of numbers from 1 - 1000 (ex. 20 is "twenty", 105 is "one hundred and five").
+- Write a function that parses Roman numerals.
+  - E.g. `XIV` returns `14`.
+- Write in words for a given digit.
+  - E.g. `123` returns `one hundred and twenty three`.
+- Given a number `N`, find the largest number just smaller than `N` that can be formed using the same digits as `N`.
+- Compute the square root of `N` without using any existing functions.
+- Given numbers represented as binary strings, and return the string containing their sum.
+  - E.g. `add('10010', '101')` returns `'10111'`.
+- Take in an integer and return its english word-format.
+  - E.g. 1 -> "one", -10,203 -> "negative ten thousand two hundred and three".
+- Write a function that returns values randomly, according to their weight. Suppose we have 3 elements with their weights: A (1), B (1) and C (2). The function should return A with probability 25%, B with 25% and C with 50% based on the weights.
+  - [Source](http://blog.gainlo.co/index.php/2016/11/11/uber-interview-question-weighted-random-numbers/)
+- Given a number, how can you get the next greater number with the same set of digits?
+  - [Source](http://blog.gainlo.co/index.php/2017/01/20/arrange-given-numbers-to-form-the-biggest-number-possible/)

algorithms/matrix.md

@@ -0,0 +1,18 @@
+Matrix
+==
+
+- You're given a 3 x 3 board of a tile puzzle, with 8 tiles numbered 1 to 8, and an empty spot. You can move any tile adjacent to the empty spot, to the empty spot, creating an empty spot where the tile originally was. The goal is to find a series of moves that will solve the board, i.e. get `[[1, 2, 3], [4, 5, 6], [7, 8, - ]]` where - is the empty tile.
+- Boggle implementation. Given a dictionary, and a matrix of letters, find all the words in the matrix that are in the dictionary. You can go across, down or diagonally.
+- The values of the matrix will represent numbers of carrots available to the rabbit in each square of the garden. If the garden does not have an exact center, the rabbit should start in the square closest to the center with the highest carrot count. On a given turn, the rabbit will eat the carrots available on the square that it is on, and then move up, down, left, or right, choosing the the square that has the most carrots. If there are no carrots left on any of the adjacent squares, the rabbit will go to sleep. You may assume that the rabbit will never have to choose between two squares with the same number of carrots. Write a function which takes a garden matrix and returns the number of carrots the rabbit eats. You may assume the matrix is rectangular with at least 1 row and 1 column, and that it is populated with non-negative integers. For example,
+  - Example: `[[5, 7, 8, 6, 3], [0, 0, 7, 0, 4], [4, 6, 3, 4, 9], [3, 1, 0, 5, 8]]` should return `27`.
+- Print a matrix in a spiral fashion.
+- In the Game of life, calculate how to compute the next state of the board. Follow up was to do it if there were memory constraints (board represented by a 1 TB file).
+- Grid Illumination: Given an NxN grid with an array of lamp coordinates. Each lamp provides illumination to every square on their x axis, every square on their y axis, and every square that lies in their diagonal (think of a Queen in chess). Given an array of query coordinates, determine whether that point is illuminated or not. The catch is when checking a query all lamps adjacent to, or on, that query get turned off. The ranges for the variables/arrays were about: 10^3 < N < 10^9, 10^3 < lamps < 10^9, 10^3 < queries < 10^9.
+- You are given a matrix of integers. Modify the matrix such that if a row or column contains a 0, make the values in the entire row or column 0.
+- Given an N x N matrix filled randomly with different colors (no limit on what the colors are), find the total number of groups of each color - a group consists of adjacent cells of the same color touching each other.
+- You have a 4 x 4 board with characters. You need to write a function that finds if a certain word exists in the board. You can only jump to neighboring characters (including diagonally adjacent).
+- Count the number of islands in a binary matrix of 0's and 1's.
+- Check a 6 x 7 Connect 4 board for a winning condition.
+- Given a fully-filled Sudoku board, check whether fulfills the Sudoku condition.
+- Implement a function that checks if a player has won tic-tac-toe.
+- Given an N x N matrix of 1's and 0's, figure out if all of the 1's are connected.

algorithms/oop.md

@@ -0,0 +1,4 @@
+Object-Oriented Programming
+==
+
+- How would you design a chess game? What classes and objects would you use? What methods would they have?

algorithms/permutation.md

@@ -0,0 +1,12 @@
+Permutation
+==
+
+- You are given a 7 digit phone number, and you should find all possible letter combinations based on the digit-to-letter mapping on numeric pad and return only the ones that have valid match against a given dictionary of words.
+- Give all possible letter combinations from a phone number.
+- Generate all subsets of a string.
+- Print all possible `N` pairs of balanced parentheses.
+  - E.g. when `N` is `2`, the function should print `(())` and `()()`.
+  - E.g. when `N` is `3`, we should get `((()))`, `(()())`, `(())()`, `()(())`, `()()()`.
+  - [Source](http://blog.gainlo.co/index.php/2016/12/23/uber-interview-questions-permutations-parentheses/)
+- Given a list of arrays, return a list of arrays, where each array is a combination of one element in each given array.
+   - E.g. If the input is `[[1, 2, 3], [4], [5, 6]]`, the output should be `[[1, 4, 5], [1, 4, 6], [2, 4, 5], [2, 4, 6], [3, 4, 5], [3, 4, 6]]`.

algorithms/queue.md

@@ -0,0 +1,4 @@
+Queue
+==
+
+- Implement a Queue class from scratch with an existing bug, the bug is that it cannot take more than 5 elements.