Added link to new page.

README.md

@@ -619,20 +619,24 @@ You'll get more graph practice in Skiena's book (see Books section below) and th
 #### Mentioned in Google Coaching:
 
 - [ ] The Algorithm Design Manual (Skiena)
-    - Book (can rent on kindle): http://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1849967202
-    - Answers: http://www.algorithm.cs.sunysb.edu/algowiki/index.php/The_Algorithms_Design_Manual_(Second_Edition)
+    - Book (can rent on kindle):
+        - http://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1849967202
+    - Answers:
+        - http://www.algorithm.cs.sunysb.edu/algowiki/index.php/The_Algorithms_Design_Manual_(Second_Edition)
 
 - [ ] Algorithms and Programming: Problems and Solutions:
     http://www.amazon.com/Algorithms-Programming-Solutions-Alexander-Shen/dp/0817638474
 
-- [ ] Once you've understood everything in the daily plan:
-    read and do exercises from the books below. Then move to coding challenges (further down below)
 
-Read first:
+    Once you've understood everything in the daily plan, read and do exercises from
+    the books below. Then move to coding challenges (further down below)
+
+
+**Read first:**
 - [ ] Programming Interviews Exposed: Secrets to Landing Your Next Job, 2nd Edition:
     http://www.wiley.com/WileyCDA/WileyTitle/productCd-047012167X.html
 
-Read second:
+**Read second:**
 - [ ] Cracking the Coding Interview, 6th Edition:
     - http://www.amazon.com/Cracking-Coding-Interview-6th-Programming/dp/0984782850/
 

plan.txt

@@ -1,876 +1 @@
-##########################################################################################
-##  How to read this
-##########################################################################################
-
-Everything below is an outline, and you should tackle the items in order from top to bottom.
-
-I put an asterisk/star (*) at the beginning of a line when I'm done with it. When all sub-items are done,
-I put a * at the top level, meaning the entire block is done. Sorry you have to remove all my *
-to use this the same way. If you search/replace, there are a couple of places to look out for.
-Sometimes I just put a * at top level if I know I've done all the subtasks, to cut down on * clutter.
-
-##########################################################################################
-##  Interview Prep:
-##########################################################################################
-
-* - Videos:
-    * - https://www.youtube.com/watch?v=oWbUtlUhwa8&feature=youtu.be
-    * - https://www.youtube.com/watch?v=qc1owf2-220&feature=youtu.be
-    * - https://www.youtube.com/watch?v=8npJLXkcmu8
-
-* - Articles:
-    * - http://www.google.com/about/careers/lifeatgoogle/hiringprocess/
-    * - http://steve-yegge.blogspot.com/2008/03/get-that-job-at-google.html
-        - all the things he mentions that you need to know are listed below
-    * - (very dated) http://dondodge.typepad.com/the_next_big_thing/2010/09/how-to-get-a-job-at-google-interview-questions-hiring-process.html
-    * - http://sites.google.com/site/steveyegge2/five-essential-phone-screen-questions
-
-* - Additional (not suggested by Google but I added):
-    * - https://medium.com/always-be-coding/abc-always-be-coding-d5f8051afce2#.4heg8zvm4
-    * - https://medium.com/always-be-coding/four-steps-to-google-without-a-degree-8f381aa6bd5e#.asalo1vfx
-    * - https://medium.com/@dpup/whiteboarding-4df873dbba2e#.hf6jn45g1
-    * - http://www.kpcb.com/blog/lessons-learned-how-google-thinks-about-hiring-management-and-culture
-    * - http://www.coderust.com/blog/2014/04/10/effective-whiteboarding-during-programming-interviews/
-    * - Cracking The Coding Interview Set 1:
-        * - https://www.youtube.com/watch?v=rEJzOhC5ZtQ
-        * - https://www.youtube.com/watch?v=aClxtDcdpsQ
-    * - How to Get a Job at the Big 4:
-        * - https://www.youtube.com/watch?v=YJZCUhxNCv8
-    * - http://alexbowe.com/failing-at-google-interviews/
-
-##########################################################################################
-##  Knowledge:
-##########################################################################################
-
-This short section were prerequisites/interesting info I wanted to learn before getting started on the daily plan.
-
-You need to know C, C++, or Java to do the coding part of the interview.
-They will sometimes make an exception and let you use Python or some other language, but the language
-must be mainstream and allow you write your code low-level enough to solve the problems.
-You'll see some C, C++ learning included below.
-
-There are a few books involved, see the bottom.
-
-Some videos are available only by enrolling in a Coursera or EdX class. It is free to do so.
-
-* - how computers process a program:
-    * - https://www.youtube.com/watch?v=42KTvGYQYnA
-    * - https://www.youtube.com/watch?v=Mv2XQgpbTNE
-
-* - how floating point numbers are stored:
-    * - simple 8-bit: http://math.stackexchange.com/questions/301435/fractions-in-binary
-    * - 32 bit: https://www.youtube.com/watch?v=ji3SfClm8TU
-    * - 64 bit: https://www.youtube.com/watch?v=50ZYcZebIec
-
-* - Computer Arch Intro:
-    (first video only - interesting but not required) https://www.youtube.com/watch?v=zLP_X4wyHbY&list=PL5PHm2jkkXmi5CxxI7b3JCL1TWybTDtKq&index=1
-
-* - C
-    * - K&R C book (ANSI C)
-    * - Clang: https://www.youtube.com/watch?v=U3zCxnj2w8M
-    * - GDB:
-        - https://www.youtube.com/watch?v=USPvePv1uzE
-        - https://www.youtube.com/watch?v=y5JmQItfFck
-      - Valgrind: https://www.youtube.com/watch?v=fvTsFjDuag8
-* - C++
-    * - basics
-    * - pointers
-    * - functions
-    * - references
-    * - templates
-    * - compilation
-    * - scope & linkage
-    * - namespaces
-    * - OOP
-    * - STL
-    * - functors: http://www.cprogramming.com/tutorial/functors-function-objects-in-c++.html
-    * - C++ at Google: https://www.youtube.com/watch?v=NOCElcMcFik
-    * - Google C++ Style Guide: https://google.github.io/styleguide/cppguide.html
-        * - Google uses clang-format (there is a command line "style" argument: -style=google)
-    * - Efficiency with Algorithms, Performance with Data Structures: https://youtu.be/fHNmRkzxHWs
-    * - review of C++ concepts: https://www.youtube.com/watch?v=Rub-JsjMhWY
-
-- Python
-    I've already read quite a bit. This is just for review.
-    - https://www.youtube.com/watch?v=N4mEzFDjqtA
-
-* - compilers:
-    * - https://class.coursera.org/compilers-004/lecture/1
-    * - https://class.coursera.org/compilers-004/lecture/2
-    * - C++: https://www.youtube.com/watch?v=twodd1KFfGk
-    * - Understanding Compiler Optimization (C++): https://www.youtube.com/watch?v=FnGCDLhaxKU
-
-----------------------------------------------------------------
-
-The Daily Plan:
-
-Each subject does not require a whole day to be able to understand it fully, and you can do multiple of these in a day.
-
-Each day I take one subject from the list below, watch videos about that subject, and write an implementation in:
-    C - using structs and functions that take a struct * and something else as args.
-    C++ - without using built-in types
-    C++ - using built-in types, like STL's std::list for a linked list
-    Python - using built-in types (to keep practicing Python)
-    and write tests to ensure I'm doing it right, sometimes just using simple assert() statements
-    You may do Java or something else, this is just my thing.
-
-Why code in all of these?
-    Practice, practice, practice, until I'm sick of it, and can do it with no problem (some have many edge cases and bookkeeping details to remember)
-    Work within the raw constraints (allocating/freeing memory without help of garbage collection (except Python))
-    Make use of built-in types so I have experience using the built-in tools for real-world use (not going to write my own linked list implementation in production)
-
-I may not have time to do all of these for every subject, but I'll try.
-
-You don't need to memorize the guts of every algorithm.
-
-Write code on a whiteboard, not a computer. Test with some sample inputs.
-Then test it out on a computer to make sure it's not buggy from syntax.
-
-----------------------------------------------------------------
-
-* - Before you get started:
-    The myth of the Genius Programmer: https://www.youtube.com/watch?v=0SARbwvhupQ
-    Google engineers are smart, but many have an insecurity that they aren't smart enough.
-
-* - Algorithmic complexity / Big O / Asymptotic analysis
-    - nothing to implement
-    - Harvard CS50 - Asymptotic Notation: https://www.youtube.com/watch?v=iOq5kSKqeR4
-    - Big O Notations (general quick tutorial) - https://www.youtube.com/watch?v=V6mKVRU1evU
-    - Big O Notation (and Omega and Theta) - best mathematical explanation:
-        - https://www.youtube.com/watch?v=ei-A_wy5Yxw&index=2&list=PL1BaGV1cIH4UhkL8a9bJGG356covJ76qN
-    - Skiena:
-        - video: https://www.youtube.com/watch?v=gSyDMtdPNpU&index=2&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b
-        - slides: http://www3.cs.stonybrook.edu/~algorith/video-lectures/2007/lecture2.pdf
-    - A Gentle Introduction to Algorithm Complexity Analysis: http://discrete.gr/complexity/
-    - Orders of Growth: https://class.coursera.org/algorithmicthink1-004/lecture/59
-    - Asymptotics: https://class.coursera.org/algorithmicthink1-004/lecture/61
-    - UC Berkeley Big O: https://youtu.be/VIS4YDpuP98
-    - UC Berkeley Big Omega: https://youtu.be/ca3e7UVmeUc
-    - Amortized Analysis: https://www.youtube.com/watch?v=B3SpQZaAZP4&index=10&list=PL1BaGV1cIH4UhkL8a9bJGG356covJ76qN
-    - Illustrating "Big O": https://class.coursera.org/algorithmicthink1-004/lecture/63
-    - Cheat sheet: http://bigocheatsheet.com/
-
------------------------------------------------------
-    Trees
------------------------------------------------------
-
-* - Arrays: (Implement an automatically resizing vector)
-    * - Description:
-        - Arrays: https://www.coursera.org/learn/data-structures/lecture/OsBSF/arrays
-        - Arrays: https://www.lynda.com/Developer-Programming-Foundations-tutorials/Basic-arrays/149042/177104-4.html
-        - Multi-dim: https://www.lynda.com/Developer-Programming-Foundations-tutorials/Multidimensional-arrays/149042/177105-4.html
-        - Dynamic Arrays: https://www.coursera.org/learn/data-structures/lecture/EwbnV/dynamic-arrays
-        - Jagged: https://www.lynda.com/Developer-Programming-Foundations-tutorials/Jagged-arrays/149042/177106-4.html
-        - Resizing arrays:
-            - https://class.coursera.org/algs4partI-010/lecture/19
-            - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Resizable-arrays/149042/177108-4.html
-    * - Implement a vector (mutable array with automatic resizing):
-        * - Practice coding using arrays and pointers, and pointer math to jump to an index instead of using indexing.
-        * - new raw data array with allocated memory
-            - can allocate int array under the hood, just not use its features
-            - start with 16, or if starting number is greater, use power of 2 - 16, 32, 64, 128
-        * - size() - number of items
-        * - capacity() - number of items it can hold
-        * - is_empty()
-        * - at(index) - returns item at given index, blows up if index out of bounds
-        * - push(item)
-        * - insert(index, item) - inserts item at index, shifts that index's value and trailing elements to the right
-        * - prepend(item) - can use insert above at index 0
-        * - pop() - remove from end, return value
-        * - delete(index) - delete item at index, shifting all trailing elements left
-        * - remove(item) - looks for value and removes index holding it (even if in multiple places)
-        * - find(item) - looks for value and returns first index with that value, -1 if not found
-        * - resize(new_capacity) // private function
-            - when you reach capacity, resize to double the size
-            - when popping an item, if size is 1/4 of capacity, resize to half
-    * - Time
-        - O(1) to add/remove at end (amortized for allocations for more space), index, or update
-        - O(n) to insert/remove elsewhere
-    * - Space
-        - contiguous in memory, so proximity helps performance
-        - space needed = (array capacity, which is >= n) * size of item, but even if 2n, still O(n)
-
-* - Linked Lists
-    * - Description:
-        * - https://www.coursera.org/learn/data-structures/lecture/kHhgK/singly-linked-lists
-        * - Lynda.com:
-            - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Introduction-lists/149042/177115-4.html
-            - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Understanding-basic-list-implementations/149042/177116-4.html
-            - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-singly-doubly-linked-lists/149042/177117-4.html
-            - https://www.lynda.com/Developer-Programming-Foundations-tutorials/List-support-across-languages/149042/177118-4.html
-    * - C Code: https://www.youtube.com/watch?v=QN6FPiD0Gzo
-            - not the whole video, just portions about Node struct and memory allocation.
-    * - Linked List vs Arrays:
-        - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/rjBs9/core-linked-lists-vs-arrays
-        - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/QUaUd/in-the-real-world-lists-vs-arrays
-    * - why you should avoid linked lists:
-        - https://www.youtube.com/watch?v=YQs6IC-vgmo
-    * - Gotcha: you need pointer to pointer knowledge:
-        (for when you pass a pointer to a function that may change the address where that pointer points)
-        This page is just to get a grasp on ptr to ptr. I don't recommend this list traversal style. Readability and maintainability suffer due to cleverness.
-        - https://www.eskimo.com/~scs/cclass/int/sx8.html
-    * - implement (I did with tail pointer & without):
-        * - size() - returns number of data elements in list
-        * - empty() - bool returns true if empty
-        * - value_at(index) - returns the value of the nth item (starting at 0 for first)
-        * - push_front(value) - adds an item to the front of the list
-        * - pop_front() - remove front item and return its value
-        * - push_back(value) - adds an item at the end
-        * - pop_back() - removes end item and returns its value
-        * - front() - get value of front item
-        * - back() - get value of end item
-        * - insert(index, value) - insert value at index, so current item at that index is pointed to by new item at index
-        * - erase(index) - removes node at given index
-        * - value_n_from_end(n) - returns the value of the node at nth position from the end of the list
-        * - reverse() - reverses the list
-        * - remove_value(value) - removes the first item in the list with this value
-    * - Doubly-linked List
-        - Description: https://www.coursera.org/learn/data-structures/lecture/jpGKD/doubly-linked-lists
-        - No need to implement
-
-* - Stacks
-    * - https://www.coursera.org/learn/data-structures/lecture/UdKzQ/stacks
-    * - https://class.coursera.org/algs4partI-010/lecture/18
-    * - https://class.coursera.org/algs4partI-010/lecture/19
-    * - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-stacks-last-first-out/149042/177120-4.html
-    * - Will not implement. Implementing with array is trivial.
-
-* - Queues
-    * - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-queues-first-first-out/149042/177122-4.html
-    * - https://class.coursera.org/algs4partI-010/lecture/20
-    * - https://www.coursera.org/learn/data-structures/lecture/EShpq/queue
-    * - Circular buffer/FIFO: https://en.wikipedia.org/wiki/Circular_buffer
-    * - https://class.coursera.org/algs4partI-010/lecture/23
-    * - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Priority-queues-deques/149042/177123-4.html
-    * - Implement using linked-list, with tail pointer:
-        - enqueue(value) - adds value at position at tail
-        - dequeue() - returns value and removes least recently added element (front)
-        - empty()
-    * - Implement using fixed-sized array:
-        - enqueue(value) - adds item at end of available storage
-        - dequeue() - returns value and removes least recently added element
-        - empty()
-        - full()
-    * - Cost:
-        - a bad implementation using linked list where you enqueue at head and dequeue at tail would be O(n)
-            because you'd need the next to last element, causing a full traversal each dequeue
-        enqueue: O(1) (amortized, linked list and array [probing])
-        dequeue: O(1) (linked list and array)
-        empty: O(1) (linked list and array)
-
-* - Hash tables
-    * - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Understanding-hash-functions/149042/177126-4.html
-    * - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Using-hash-tables/149042/177127-4.html
-    * - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Supporting-hashing/149042/177128-4.html
-    * - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Language-support-hash-tables/149042/177129-4.html
-    * - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/m7UuP/core-hash-tables
-    * - https://www.youtube.com/watch?v=C4Kc8xzcA68
-    * - https://class.coursera.org/algs4partI-010/lecture/52
-    * - https://class.coursera.org/algs4partI-010/lecture/53
-    * - https://class.coursera.org/algs4partI-010/lecture/55
-    * - https://class.coursera.org/algs4partI-010/lecture/56
-    * - https://www.coursera.org/learn/data-structures/home/week/3
-    * - https://www.coursera.org/learn/data-structures/lecture/NYZZP/phone-book-problem
-    * - distributed hash tables:
-        - https://www.coursera.org/learn/data-structures/lecture/DvaIb/instant-uploads-and-storage-optimization-in-dropbox
-        - https://www.coursera.org/learn/data-structures/lecture/tvH8H/distributed-hash-tables
-    * - MIT:
-        https://www.youtube.com/watch?v=0M_kIqhwbFo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=8
-        https://www.youtube.com/watch?v=BRO7mVIFt08&index=9&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb
-        https://www.youtube.com/watch?v=rvdJDijO2Ro&index=10&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb
-    * - implement with array using linear probing
-        - hash(k, m) - m is size of hash table
-        - add(key, value) - if key already exists, update value
-        - exists(key)
-        - get(key)
-        - remove(key)
-
------------------------------------------------------
-    More Knowledge
------------------------------------------------------
-
-* - Binary search:
-    * - https://www.youtube.com/watch?v=D5SrAga1pno
-    * - https://www.khanacademy.org/computing/computer-science/algorithms/binary-search/a/binary-search
-    * - detail: https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/
-    * - Implement:
-        - binary search (on sorted array of integers)
-        - binary search using recursion
-
-* - Bit operations
-    * - Get a really good understanding of manipulating bits with: &, |, ^, ~, >>, <<
-        * - words: https://en.wikipedia.org/wiki/Word_(computer_architecture)
-        * - Good intro:
-            https://www.youtube.com/watch?v=7jkIUgLC29I
-        * - https://www.youtube.com/watch?v=d0AwjSpNXR0
-        * - https://en.wikipedia.org/wiki/Bit_manipulation
-        * - https://en.wikipedia.org/wiki/Bitwise_operation
-        * - https://graphics.stanford.edu/~seander/bithacks.html
-        * - http://bits.stephan-brumme.com/
-        * - http://bits.stephan-brumme.com/interactive.html
-    * - 2s and 1s complement
-        - https://www.youtube.com/watch?v=lKTsv6iVxV4
-        - https://en.wikipedia.org/wiki/Ones%27_complement
-        - https://en.wikipedia.org/wiki/Two%27s_complement
-    * - count set bits
-        - https://youtu.be/Hzuzo9NJrlc
-        - https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan
-        - http://stackoverflow.com/questions/109023/how-to-count-the-number-of-set-bits-in-a-32-bit-integer
-    * - round to next power of 2:
-        - http://bits.stephan-brumme.com/roundUpToNextPowerOfTwo.html
-    * - swap values:
-        - http://bits.stephan-brumme.com/swap.html
-    * - absolute value:
-        - http://bits.stephan-brumme.com/absInteger.html
-
-* - Parity & Hamming Code:
-    * - Parity:
-        - https://www.youtube.com/watch?v=DdMcAUlxh1M
-    * - Hamming Code:
-        - Error detection: https://www.youtube.com/watch?v=1A_NcXxdoCc
-        - Error correction: https://www.youtube.com/watch?v=JAMLuxdHH8o
-    * - Error Checking:
-        - https://www.youtube.com/watch?v=wbH2VxzmoZk
-
------------------------------------------------------
-    Trees
------------------------------------------------------
-Notes:
-    * - Series: https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/ovovP/core-trees
-    * - Series: https://www.coursera.org/learn/data-structures/lecture/95qda/trees
-    - basic tree construction
-    - traversal
-    - manipulation algorithms
-    - BFS (breadth-first search)
-        - MIT: https://www.youtube.com/watch?v=s-CYnVz-uh4&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=13
-        - level order (BFS, using queue)
-            time complexity: O(n)
-            space complexity: best: O(1), worst: O(n/2)=O(n)
-    - DFS (depth-first search)
-        - MIT: https://www.youtube.com/watch?v=AfSk24UTFS8&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=14
-        - notes:
-            time complexity: O(n)
-            space complexity:
-                best: O(log n) - avg. height of tree
-                worst: O(n)
-        - inorder (DFS: left, self, right)
-        - postorder (DFS: left, right, self)
-        - preorder (DFS: self, left, right)
-
-
-~~ - Binary search trees: BSTs ~~
-    * - Series: https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/p82sw/core-introduction-to-binary-search-trees
-    * - Series: https://class.coursera.org/algs4partI-010/lecture/43
-        - starts with symbol table and goes through BST applications
-    * - https://www.coursera.org/learn/data-structures/lecture/E7cXP/introduction
-    * - MIT: https://www.youtube.com/watch?v=9Jry5-82I68
-    ~~ - C/C++: ~~
-        * - https://www.youtube.com/watch?v=COZK7NATh4k&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=28
-        * - https://www.youtube.com/watch?v=hWokyBoo0aI&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=29
-        * - https://www.youtube.com/watch?v=Ut90klNN264&index=30&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P
-        * - https://www.youtube.com/watch?v=_pnqMz5nrRs&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=31
-        * - https://www.youtube.com/watch?v=9RHO6jU--GU&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=32
-        * - https://www.youtube.com/watch?v=86g8jAQug04&index=33&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P
-        * - https://www.youtube.com/watch?v=gm8DUJJhmY4&index=34&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P
-        * - https://www.youtube.com/watch?v=yEwSGhSsT0U&index=35&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P
-        * - https://www.youtube.com/watch?v=gcULXE7ViZw&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=36
-        * - https://www.youtube.com/watch?v=5cPbNCrdotA&index=37&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P
-
-Know least one type of balanced binary tree (and know how it's implemented):
-    - red/black tree
-        - https://class.coursera.org/algs4partI-010/lecture/50
-    - splay trees
-        - https://www.coursera.org/learn/data-structures/lecture/O9nZ6/splay-trees
-    - AVL trees
-        - MIT: https://www.youtube.com/watch?v=FNeL18KsWPc&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=6
-        - https://www.coursera.org/learn/data-structures/lecture/Qq5E0/avl-trees
-        - https://www.coursera.org/learn/data-structures/lecture/PKEBC/avl-tree-implementation
-        - https://www.coursera.org/learn/data-structures/lecture/22BgE/split-and-merge
-    - B-Trees:
-        - fun fact: B could stand for Boeing, Balanced, or Bayer (co-inventor)
-        - https://en.wikipedia.org/wiki/B-tree
-        - https://class.coursera.org/algs4partI-010/lecture/51
-    - 2-3 (type of B-tree) Search Trees
-        - https://class.coursera.org/algs4partI-010/lecture/49
-
-- N-ary trees
-    - https://en.wikipedia.org/wiki/K-ary_tree
-
-- Tries
-    - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/08Xyf/core-introduction-to-tries
-    - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/PvlZW/core-performance-of-tries
-    - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/DFvd3/core-implementing-a-trie
-
-- Heap (data structure):
-    - https://en.wikipedia.org/wiki/Heap_(data_structure)
-    - https://www.coursera.org/learn/data-structures/lecture/2OpTs/introduction
-    - https://www.coursera.org/learn/data-structures/lecture/z3l9N/naive-implementations
-    - https://www.coursera.org/learn/data-structures/lecture/GRV2q/binary-trees
-    - https://www.coursera.org/learn/data-structures/supplement/S5xxz/tree-height-remark
-    - https://www.coursera.org/learn/data-structures/lecture/0g1dl/basic-operations
-    - https://www.coursera.org/learn/data-structures/lecture/gl5Ni/complete-binary-trees
-    - https://www.coursera.org/learn/data-structures/lecture/HxQo9/pseudocode
-    - see: https://class.coursera.org/algs4partI-010/lecture
-    - https://class.coursera.org/algs4partI-010/lecture/39
-
-- Binary Heap:
-    Min Heap / Max Heap
-
-- Disjoint Sets:
-    - https://www.coursera.org/learn/data-structures/lecture/JssSY/overview
-    - https://www.coursera.org/learn/data-structures/lecture/EM5D0/naive-implementations
-    - https://www.coursera.org/learn/data-structures/lecture/Mxu0w/trees
-    - https://www.coursera.org/learn/data-structures/lecture/qb4c2/union-by-rank
-    - https://www.coursera.org/learn/data-structures/lecture/Q9CVI/path-compression
-    - https://www.coursera.org/learn/data-structures/lecture/GQQLN/analysis-optional
-
-- Priority Queue
-    - https://en.wikipedia.org/wiki/Priority_queue
-
------------------------------------------------------
-    Graphs
------------------------------------------------------
-Notes:
-    There are three basic ways to represent a graph in memory:
-        - objects and pointers
-        - matrix
-        - adjacency list
-    Familiarize yourself with each representation and its pros & cons
-    BFS and DFS - know their computational complexity, their tradeoffs, and how to implement them in real code
-    If you get a chance, try to study up on fancier algorithms:
-        - Dijkstra's algorithm
-            - https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
-        - A*
-            - https://en.wikipedia.org/wiki/A*_search_algorithm
-    When asked a question, look for a graph-based solution first, then move on if none.
-
-Compute Strongly Connected Components
-    - https://www.coursera.org/learn/algorithms-on-graphs/home/week/5
-
-Implement:
-
-    Dijkstra's algorithm
-    A*
-
-You'll get more graph practice in Skiena's book (see Books section below) and the interview books
-
------------------------------------------------------
-    Sorting
------------------------------------------------------
-Notes:
-    - Implement & know best case/worst case, average complexity of each:
-        - no bubble sort - it's terrible - O(n^2)
-    - stability in sorting algorithms:
-        - http://stackoverflow.com/questions/1517793/stability-in-sorting-algorithms
-        - http://www.geeksforgeeks.org/stability-in-sorting-algorithms/
-    - Which algorithms can be used on linked lists? Which on arrays? Which on both? Is Quicksort stable?
-
-Implement:
-
-    Mergesort
-    Quicksort
-    Insertion Sort
-    Selection Sort
-
-For Curiosity:
-    Radix Sort: https://www.youtube.com/watch?v=xhr26ia4k38
-
------------------------------------------------------
-    More Knowledge
------------------------------------------------------
-
-Caches
-    - LRU cache
-
-NP and NP Complete
-    - Know about the most famous classes of NP-complete problems, such as traveling salesman and the knapsack problem,
-        and be able to recognize them when an interviewer asks you them in disguise.
-    - Know what NP-complete means.
-
-Recursion
-    -  when it is appropriate to use it
-
-open-ended problems
-    - manipulate strings
-    - manipulate patterns
-
-Combinatorics (n choose k)
-
-Probability
-    - https://www.youtube.com/watch?v=sZkAAk9Wwa4
-    - https://www.youtube.com/watch?v=dNaJg-mLobQ
-
-Dynamic Programming
-
-Scheduling
-
-Weighted random sampling
-
-Implement system routines
-
-Design patterns:
-    - description:
-        - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Foundations-Programming-Design-Patterns/135365-2.html
-        - Patterns: https://www.youtube.com/playlist?list=PLF206E906175C7E07
-        - UML: https://www.youtube.com/playlist?list=PLGLfVvz_LVvQ5G-LdJ8RLqe-ndo7QITYc
-    - strategy
-    - singleton
-    - adapter
-    - prototype
-    - decorator
-    - visitor
-    - factory
-
-
-Operating Systems (25 videos):
-    - https://www.youtube.com/watch?v=-KWd_eQYLwY&index=2&list=PL-XXv-cvA_iBDyz-ba4yDskqMDY6A1w_c
-    - https://www.quora.com/What-is-the-difference-between-a-process-and-a-thread
-    Covers:
-        Processes, Threads, Concurrency issues
-            - difference between processes and threads
-            - processes
-            - threads
-            - locks
-            - mutexes
-            - semaphores
-            - monitors
-            - how they work
-            - deadlock
-            - livelock
-        CPU activity, interrupts, context switching
-        Modern concurrency constructs with multicore processors
-        Process resource needs (memory: code, static storage, stack, heap, and also file descriptors, i/o)
-        Thread resource needs (shares above with other threads in same process but each has its own pc, stack counter, registers and stack)
-        Forking is really copy on write (read-only) until the new process writes to memory, then it does a full copy.
-        Context switching
-            - How context switching is initiated by the operating system and underlying hardware
-    - threads in C++:
-        https://www.youtube.com/playlist?list=PL5jc9xFGsL8E12so1wlMS0r0hTQoJL74M
-        - stopped here: https://www.youtube.com/watch?v=_N0B5ua7oN8&list=PL5jc9xFGsL8E12so1wlMS0r0hTQoJL74M&index=4
-
-Data handling:
-    - see scalability options below
-    Distill large data sets to single values
-    Transform one data set to another
-    Handling obscenely large amounts of data
-
-System design:
-    - https://www.quora.com/How-do-I-prepare-to-answer-design-questions-in-a-technical-interview?redirected_qid=1500023
-    - features sets
-    - interfaces
-    - class hierarchies
-    - designing a system under certain constraints
-    - simplicity and robustness
-    - tradeoffs
-    - performance analysis and optimization
-
-Familiarize yourself with a unix-based code editor: emacs & vi(m)
-    vi(m):
-        - https://www.youtube.com/watch?v=5givLEMcINQ&index=1&list=PL13bz4SHGmRxlZVmWQ9DvXo1fEg4UdGkr
-        - set of 4:
-            - https://www.youtube.com/watch?v=SI8TeVMX8pk
-            - https://www.youtube.com/watch?v=F3OO7ZIOaJE
-            - https://www.youtube.com/watch?v=ZYEccA_nMaI
-            - https://www.youtube.com/watch?v=1lYD5gwgZIA
-    emacs:
-        - https://www.youtube.com/watch?v=hbmV1bnQ-i0
-        - set of 3:
-            - https://www.youtube.com/watch?v=ujODL7MD04Q
-            - https://www.youtube.com/watch?v=XWpsRupJ4II
-            - https://www.youtube.com/watch?v=paSgzPso-yc
-        - https://www.youtube.com/watch?v=JWD1Fpdd4Pc
-
-Testing
-
--------------------------------------------------------------------
-
-Once you're closer to the interview:
-
-    - Cracking The Coding Interview Set 2:
-        - https://www.youtube.com/watch?v=4NIb9l3imAo
-        - https://www.youtube.com/watch?v=Eg5-tdAwclo
-        - https://www.youtube.com/watch?v=1fqxMuPmGak
-
--------------------------------------------------------------------
-
-Extras that can't hurt:
-
-Weighted random sampling
-Vector calculus
-
-Computer Security:
-    - MIT (23 videos): https://www.youtube.com/playlist?list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh
-
-Information theory:
-    - Markov processes:
-        - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/waxgx/core-markov-text-generation
-        - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/gZhiC/core-implementing-markov-text-generation
-    - https://www.khanacademy.org/computing/computer-science/informationtheory/moderninfotheory/v/symbol-rate-information-theory
-    - includes Markov chain
-
-Bloom Filter
-    - https://www.youtube.com/watch?v=-SuTGoFYjZs
-    - http://blog.michaelschmatz.com/2016/04/11/how-to-write-a-bloom-filter-cpp/
-
-Fast Fourier Transform
-    - http://jakevdp.github.io/blog/2013/08/28/understanding-the-fft/
-
-Machine Learning:
-    - great course: https://www.coursera.org/learn/machine-learning
-    - http://www.analyticsvidhya.com/blog/2016/04/neural-networks-python-theano/
-    - http://www.dataschool.io/
-
-Parallel Programming:
-    - https://www.coursera.org/learn/parprog1/home/week/1
-
-String search algorithm:
-    Knuth-Morris-Pratt (KMP):
-        - https://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm
-        - https://www.youtube.com/watch?v=2ogqPWJSftE
-    Boyer–Moore string search algorithm
-        - https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm
-        - https://www.youtube.com/watch?v=xYBM0_dChRE
-
--------------------------------------------------------------------
-
-Resume:
-    - http://steve-yegge.blogspot.co.uk/2007_09_01_archive.html
-
----------------------------
-
-Be thinking of for when the interview comes:
-
-Think of about 20 interview questions you'll get, along the lines of the items below:
-have 2-3 answers for each
-Have a story, not just data, about something you accomplished
-
-Why do you want this job?
-What's a tough problem you've solved?
-Biggest challenges faced?
-Best/worst designs seen?
-Ideas for improving an existing Google product.
-How do you work best, as an individual and as part of a team?
-Which of your skills or experiences would be assets in the role and why?
-What did you most enjoy at [job x / project y]?
-What was the biggest challenge you faced at [job x / project y]?
-What was the hardest bug you faced at [job x / project y]?
-What did you learn at [job x / project y]?
-What would you have done better at [job x / project y]?
-
----------------------------
-
-Have questions for the interviewer.
-
-Some of mine (I already may know answer to but want their opinion or team perspective):
-    - How large is your team?
-    - What is your dev cycle look like? Do you do waterfall/sprints/agile?
-    - Are rushes to deadlines common? Or is there flexibility?
-    - How are decisions made in your team?
-    - How many meetings do you have per week?
-    - Do you feel your work environment helps you concentrate?
-    - What are you working on?
-    - What do you like about it?
-    - What is the work life like?
-
-
-##########################################################################################
-##  Books:
-##########################################################################################
-
-Mentioned in Coaching:
-
-    The Algorithm Design Manual (Skiena)
-        - Book (can rent on kindle): http://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1849967202
-        - Answers: http://www.algorithm.cs.sunysb.edu/algowiki/index.php/The_Algorithms_Design_Manual_(Second_Edition)
-
-    Algorithms and Programming: Problems and Solutions:
-        http://www.amazon.com/Algorithms-Programming-Solutions-Alexander-Shen/dp/0817638474
-
-    Once you've understood everything in the daily plan:
-        read and do exercises from the books below. Then move to coding challenges (further down below)
-
-    Read first:
-    Programming Interviews Exposed: Secrets to Landing Your Next Job, 2nd Edition:
-        http://www.wiley.com/WileyCDA/WileyTitle/productCd-047012167X.html
-
-    Read second:
-    Cracking the Coding Interview, 6th Edition:
-        - http://www.amazon.com/Cracking-Coding-Interview-6th-Programming/dp/0984782850/
-
-Additional (not suggested by Google but I added):
-
-    * - C Programming Language, Vol 2
-
-    * - C++ Primer Plus, 6th Edition
-
-    Introduction to Algorithms
-        - https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844
-
-    Programming Pearls:
-        - http://www.amazon.com/Programming-Pearls-2nd-Jon-Bentley/dp/0201657880
-
-    If you see people reference "The Google Resume", it was a book replaced by "Cracking the Coding Interview".
-
-##########################################################################################
-##########################################################################################
-##
-##
-##
-##  Everything below is my recommendation, not Google's, and
-##      you may not have enough time to watch or read them all.
-##      That's ok. I may not either.
-##
-##
-##
-##########################################################################################
-
-##########################################################################################
-##  Videos:
-##########################################################################################
-
-Scalability:
-    - https://www.youtube.com/watch?v=9nWyWwY2Onc
-    - https://www.youtube.com/watch?v=H4vMcD7zKM0
-
-CSE373 - Analysis of Algorithms (25 videos):
-    - https://www.youtube.com/watch?v=ZFjhkohHdAA&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=1
-
-MIT 6.042: Math for CS (25 videos):
-    - https://www.youtube.com/watch?v=L3LMbpZIKhQ&list=PLB7540DEDD482705B
-
-MIT 6.006: Intro to Algorithms (47 videos):
-    - https://www.youtube.com/watch?v=HtSuA80QTyo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&nohtml5=False
-
-MIT 6.033: Computer System Engineering (22 videos):
-    - https://www.youtube.com/watch?v=zm2VP0kHl1M&list=PL6535748F59DCA484
-
-MIT 6.046: Design and Analysis of Algorithms (34 videos):
-    - https://www.youtube.com/watch?v=2P-yW7LQr08&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp
-
-MIT 6.858 Computer Systems Security, Fall 2014 ():
-    - https://www.youtube.com/watch?v=GqmQg-cszw4&index=1&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh
-
-MIT 6.851: Advanced Data Structures (22 videos):
-    - https://www.youtube.com/watch?v=T0yzrZL1py0&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf&index=1
-
-Stanford: Programming Paradigms (17 videos)
-    - https://www.youtube.com/watch?v=jTSvthW34GU&list=PLC0B8B318B7394B6F&nohtml5=False
-
-MIT 6.050J Information and Entropy, Spring 2008 ()
-    - https://www.youtube.com/watch?v=phxsQrZQupo&list=PL_2Bwul6T-A7OldmhGODImZL8KEVE38X7
-
-Introduction to Cryptography:
-    - https://www.youtube.com/watch?v=2aHkqB2-46k&feature=youtu.be
-
-##########################################################################################
-##  Google:
-##########################################################################################
-
-- How Search Works:
-    https://www.google.com/insidesearch/howsearchworks/thestory/
-    https://www.youtube.com/watch?v=BNHR6IQJGZs
-    https://www.google.com/insidesearch/howsearchworks/
-
-##########################################################################################
-##  Articles:
-##########################################################################################
-
-- https://www.topcoder.com/community/data-science/data-science-tutorials/the-importance-of-algorithms/
-- http://highscalability.com/blog/2016/4/4/how-to-remove-duplicates-in-a-large-dataset-reducing-memory.html
-- http://highscalability.com/blog/2016/3/23/what-does-etsys-architecture-look-like-today.html
-- http://highscalability.com/blog/2016/3/21/to-compress-or-not-to-compress-that-was-ubers-question.html
-- http://highscalability.com/blog/2016/3/3/asyncio-tarantool-queue-get-in-the-queue.html
-- http://highscalability.com/blog/2016/2/25/when-should-approximate-query-processing-be-used.html
-- http://highscalability.com/blog/2016/2/23/googles-transition-from-single-datacenter-to-failover-to-a-n.html
-- http://highscalability.com/blog/2016/2/15/egnyte-architecture-lessons-learned-in-building-and-scaling.html
-- http://highscalability.com/blog/2016/2/1/a-patreon-architecture-short.html
-- http://highscalability.com/blog/2016/1/27/tinder-how-does-one-of-the-largest-recommendation-engines-de.html
-- http://highscalability.com/blog/2016/1/25/design-of-a-modern-cache.html
-- http://highscalability.com/blog/2016/1/13/live-video-streaming-at-facebook-scale.html
-- http://highscalability.com/blog/2016/1/11/a-beginners-guide-to-scaling-to-11-million-users-on-amazons.html
-- http://highscalability.com/blog/2015/12/16/how-does-the-use-of-docker-effect-latency.html
-- http://highscalability.com/blog/2015/12/14/does-amp-counter-an-existential-threat-to-google.html
-- http://highscalability.com/blog/2015/11/9/a-360-degree-view-of-the-entire-netflix-stack.html
-
-##########################################################################################
-##  Papers:
-##########################################################################################
-
-Computing Weak Consistency in Polynomial Time
-    - http://dl.acm.org/ft_gateway.cfm?id=2767407&ftid=1607485&dwn=1&CFID=627637486&CFTOKEN=49290244
-
-How Developers Search for Code: A Case Study
-    - http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43835.pdf
-
-Borg, Omega, and Kubernetes
-    - http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/44843.pdf
-
-Continuous Pipelines at Google
-    - http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43790.pdf
-
-AddressSanitizer: A Fast Address Sanity Checker
-    - http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/37752.pdf
-
-##########################################################################################
-##  Coding exercises/challenges:
-##########################################################################################
-
-- https://courses.csail.mit.edu/iap/interview/materials.php
-
-LeetCode: https://leetcode.com/
-Project Euler: https://projecteuler.net/index.php?section=problems
-TopCoder: https://www.topcoder.com/
-
-More:
-HackerRank: https://www.hackerrank.com/
-Codility: https://codility.com/programmers/
-InterviewCake: https://www.interviewcake.com/
-InterviewBit: https://www.interviewbit.com/invite/icjf
-
-##########################################################################################
-##  Maybe:
-##########################################################################################
-
-http://www.gainlo.co/ - Mock interviewers from big companies
-
-##########################################################################################
-##  Code References:
-##########################################################################################
-
-For review questions in C book:
-    https://github.com/lekkas/c-algorithms
-
-##########################################################################################
-##  Once you've got the job (this is mainly for me):
-##########################################################################################
-
-Books:
-    Clean Code
-    Code Complete
-    How to Prove It: A Structured Approach, 2nd Edition
-    Unix Power Tools, Third Edition
-
-* - C++ Seasoning:
-    - https://www.youtube.com/watch?v=qH6sSOr-yk8
-
-* - Better Code: Data Structures:
-    - https://www.youtube.com/watch?v=sWgDk-o-6ZE
-
-C++ Talks at CPPCon:
-    - https://www.youtube.com/watch?v=hEx5DNLWGgA&index=2&list=PLHTh1InhhwT75gykhs7pqcR_uSiG601oh
-
-MIT CMS.611J Creating Video Games, Fall 2014
-    - https://www.youtube.com/watch?v=pfDfriSjFbY&list=PLUl4u3cNGP61V4W6yRm1Am5zI94m33dXk
-
-Compilers:
-    - https://class.coursera.org/compilers-004/lecture
-
-Computer and processor architecture:
-    - https://class.coursera.org/comparch-003/lecture
-
-Long series of C++ videos:
-    - https://www.youtube.com/playlist?list=PLfVsf4Bjg79Cu5MYkyJ-u4SyQmMhFeC1C
-
-##########################################################################################
-##  Done.                                                                               ##
-##########################################################################################
+This has moved to the <a href="README.md">README</a>.