mirrors/coding-interview-university
mirrors
/
coding-interview-university
mirror of https://github.com/jwasham/coding-interview-university.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Revert "Removed broken video link." 

This reverts commit eddd1d5579.
This commit is contained in:
Tony 2020-03-01 13:32:16 -06:00
parent eddd1d5579
commit f312a53355
1 changed files with 1152 additions and 1223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

207
README.md
View File

@ -10,7 +10,7 @@
> The items listed here will prepare you well for a technical interview at just about any software company,
> including the giants: Amazon, Facebook, Google, and Microsoft.
>
> _Best of luck to you!_
> *Best of luck to you!*
<details>
<summary>Translations:</summary>
@ -149,7 +149,7 @@ If you want to be a reliability engineer or operations engineer, study more from
- [Garbage collection](#garbage-collection)
- [Parallel Programming](#parallel-programming)
- [Messaging, Serialization, and Queueing Systems](#messaging-serialization-and-queueing-systems)
- [A\*](#a)
- [A*](#a)
- [Fast Fourier Transform](#fast-fourier-transform)
- [Bloom Filter](#bloom-filter)
- [HyperLogLog](#hyperloglog)
@ -200,6 +200,7 @@ I'm using Github's special markdown flavor, including tasks lists to check progr
**Create a new branch so you can check items like this, just put an x in the brackets: [x]**
Fork a branch and follow the commands below
`git checkout -b progress`
@ -220,6 +221,7 @@ I'm using Github's special markdown flavor, including tasks lists to check progr
[More about Github-flavored markdown](https://guides.github.com/features/mastering-markdown/#GitHub-flavored-markdown)
## Don't feel you aren't smart enough
- Successful software engineers are smart, but many have an insecurity that they aren't smart enough.
@ -234,6 +236,7 @@ Sometimes the classes are not in session so you have to wait a couple of months,
I'd appreciate your help to add free and always-available public sources, such as YouTube videos to accompany the online course videos.
I like using university lectures.
## Interview Process & General Interview Prep
- [ ] [ABC: Always Be Coding](https://medium.com/always-be-coding/abc-always-be-coding-d5f8051afce2#.4heg8zvm4)
@ -276,7 +279,6 @@ Here is an article I wrote about choosing a language for the interview: [Pick On
You need to be very comfortable in the language and be knowledgeable.
Read more about choices:
- http://www.byte-by-byte.com/choose-the-right-language-for-your-coding-interview/
- http://blog.codingforinterviews.com/best-programming-language-jobs/
@ -349,6 +351,7 @@ OR:
- Pythonic code
- my glowing book report: https://startupnextdoor.com/book-report-data-structures-and-algorithms-in-python/
## Before you Get Started
This list grew over many months, and yes, it kind of got out of hand.
@ -386,7 +389,7 @@ same card and answer it several times correctly before you really know it. Repet
your brain.
An alternative to using my flashcard site is [Anki](http://ankisrs.net/), which has been recommended to me numerous times. It uses a repetition system to help you remember.
It's user-friendly, available on all platforms and has a cloud sync system. It costs \$25 on iOS but is free on other platforms.
It's user-friendly, available on all platforms and has a cloud sync system. It costs $25 on iOS but is free on other platforms.
My flashcard database in Anki format: https://ankiweb.net/shared/info/25173560 (thanks [@xiewenya](https://github.com/xiewenya))
@ -423,8 +426,7 @@ These are prevalent technologies but not part of this study plan:
Some subjects take one day, and some will take multiple days. Some are just learning with nothing to implement.
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 - 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)
@ -434,7 +436,6 @@ Each day I take one subject from the list below, watch videos about that subject
You don't need all these. You need only [one language for the interview](#pick-one-language-for-the-interview).
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 or Java))
- 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)
@ -442,10 +443,9 @@ Why code in all of these?
I may not have time to do all of these for every subject, but I'll try.
You can see my code here:
- [C](https://github.com/jwasham/practice-c)
- [C++](https://github.com/jwasham/practice-cpp)
- [Python](https://github.com/jwasham/practice-python)
- [C](https://github.com/jwasham/practice-c)
- [C++](https://github.com/jwasham/practice-cpp)
- [Python](https://github.com/jwasham/practice-python)
You don't need to memorize the guts of every algorithm.
@ -454,8 +454,7 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
## Prerequisite Knowledge
- [ ] **Learn C**
- C is everywhere. You'll see examples in books, lectures, videos, _everywhere_ while you're studying.
- C is everywhere. You'll see examples in books, lectures, videos, *everywhere* while you're studying.
- [ ] [C Programming Language, Vol 2](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628)
- This is a short book, but it will give you a great handle on the C language and if you practice it a little
you'll quickly get proficient. Understanding C helps you understand how programs and memory work.
@ -494,7 +493,6 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
## Data Structures
- ### Arrays
- Implement an automatically resizing vector.
- [ ] Description:
- [Arrays (video)](https://www.coursera.org/learn/data-structures/lecture/OsBSF/arrays)
@ -529,15 +527,15 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
- 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)
- space needed = (array capacity, which is >= n) * size of item, but even if 2n, still O(n)
- ### Linked Lists
- [ ] Description:
- [ ] [Singly Linked Lists (video)](https://www.coursera.org/learn/data-structures/lecture/kHhgK/singly-linked-lists)
- [ ] [CS 61B - Linked Lists 1 (video)](https://archive.org/details/ucberkeley_webcast_htzJdKoEmO0)
- [ ] [CS 61B - Linked Lists 2 (video)](https://archive.org/details/ucberkeley_webcast_-c4I3gFYe3w)
- [ ] [C Code (video)](https://www.youtube.com/watch?v=QN6FPiD0Gzo) - not the whole video, just portions about Node struct and memory allocation.
- [ ] [C Code (video)](https://www.youtube.com/watch?v=QN6FPiD0Gzo)
- not the whole video, just portions about Node struct and memory allocation.
- [ ] Linked List vs Arrays:
- [Core Linked Lists Vs Arrays (video)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/rjBs9/core-linked-lists-vs-arrays)
- [In The Real World Linked Lists Vs Arrays (video)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/QUaUd/in-the-real-world-lists-vs-arrays)
@ -566,13 +564,11 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
- No need to implement
- ### Stack
- [ ] [Stacks (video)](https://www.coursera.org/learn/data-structures/lecture/UdKzQ/stacks)
- [ ] [Using Stacks Last-In First-Out (video)](https://archive.org/details/0102WhatYouShouldKnow/05_01-usingStacksForLast-inFirst-out.mp4)
- [ ] Will not implement. Implementing with array is trivial.
- ### Queue
- [ ] [Using Queues First-In First-Out(video)](https://archive.org/details/0102WhatYouShouldKnow/05_03-usingQueuesForFirst-inFirst-out.mp4)
- [ ] [Queue (video)](https://www.coursera.org/lecture/data-structures/queues-EShpq)
- [ ] [Circular buffer/FIFO](https://en.wikipedia.org/wiki/Circular_buffer)
@ -594,9 +590,7 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
- empty: O(1) (linked list and array)
- ### Hash table
- [ ] Videos:
- [ ] [Hashing with Chaining (video)](https://www.youtube.com/watch?v=0M_kIqhwbFo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=8)
- [ ] [Table Doubling, Karp-Rabin (video)](https://www.youtube.com/watch?v=BRO7mVIFt08&index=9&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
- [ ] [Open Addressing, Cryptographic Hashing (video)](https://www.youtube.com/watch?v=rvdJDijO2Ro&index=10&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
@ -605,7 +599,6 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
- [ ] [(Advanced) Perfect hashing (video)](https://www.youtube.com/watch?v=N0COwN14gt0&list=PL2B4EEwhKD-NbwZ4ezj7gyc_3yNrojKM9&index=4)
- [ ] Online Courses:
- [ ] [Understanding Hash Functions (video)](https://archive.org/details/0102WhatYouShouldKnow/06_02-understandingHashFunctions.mp4)
- [ ] [Using Hash Tables (video)](https://archive.org/details/0102WhatYouShouldKnow/06_03-usingHashTables.mp4)
- [ ] [Supporting Hashing (video)](https://archive.org/details/0102WhatYouShouldKnow/06_04-supportingHashing.mp4)
@ -627,7 +620,6 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
## More Knowledge
- ### Binary search
- [ ] [Binary Search (video)](https://www.youtube.com/watch?v=D5SrAga1pno)
- [ ] [Binary Search (video)](https://www.khanacademy.org/computing/computer-science/algorithms/binary-search/a/binary-search)
- [ ] [detail](https://www.topcoder.com/community/competitive-programming/tutorials/binary-search/)
@ -638,7 +630,7 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
- ### Bitwise operations
- [ ] [Bits cheat sheet](https://github.com/jwasham/coding-interview-university/blob/master/extras/cheat%20sheets/bits-cheat-cheet.pdf) - you should know many of the powers of 2 from (2^1 to 2^16 and 2^32)
- [ ] Get a really good understanding of manipulating bits with: &, |, ^, ~, >>, <<
- [ ] [words](<https://en.wikipedia.org/wiki/Word_(computer_architecture)>)
- [ ] [words](https://en.wikipedia.org/wiki/Word_(computer_architecture))
- [ ] Good intro:
[Bit Manipulation (video)](https://www.youtube.com/watch?v=7jkIUgLC29I)
- [ ] [C Programming Tutorial 2-10: Bitwise Operators (video)](https://www.youtube.com/watch?v=d0AwjSpNXR0)
@ -663,7 +655,6 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
## Trees
- ### Trees - Notes & Background
- [ ] [Series: Core Trees (video)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/ovovP/core-trees)
- [ ] [Series: Trees (video)](https://www.coursera.org/learn/data-structures/lecture/95qda/trees)
- basic tree construction
@ -684,7 +675,6 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
- preorder (DFS: self, left, right)
- ### Binary search trees: BSTs
- [ ] [Binary Search Tree Review (video)](https://www.youtube.com/watch?v=x6At0nzX92o&index=1&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
- [ ] [Series (video)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/p82sw/core-introduction-to-binary-search-trees)
- starts with symbol table and goes through BST applications
@ -716,7 +706,7 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
- ### Heap / Priority Queue / Binary Heap
- visualized as a tree, but is usually linear in storage (array, linked list)
- [ ] [Heap](<https://en.wikipedia.org/wiki/Heap_(data_structure)>)
- [ ] [Heap](https://en.wikipedia.org/wiki/Heap_(data_structure))
- [ ] [Introduction (video)](https://www.coursera.org/learn/data-structures/lecture/2OpTs/introduction)
- [ ] [Naive Implementations (video)](https://www.coursera.org/learn/data-structures/lecture/z3l9N/naive-implementations)
- [ ] [Binary Trees (video)](https://www.coursera.org/learn/data-structures/lecture/GRV2q/binary-trees)
@ -746,7 +736,6 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
## Sorting
- [ ] Notes:
- Implement sorts & know best case/worst case, average complexity of each:
- no bubble sort - it's terrible - O(n^2), except when n <= 16
- [ ] stability in sorting algorithms ("Is Quicksort stable?")
@ -761,7 +750,6 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
- For heapsort, see Heap data structure above. Heap sort is great, but not stable.
- [ ] [Sedgewick - Mergesort (5 videos)](https://www.coursera.org/learn/algorithms-part1/home/week/3)
- [ ] [1. Mergesort](https://www.coursera.org/learn/algorithms-part1/lecture/ARWDq/mergesort)
- [ ] [2. Bottom up Mergesort](https://www.coursera.org/learn/algorithms-part1/lecture/PWNEl/bottom-up-mergesort)
- [ ] [3. Sorting Complexity](https://www.coursera.org/learn/algorithms-part1/lecture/xAltF/sorting-complexity)
@ -769,14 +757,12 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
- [ ] [5. Stability](https://www.coursera.org/learn/algorithms-part1/lecture/pvvLZ/stability)
- [ ] [Sedgewick - Quicksort (4 videos)](https://www.coursera.org/learn/algorithms-part1/home/week/3)
- [ ] [1. Quicksort](https://www.coursera.org/learn/algorithms-part1/lecture/vjvnC/quicksort)
- [ ] [2. Selection](https://www.coursera.org/learn/algorithms-part1/lecture/UQxFT/selection)
- [ ] [3. Duplicate Keys](https://www.coursera.org/learn/algorithms-part1/lecture/XvjPd/duplicate-keys)
- [ ] [4. System Sorts](https://www.coursera.org/learn/algorithms-part1/lecture/QBNZ7/system-sorts)
- [ ] UC Berkeley:
- [ ] [CS 61B Lecture 29: Sorting I (video)](https://archive.org/details/ucberkeley_webcast_EiUvYS2DT6I)
- [ ] [CS 61B Lecture 30: Sorting II (video)](https://archive.org/details/ucberkeley_webcast_2hTY3t80Qsk)
- [ ] [CS 61B Lecture 32: Sorting III (video)](https://archive.org/details/ucberkeley_webcast_Y6LOLpxg6Dc)
@ -795,13 +781,11 @@ Write code on a whiteboard or paper, not a computer. Test with some sample input
- [ ] [Using output array (Python)](https://github.com/jwasham/practice-python/blob/master/merge_sort/merge_sort.py)
- [ ] [In-place (C++)](https://github.com/jwasham/practice-cpp/blob/master/merge_sort/merge_sort.cc)
- [ ] Quick sort code:
- [ ] [Implementation (C)](http://www.cs.yale.edu/homes/aspnes/classes/223/examples/randomization/quick.c)
- [ ] [Implementation (C)](https://github.com/jwasham/practice-c/blob/master/quick_sort/quick_sort.c)
- [ ] [Implementation (Python)](https://github.com/jwasham/practice-python/blob/master/quick_sort/quick_sort.py)
- [ ] Implement:
- [ ] Mergesort: O(n log n) average and worst case
- [ ] Quicksort O(n log n) average case
- Selection sort and insertion sort are both O(n^2) average and worst case
@ -829,7 +813,6 @@ If you need more detail on this subject, see "Sorting" section in [Additional De
Graphs can be used to represent many problems in computer science, so this section is long, like trees and sorting were.
- Notes:
- There are 4 basic ways to represent a graph in memory:
- objects and pointers
- adjacency matrix
@ -840,12 +823,10 @@ Graphs can be used to represent many problems in computer science, so this secti
- When asked a question, look for a graph-based solution first, then move on if none.
- [ ] MIT(videos):
- [ ] [Breadth-First Search](https://www.youtube.com/watch?v=s-CYnVz-uh4&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=13)
- [ ] [Depth-First Search](https://www.youtube.com/watch?v=AfSk24UTFS8&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=14)
- [ ] Skiena Lectures - great intro:
- [ ] [CSE373 2012 - Lecture 11 - Graph Data Structures (video)](https://www.youtube.com/watch?v=OiXxhDrFruw&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=11)
- [ ] [CSE373 2012 - Lecture 12 - Breadth-First Search (video)](https://www.youtube.com/watch?v=g5vF8jscteo&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=12)
- [ ] [CSE373 2012 - Lecture 13 - Graph Algorithms (video)](https://www.youtube.com/watch?v=S23W6eTcqdY&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=13)
@ -859,8 +840,8 @@ Graphs can be used to represent many problems in computer science, so this secti
- [ ] [6.006 Dijkstra (video)](https://www.youtube.com/watch?v=2E7MmKv0Y24&index=16&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
- [ ] [6.006 Bellman-Ford (video)](https://www.youtube.com/watch?v=ozsuci5pIso&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=17)
- [ ] [6.006 Speeding Up Dijkstra (video)](https://www.youtube.com/watch?v=CHvQ3q_gJ7E&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=18)
- [ ] [Aduni: Graph Algorithms I - Topological Sorting, Minimum Spanning Trees, Prim's Algorithm - Lecture 6 (video)](https://www.youtube.com/watch?v=i_AQT_XfvD8&index=6&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
- [ ] [Aduni: Graph Algorithms II - DFS, BFS, Kruskal's Algorithm, Union Find Data Structure - Lecture 7 (video)](https://www.youtube.com/watch?v=ufj5_bppBsA&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=7)
- [ ] [Aduni: Graph Algorithms I - Topological Sorting, Minimum Spanning Trees, Prim's Algorithm - Lecture 6 (video)]( https://www.youtube.com/watch?v=i_AQT_XfvD8&index=6&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
- [ ] [Aduni: Graph Algorithms II - DFS, BFS, Kruskal's Algorithm, Union Find Data Structure - Lecture 7 (video)]( https://www.youtube.com/watch?v=ufj5_bppBsA&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=7)
- [ ] [Aduni: Graph Algorithms III: Shortest Path - Lecture 8 (video)](https://www.youtube.com/watch?v=DiedsPsMKXc&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=8)
- [ ] [Aduni: Graph Alg. IV: Intro to geometric algorithms - Lecture 9 (video)](https://www.youtube.com/watch?v=XIAQRlNkJAw&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=9)
- [ ] ~~[CS 61B 2014 (starting at 58:09) (video)](https://youtu.be/dgjX4HdMI-Q?list=PL-XXv-cvA_iAlnI-BQr9hjqADPBtujFJd&t=3489)~~
@ -869,7 +850,6 @@ Graphs can be used to represent many problems in computer science, so this secti
- [ ] [Strongly Connected Components Kosaraju's Algorithm Graph Algorithm (video)](https://www.youtube.com/watch?v=RpgcYiky7uw)
- Full Coursera Course:
- [ ] [Algorithms on Graphs (video)](https://www.coursera.org/learn/algorithms-on-graphs/home/welcome)
- I'll implement:
@ -891,7 +871,6 @@ Graphs can be used to represent many problems in computer science, so this secti
## Even More Knowledge
- ### Recursion
- [ ] Stanford lectures on recursion & backtracking:
- [ ] [Lecture 8 | Programming Abstractions (video)](https://www.youtube.com/watch?v=gl3emqCuueQ&list=PLFE6E58F856038C69&index=8)
- [ ] [Lecture 9 | Programming Abstractions (video)](https://www.youtube.com/watch?v=uFJhEPrbycQ&list=PLFE6E58F856038C69&index=9)
@ -903,7 +882,6 @@ Graphs can be used to represent many problems in computer science, so this secti
- [ ] [Tail Recursion (video)](https://www.youtube.com/watch?v=L1jjXGfxozc)
- ### Dynamic Programming
- You probably won't see any dynamic programming problems in your interview, but it's worth being able to recognize a problem as being a candidate for dynamic programming.
- This subject can be pretty difficult, as each DP soluble problem must be defined as a recursion relation, and coming up with it can be tricky.
- I suggest looking at many examples of DP problems until you have a solid understanding of the pattern involved.
@ -930,7 +908,6 @@ Graphs can be used to represent many problems in computer science, so this secti
- [ ] [Local pairwise sequence alignment (video)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/WnNau/local-pairwise-sequence-alignment)
- ### Object-Oriented Programming
- [ ] [Optional: UML 2.0 Series (video)](https://www.youtube.com/watch?v=OkC7HKtiZC0&list=PLGLfVvz_LVvQ5G-LdJ8RLqe-ndo7QITYc)
- [ ] SOLID OOP Principles: [SOLID Principles (video)](https://www.youtube.com/playlist?list=PL4CE9F710017EA77A)
@ -963,8 +940,8 @@ Graphs can be used to represent many problems in computer science, so this secti
- [ ] [Handy reference: 101 Design Patterns & Tips for Developers](https://sourcemaking.com/design-patterns-and-tips)
- [ ] [Design patterns for humans](https://github.com/kamranahmedse/design-patterns-for-humans#structural-design-patterns)
* ### Combinatorics (n choose k) & Probability
- ### Combinatorics (n choose k) & Probability
- [ ] [Math Skills: How to find Factorial, Permutation and Combination (Choose) (video)](https://www.youtube.com/watch?v=8RRo6Ti9d0U)
- [ ] [Make School: Probability (video)](https://www.youtube.com/watch?v=sZkAAk9Wwa4)
- [ ] [Make School: More Probability and Markov Chains (video)](https://www.youtube.com/watch?v=dNaJg-mLobQ)
@ -974,8 +951,7 @@ Graphs can be used to represent many problems in computer science, so this secti
- Just the videos - 41 (each are simple and each are short):
- [ ] [Probability Explained (video)](https://www.youtube.com/watch?v=uzkc-qNVoOk&list=PLC58778F28211FA19)
* ### NP, NP-Complete and Approximation Algorithms
- ### NP, NP-Complete and Approximation Algorithms
- 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.
@ -996,8 +972,7 @@ Graphs can be used to represent many problems in computer science, so this secti
- [Jupyter Notebook](http://nbviewer.jupyter.org/url/norvig.com/ipython/TSP.ipynb)
- Pages 1048 - 1140 in CLRS if you have it.
* ### Caches
- ### Caches
- [ ] LRU cache:
- [ ] [The Magic of LRU Cache (100 Days of Google Dev) (video)](https://www.youtube.com/watch?v=R5ON3iwx78M)
- [ ] [Implementing LRU (video)](https://www.youtube.com/watch?v=bq6N7Ym81iI)
@ -1006,8 +981,7 @@ Graphs can be used to represent many problems in computer science, so this secti
- [ ] [MIT 6.004 L15: The Memory Hierarchy (video)](https://www.youtube.com/watch?v=vjYF_fAZI5E&list=PLrRW1w6CGAcXbMtDFj205vALOGmiRc82-&index=24)
- [ ] [MIT 6.004 L16: Cache Issues (video)](https://www.youtube.com/watch?v=ajgC3-pyGlk&index=25&list=PLrRW1w6CGAcXbMtDFj205vALOGmiRc82-)
* ### Processes and Threads
- ### Processes and Threads
- [ ] Computer Science 162 - Operating Systems (25 videos):
- for processes and threads see videos 1-11
- [Operating Systems and System Programming (video)](https://archive.org/details/ucberkeley-webcast-PL-XXv-cvA_iBDyz-ba4yDskqMDY6A1w_c)
@ -1028,6 +1002,7 @@ Graphs can be used to represent many problems in computer science, so this secti
- Modern concurrency constructs with multicore processors
- [Paging, segmentation and virtual memory (video)](https://www.youtube.com/watch?v=LKe7xK0bF7o&list=PLCiOXwirraUCBE9i_ukL8_Kfg6XNv7Se8&index=2)
- [Interrupts (video)](https://www.youtube.com/watch?v=uFKi2-J-6II&list=PLCiOXwirraUCBE9i_ukL8_Kfg6XNv7Se8&index=3)
- [Scheduling (video)](https://www.youtube.com/watch?v=-Gu5mYdKbu4&index=4&list=PLCiOXwirraUCBE9i_ukL8_Kfg6XNv7Se8)
- Process resource needs (memory: code, static storage, stack, heap, and also file descriptors, i/o)
- Thread resource needs (shares above (minus stack) with other threads in the 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.
@ -1043,8 +1018,7 @@ Graphs can be used to represent many problems in computer science, so this secti
- [ ] [Keynote David Beazley - Topics of Interest (Python Asyncio)](https://www.youtube.com/watch?v=ZzfHjytDceU)
- [ ] [Mutex in Python](https://www.youtube.com/watch?v=0zaPs8OtyKY)
* ### Testing
- ### Testing
- To cover:
- how unit testing works
- what are mock objects
@ -1059,13 +1033,11 @@ Graphs can be used to represent many problems in computer science, so this secti
- [ ] [Tao Of Testing](http://jasonpolites.github.io/tao-of-testing/ch3-1.1.html)
- [ ] [How to write tests](http://jasonpolites.github.io/tao-of-testing/ch4-1.1.html)
* ### Scheduling
- ### Scheduling
- in an OS, how it works
- can be gleaned from Operating System videos
* ### String searching & manipulations
- ### String searching & manipulations
- [ ] [Sedgewick - Suffix Arrays (video)](https://www.coursera.org/learn/algorithms-part2/lecture/TH18W/suffix-arrays)
- [ ] [Sedgewick - Substring Search (videos)](https://www.coursera.org/learn/algorithms-part2/home/week/4)
- [ ] [1. Introduction to Substring Search](https://www.coursera.org/learn/algorithms-part2/lecture/n3ZpG/introduction-to-substring-search)
@ -1077,8 +1049,7 @@ Graphs can be used to represent many problems in computer science, so this secti
If you need more detail on this subject, see "String Matching" section in [Additional Detail on Some Subjects](#additional-detail-on-some-subjects)
* ### Tries
- ### Tries
- Note there are different kinds of tries. Some have prefixes, some don't, and some use string instead of bits
to track the path.
- I read through code, but will not implement.
@ -1096,25 +1067,22 @@ Graphs can be used to represent many problems in computer science, so this secti
- [ ] [Stanford Lecture (real world use case) (video)](https://www.youtube.com/watch?v=TJ8SkcUSdbU)
- [ ] [MIT, Advanced Data Structures, Strings (can get pretty obscure about halfway through) (video)](https://www.youtube.com/watch?v=NinWEPPrkDQ&index=16&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf)
* ### Floating Point Numbers
- ### Floating Point Numbers
- [ ] simple 8-bit: [Representation of Floating Point Numbers - 1 (video - there is an error in calculations - see video description)](https://www.youtube.com/watch?v=ji3SfClm8TU)
- [ ] 32 bit: [IEEE754 32-bit floating point binary (video)](https://www.youtube.com/watch?v=50ZYcZebIec)
* ### Unicode
- [ ] [The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets](http://www.joelonsoftware.com/articles/Unicode.html)
- ### Unicode
- [ ] [The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets]( http://www.joelonsoftware.com/articles/Unicode.html)
- [ ] [What Every Programmer Absolutely, Positively Needs To Know About Encodings And Character Sets To Work With Text](http://kunststube.net/encoding/)
* ### Endianness
- ### Endianness
- [ ] [Big And Little Endian](https://web.archive.org/web/20180107141940/http://www.cs.umd.edu:80/class/sum2003/cmsc311/Notes/Data/endian.html)
- [ ] [Big Endian Vs Little Endian (video)](https://www.youtube.com/watch?v=JrNF0KRAlyo)
- [ ] [Big And Little Endian Inside/Out (video)](https://www.youtube.com/watch?v=oBSuXP-1Tc0)
- Very technical talk for kernel devs. Don't worry if most is over your head.
- The first half is enough.
* ### Networking
- ### Networking
- **if you have networking experience or want to be a reliability engineer or operations engineer, expect questions**
- otherwise, this is just good to know
- [ ] [Khan Academy](https://www.khanacademy.org/computing/computer-science/internet-intro)
@ -1199,7 +1167,7 @@ Graphs can be used to represent many problems in computer science, so this secti
- [ ] [To Compress Or Not To Compress, That Was Uber's Question](https://eng.uber.com/trip-data-squeeze/)
- [ ] [Asyncio Tarantool Queue, Get In The Queue](http://highscalability.com/blog/2016/3/3/asyncio-tarantool-queue-get-in-the-queue.html)
- [ ] [When Should Approximate Query Processing Be Used?](http://highscalability.com/blog/2016/2/25/when-should-approximate-query-processing-be-used.html)
- [ ] [Google's Transition From Single Datacenter, To Failover, To A Native Multihomed Architecture](http://highscalability.com/blog/2016/2/23/googles-transition-from-single-datacenter-to-failover-to-a-n.html)
- [ ] [Google's Transition From Single Datacenter, To Failover, To A Native Multihomed Architecture]( http://highscalability.com/blog/2016/2/23/googles-transition-from-single-datacenter-to-failover-to-a-n.html)
- [ ] [Spanner](http://highscalability.com/blog/2012/9/24/google-spanners-most-surprising-revelation-nosql-is-out-and.html)
- [ ] [Machine Learning Driven Programming: A New Programming For A New World](http://highscalability.com/blog/2016/7/6/machine-learning-driven-programming-a-new-programming-for-a.html)
- [ ] [The Image Optimization Technology That Serves Millions Of Requests Per Day](http://highscalability.com/blog/2016/6/15/the-image-optimization-technology-that-serves-millions-of-re.html)
@ -1281,7 +1249,6 @@ Now that you know all the computer science topics above, it's time to practice a
**Coding question practice is not about memorizing answers to programming problems.**
Why you need to practice doing programming problems:
- problem recognition, and where the right data structures and algorithms fit in
- gathering requirements for the problem
- talking your way through the problem like you will in the interview
@ -1316,6 +1283,7 @@ Supplemental:
See [Book List above](#book-list)
## Coding exercises/challenges
Once you've learned your brains out, put those brains to work.
@ -1325,12 +1293,10 @@ Take coding challenges every day, as many as you can.
- [How to Dissect a Topcoder Problem Statement](https://www.topcoder.com/community/competitive-programming/tutorials/how-to-dissect-a-topcoder-problem-statement/)
Coding Interview Question Videos:
- [IDeserve (88 videos)](https://www.youtube.com/watch?v=NBcqBddFbZw&list=PLamzFoFxwoNjPfxzaWqs7cZGsPYy0x_gI)
- [Tushar Roy (5 playlists)](https://www.youtube.com/user/tusharroy2525/playlists?shelf_id=2&view=50&sort=dd)
Challenge sites:
- [LeetCode](https://leetcode.com/)
- [TopCoder](https://www.topcoder.com/)
- [Project Euler (math-focused)](https://projecteuler.net/index.php?section=problems)
@ -1345,15 +1311,14 @@ Challenge sites:
- [Codechef](https://www.codechef.com/)
Challenge repos:
- [Interactive Coding Interview Challenges in Python](https://github.com/donnemartin/interactive-coding-challenges)
Mock Interviews:
- [Gainlo.co: Mock interviewers from big companies](http://www.gainlo.co/) - I used this and it helped me relax for the phone screen and on-site interview.
- [Pramp: Mock interviews from/with peers](https://www.pramp.com/) - peer-to-peer model of practice interviews
- [Refdash: Mock interviews and expedited interviews](https://refdash.com/) - also help candidates fast track by skipping multiple interviews with tech companies.
## Once you're closer to the interview
- Cracking The Coding Interview Set 2 (videos):
@ -1364,6 +1329,7 @@ Mock Interviews:
- See Resume prep items in Cracking The Coding Interview and back of Programming Interviews Exposed
## Be thinking of for when the interview comes
Think of about 20 interview questions you'll get, along with the lines of the items below. Have 2-3 answers for each.
@ -1452,7 +1418,7 @@ You're never really done.
- about to get to this part. Will update here once I've made my way through it.
- Can rent it on kindle
- Answers:
- [Solutions](<http://www.algorithm.cs.sunysb.edu/algowiki/index.php/The_Algorithms_Design_Manual_(Second_Edition)>)
- [Solutions](http://www.algorithm.cs.sunysb.edu/algowiki/index.php/The_Algorithms_Design_Manual_(Second_Edition))
- [Solutions](http://blog.panictank.net/category/algorithmndesignmanualsolutions/page/2/)
- [Errata](http://www3.cs.stonybrook.edu/~skiena/algorist/book/errata)
- [Write Great Code: Volume 1: Understanding the Machine](https://www.amazon.com/Write-Great-Code-Understanding-Machine/dp/1593270038)
@ -1469,12 +1435,10 @@ You're never really done.
- Chapter 10 - Instruction Set Architecture
- Chapter 11 - Memory Architecture and Organization
- [Introduction to Algorithms](https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844)
- **Important:** Reading this book will only have limited value. This book is a great review of algorithms and data structures, but won't teach you how to write good code. You have to be able to code a decent solution efficiently.
- aka CLR, sometimes CLRS, because Stein was late to the game
- [Computer Architecture, Sixth Edition: A Quantitative Approach](https://www.amazon.com/dp/0128119055)
- For a richer, more up-to-date (2017), but longer treatment
- [Programming Pearls](http://www.amazon.com/Programming-Pearls-2nd-Jon-Bentley/dp/0201657880)
@ -1487,14 +1451,12 @@ You're never really done.
technologies and algorithms, so you'll have a bigger toolbox.
- ### Compilers
- [How a Compiler Works in ~1 minute (video)](https://www.youtube.com/watch?v=IhC7sdYe-Jg)
- [Harvard CS50 - Compilers (video)](https://www.youtube.com/watch?v=CSZLNYF4Klo)
- [C++ (video)](https://www.youtube.com/watch?v=twodd1KFfGk)
- [Understanding Compiler Optimization (C++) (video)](https://www.youtube.com/watch?v=FnGCDLhaxKU)
- ### Emacs and vi(m)
- Familiarize yourself with a unix-based code editor
- vi(m):
- [Editing With vim 01 - Installation, Setup, and The Modes (video)](https://www.youtube.com/watch?v=5givLEMcINQ&index=1&list=PL13bz4SHGmRxlZVmWQ9DvXo1fEg4UdGkr)
@ -1516,7 +1478,6 @@ You're never really done.
- [(maybe) Org Mode In Depth: Managing Structure (video)](https://www.youtube.com/watch?v=nsGYet02bEk)
- ### Unix command line tools
- I filled in the list below from good tools.
- bash
- cat
@ -1531,7 +1492,6 @@ You're never really done.
- [tcpdump](https://danielmiessler.com/study/tcpdump/)
- ### Information theory (videos)
- [Khan Academy](https://www.khanacademy.org/computing/computer-science/informationtheory)
- more about Markov processes:
- [Core Markov Text Generation](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/waxgx/core-markov-text-generation)
@ -1540,7 +1500,6 @@ You're never really done.
- See more in MIT 6.050J Information and Entropy series below.
- ### Parity & Hamming Code (videos)
- [Intro](https://www.youtube.com/watch?v=q-3BctoUpHE)
- [Parity](https://www.youtube.com/watch?v=DdMcAUlxh1M)
- Hamming Code:
@ -1549,13 +1508,11 @@ You're never really done.
- [Error Checking](https://www.youtube.com/watch?v=wbH2VxzmoZk)
- ### Entropy
- also see videos below
- make sure to watch information theory videos first
- [Information Theory, Claude Shannon, Entropy, Redundancy, Data Compression & Bits (video)](https://youtu.be/JnJq3Py0dyM?t=176)
- ### Cryptography
- also see videos below
- make sure to watch information theory videos first
- [Khan Academy Series](https://www.khanacademy.org/computing/computer-science/cryptography)
@ -1563,7 +1520,6 @@ You're never really done.
- [Cryptography: Encryption](https://www.youtube.com/watch?v=9TNI2wHmaeI&index=31&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
- ### Compression
- make sure to watch information theory videos first
- Computerphile (videos):
- [Compression](https://www.youtube.com/watch?v=Lto-ajuqW3w)
@ -1576,7 +1532,6 @@ You're never really done.
- [(optional) Google Developers Live: GZIP is not enough!](https://www.youtube.com/watch?v=whGwm0Lky2s)
- ### Computer Security
- [MIT (23 videos)](https://www.youtube.com/playlist?list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
- [Introduction, Threat Models](https://www.youtube.com/watch?v=GqmQg-cszw4&index=1&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
- [Control Hijacking Attacks](https://www.youtube.com/watch?v=6bwzNg5qQ0o&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh&index=2)
@ -1592,18 +1547,15 @@ You're never really done.
- [Side-Channel Attacks](https://www.youtube.com/watch?v=PuVMkSEcPiI&index=15&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
- ### Garbage collection
- [GC in Python (video)](https://www.youtube.com/watch?v=iHVs_HkjdmI)
- [Deep Dive Java: Garbage Collection is Good!](https://www.infoq.com/presentations/garbage-collection-benefits)
- [Deep Dive Python: Garbage Collection in CPython (video)](https://www.youtube.com/watch?v=P-8Z0-MhdQs&list=PLdzf4Clw0VbOEWOS_sLhT_9zaiQDrS5AR&index=3)
- ### Parallel Programming
- [Coursera (Scala)](https://www.coursera.org/learn/parprog1/home/week/1)
- [Efficient Python for High Performance Parallel Computing (video)](https://www.youtube.com/watch?v=uY85GkaYzBk)
- ### Messaging, Serialization, and Queueing Systems
- [Thrift](https://thrift.apache.org/)
- [Tutorial](http://thrift-tutorial.readthedocs.io/en/latest/intro.html)
- [Protocol Buffers](https://developers.google.com/protocol-buffers/)
@ -1625,14 +1577,12 @@ You're never really done.
- [MessagePack](http://msgpack.org/index.html)
- [Avro](https://avro.apache.org/)
- ### A\*
- ### A*
- [A Search Algorithm](https://en.wikipedia.org/wiki/A*_search_algorithm)
- [A\* Pathfinding Tutorial (video)](https://www.youtube.com/watch?v=KNXfSOx4eEE)
- [A\* Pathfinding (E01: algorithm explanation) (video)](https://www.youtube.com/watch?v=-L-WgKMFuhE)
- [A* Pathfinding Tutorial (video)](https://www.youtube.com/watch?v=KNXfSOx4eEE)
- [A* Pathfinding (E01: algorithm explanation) (video)](https://www.youtube.com/watch?v=-L-WgKMFuhE)
- ### Fast Fourier Transform
- [An Interactive Guide To The Fourier Transform](https://betterexplained.com/articles/an-interactive-guide-to-the-fourier-transform/)
- [What is a Fourier transform? What is it used for?](http://www.askamathematician.com/2012/09/q-what-is-a-fourier-transform-what-is-it-used-for/)
- [What is the Fourier Transform? (video)](https://www.youtube.com/watch?v=Xxut2PN-V8Q)
@ -1640,7 +1590,6 @@ You're never really done.
- [Understanding The FFT](http://jakevdp.github.io/blog/2013/08/28/understanding-the-fft/)
- ### Bloom Filter
- Given a Bloom filter with m bits and k hashing functions, both insertion and membership testing are O(k)
- [Bloom Filters (video)](https://www.youtube.com/watch?v=-SuTGoFYjZs)
- [Bloom Filters | Mining of Massive Datasets | Stanford University (video)](https://www.youtube.com/watch?v=qBTdukbzc78)
@ -1648,26 +1597,21 @@ You're never really done.
- [How To Write A Bloom Filter App](http://blog.michaelschmatz.com/2016/04/11/how-to-write-a-bloom-filter-cpp/)
- ### HyperLogLog
- [How To Count A Billion Distinct Objects Using Only 1.5KB Of Memory](http://highscalability.com/blog/2012/4/5/big-data-counting-how-to-count-a-billion-distinct-objects-us.html)
- ### Locality-Sensitive Hashing
- used to determine the similarity of documents
- the opposite of MD5 or SHA which are used to determine if 2 documents/strings are exactly the same.
- [Simhashing (hopefully) made simple](http://ferd.ca/simhashing-hopefully-made-simple.html)
- ### van Emde Boas Trees
- [Divide & Conquer: van Emde Boas Trees (video)](https://www.youtube.com/watch?v=hmReJCupbNU&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=6)
- [MIT Lecture Notes](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-046j-design-and-analysis-of-algorithms-spring-2012/lecture-notes/MIT6_046JS12_lec15.pdf)
- ### Augmented Data Structures
- [CS 61B Lecture 39: Augmenting Data Structures](https://archive.org/details/ucberkeley_webcast_zksIj9O8_jc)
- ### Balanced search trees
- Know at least one type of balanced binary tree (and know how it's implemented):
- "Among balanced search trees, AVL and 2/3 trees are now passé, and red-black trees seem to be more popular.
A particularly interesting self-organizing data structure is the splay tree, which uses rotations
@ -1682,7 +1626,6 @@ You're never really done.
- [Self-balancing binary search tree](https://en.wikipedia.org/wiki/Self-balancing_binary_search_tree)
- **AVL trees**
- In practice:
From what I can tell, these aren't used much in practice, but I could see where they would be:
The AVL tree is another structure supporting O(log n) search, insertion, and removal. It is more rigidly
@ -1695,7 +1638,6 @@ You're never really done.
- [Split And Merge](https://www.coursera.org/learn/data-structures/lecture/22BgE/split-and-merge)
- **Splay trees**
- In practice:
Splay trees are typically used in the implementation of caches, memory allocators, routers, garbage collectors,
data compression, ropes (replacement of string used for long text strings), in Windows NT (in the virtual memory,
@ -1706,7 +1648,6 @@ You're never really done.
- [Video](https://www.youtube.com/watch?v=QnPl_Y6EqMo)
- **Red/black trees**
- these are a translation of a 2-3 tree (see below)
- In practice:
Red–black trees offer worst-case guarantees for insertion time, deletion time, and search time.
@ -1722,7 +1663,6 @@ You're never really done.
- [An Introduction To Binary Search And Red Black Tree](https://www.topcoder.com/community/competitive-programming/tutorials/an-introduction-to-binary-search-and-red-black-trees/)
- **2-3 search trees**
- In practice:
2-3 trees have faster inserts at the expense of slower searches (since height is more compared to AVL trees).
- You would use 2-3 tree very rarely because its implementation involves different types of nodes. Instead, people use Red Black trees.
@ -1731,7 +1671,6 @@ You're never really done.
- [2-3 Trees (student recitation) (video)](https://www.youtube.com/watch?v=TOb1tuEZ2X4&index=5&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
- **2-3-4 Trees (aka 2-4 trees)**
- In practice:
For every 2-4 tree, there are corresponding red–black trees with data elements in the same order. The insertion and deletion
operations on 2-4 trees are also equivalent to color-flipping and rotations in red–black trees. This makes 2-4 trees an
@ -1742,7 +1681,6 @@ You're never really done.
- [Top Down 234-Trees (video)](https://www.youtube.com/watch?v=2679VQ26Fp4&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6&index=5)
- **N-ary (K-ary, M-ary) trees**
- note: the N or K is the branching factor (max branches)
- binary trees are a 2-ary tree, with branching factor = 2
- 2-3 trees are 3-ary
@ -1760,62 +1698,56 @@ You're never really done.
- [Introduction to B-Trees (video)](https://www.youtube.com/watch?v=I22wEC1tTGo&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6&index=6)
- [B-Tree Definition and Insertion (video)](https://www.youtube.com/watch?v=s3bCdZGrgpA&index=7&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
- [B-Tree Deletion (video)](https://www.youtube.com/watch?v=svfnVhJOfMc&index=8&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
- [MIT 6.851 - Memory Hierarchy Models (video)](https://www.youtube.com/watch?v=V3omVLzI0WE&index=7&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf) - covers cache-oblivious B-Trees, very interesting data structures - the first 37 minutes are very technical, may be skipped (B is block size, cache line size)
- [MIT 6.851 - Memory Hierarchy Models (video)](https://www.youtube.com/watch?v=V3omVLzI0WE&index=7&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf)
- covers cache-oblivious B-Trees, very interesting data structures
- the first 37 minutes are very technical, may be skipped (B is block size, cache line size)
* ### k-D Trees
- ### k-D Trees
- great for finding number of points in a rectangle or higher dimension object
- a good fit for k-nearest neighbors
- [Kd Trees (video)](https://www.youtube.com/watch?v=W94M9D_yXKk)
- [kNN K-d tree algorithm (video)](https://www.youtube.com/watch?v=Y4ZgLlDfKDg)
* ### Skip lists
- ### Skip lists
- "These are somewhat of a cult data structure" - Skiena
- [Randomization: Skip Lists (video)](https://www.youtube.com/watch?v=2g9OSRKJuzM&index=10&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
- [For animations and a little more detail](https://en.wikipedia.org/wiki/Skip_list)
* ### Network Flows
- ### Network Flows
- [Ford-Fulkerson in 5 minutes — Step by step example (video)](https://www.youtube.com/watch?v=Tl90tNtKvxs)
- [Ford-Fulkerson Algorithm (video)](https://www.youtube.com/watch?v=v1VgJmkEJW0)
- [Network Flows (video)](https://www.youtube.com/watch?v=2vhN4Ice5jI)
* ### Disjoint Sets & Union Find
- ### Disjoint Sets & Union Find
- [UCB 61B - Disjoint Sets; Sorting & selection (video)](https://archive.org/details/ucberkeley_webcast_MAEGXTwmUsI)
- [Sedgewick Algorithms - Union-Find (6 videos)](https://www.coursera.org/learn/algorithms-part1/home/week/1)
* ### Math for Fast Processing
- ### Math for Fast Processing
- [Integer Arithmetic, Karatsuba Multiplication (video)](https://www.youtube.com/watch?v=eCaXlAaN2uE&index=11&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
- [The Chinese Remainder Theorem (used in cryptography) (video)](https://www.youtube.com/watch?v=ru7mWZJlRQg)
* ### Treap
- ### Treap
- Combination of a binary search tree and a heap
- [Treap](https://en.wikipedia.org/wiki/Treap)
- [Data Structures: Treaps explained (video)](https://www.youtube.com/watch?v=6podLUYinH8)
- [Applications in set operations](https://www.cs.cmu.edu/~scandal/papers/treaps-spaa98.pdf)
* ### Linear Programming (videos)
- ### Linear Programming (videos)
- [Linear Programming](https://www.youtube.com/watch?v=M4K6HYLHREQ)
- [Finding minimum cost](https://www.youtube.com/watch?v=2ACJ9ewUC6U)
- [Finding maximum value](https://www.youtube.com/watch?v=8AA_81xI3ik)
- [Solve Linear Equations with Python - Simplex Algorithm](https://www.youtube.com/watch?v=44pAWI7v5Zk)
* ### Geometry, Convex hull (videos)
- ### Geometry, Convex hull (videos)
- [Graph Alg. IV: Intro to geometric algorithms - Lecture 9](https://youtu.be/XIAQRlNkJAw?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=3164)
- [Geometric Algorithms: Graham & Jarvis - Lecture 10](https://www.youtube.com/watch?v=J5aJEcOr6Eo&index=10&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
- [Divide & Conquer: Convex Hull, Median Finding](https://www.youtube.com/watch?v=EzeYI7p9MjU&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=2)
* ### Discrete math
- ### Discrete math
- see videos below
* ### Machine Learning
- ### Machine Learning
- Why ML?
- [How Google Is Remaking Itself As A Machine Learning First Company](https://backchannel.com/how-google-is-remaking-itself-as-a-machine-learning-first-company-ada63defcb70)
- [Large-Scale Deep Learning for Intelligent Computer Systems (video)](https://www.youtube.com/watch?v=QSaZGT4-6EY)
@ -1826,12 +1758,14 @@ You're never really done.
- [Tensorflow Tutorials](https://www.tensorflow.org/versions/r0.11/tutorials/index.html)
- [Practical Guide to implementing Neural Networks in Python (using Theano)](http://www.analyticsvidhya.com/blog/2016/04/neural-networks-python-theano/)
- Courses:
- [Great starter course: Machine Learning](https://www.coursera.org/learn/machine-learning) - [videos only](https://www.youtube.com/playlist?list=PLZ9qNFMHZ-A4rycgrgOYma6zxF4BZGGPW) - see videos 12-18 for a review of linear algebra (14 and 15 are duplicates)
- [Great starter course: Machine Learning](https://www.coursera.org/learn/machine-learning)
- [videos only](https://www.youtube.com/playlist?list=PLZ9qNFMHZ-A4rycgrgOYma6zxF4BZGGPW)
- see videos 12-18 for a review of linear algebra (14 and 15 are duplicates)
- [Neural Networks for Machine Learning](https://www.coursera.org/learn/neural-networks)
- [Google's Deep Learning Nanodegree](https://www.udacity.com/course/deep-learning--ud730)
- [Google/Kaggle Machine Learning Engineer Nanodegree](https://www.udacity.com/course/machine-learning-engineer-nanodegree-by-google--nd009)
- [Self-Driving Car Engineer Nanodegree](https://www.udacity.com/drive)
- [Metis Online Course (\$99 for 2 months)](http://www.thisismetis.com/explore-data-science)
- [Metis Online Course ($99 for 2 months)](http://www.thisismetis.com/explore-data-science)
- Resources:
- Books:
- [Python Machine Learning](https://www.amazon.com/Python-Machine-Learning-Sebastian-Raschka/dp/1783555130/)
@ -1863,8 +1797,8 @@ You're never really done.
- [Why Is The Dependency Inversion Principle And Why Is It Important](http://stackoverflow.com/questions/62539/what-is-the-dependency-inversion-principle-and-why-is-it-important)
- [more flavor](http://docs.google.com/a/cleancoder.com/viewer?a=v&pid=explorer&chrome=true&srcid=0BwhCYaYDn8EgMjdlMWIzNGUtZTQ0NC00ZjQ5LTkwYzQtZjRhMDRlNTQ3ZGMz&hl=en)
* **Union-Find**
- **Union-Find**
- [Overview](https://www.coursera.org/learn/data-structures/lecture/JssSY/overview)
- [Naive Implementation](https://www.coursera.org/learn/data-structures/lecture/EM5D0/naive-implementations)
- [Trees](https://www.coursera.org/learn/data-structures/lecture/Mxu0w/trees)
@ -1872,8 +1806,7 @@ You're never really done.
- [Path Compression](https://www.coursera.org/learn/data-structures/lecture/Q9CVI/path-compression)
- [Analysis Options](https://www.coursera.org/learn/data-structures/lecture/GQQLN/analysis-optional)
* **More Dynamic Programming** (videos)
- **More Dynamic Programming** (videos)
- [6.006: Dynamic Programming I: Fibonacci, Shortest Paths](https://www.youtube.com/watch?v=OQ5jsbhAv_M&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=19)
- [6.006: Dynamic Programming II: Text Justification, Blackjack](https://www.youtube.com/watch?v=ENyox7kNKeY&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=20)
- [6.006: DP III: Parenthesization, Edit Distance, Knapsack](https://www.youtube.com/watch?v=ocZMDMZwhCY&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=21)
@ -1882,13 +1815,11 @@ You're never really done.
- [6.046: Dynamic Programming: All-Pairs Shortest Paths](https://www.youtube.com/watch?v=NzgFUwOaoIw&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=15)
- [6.046: Dynamic Programming (student recitation)](https://www.youtube.com/watch?v=krZI60lKPek&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=12)
* **Advanced Graph Processing** (videos)
- **Advanced Graph Processing** (videos)
- [Synchronous Distributed Algorithms: Symmetry-Breaking. Shortest-Paths Spanning Trees](https://www.youtube.com/watch?v=mUBmcbbJNf4&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=27)
- [Asynchronous Distributed Algorithms: Shortest-Paths Spanning Trees](https://www.youtube.com/watch?v=kQ-UQAzcnzA&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=28)
* MIT **Probability** (mathy, and go slowly, which is good for mathy things) (videos):
- MIT **Probability** (mathy, and go slowly, which is good for mathy things) (videos):
- [MIT 6.042J - Probability Introduction](https://www.youtube.com/watch?v=SmFwFdESMHI&index=18&list=PLB7540DEDD482705B)
- [MIT 6.042J - Conditional Probability](https://www.youtube.com/watch?v=E6FbvM-FGZ8&index=19&list=PLB7540DEDD482705B)
- [MIT 6.042J - Independence](https://www.youtube.com/watch?v=l1BCv3qqW4A&index=20&list=PLB7540DEDD482705B)
@ -1898,10 +1829,9 @@ You're never really done.
- [MIT 6.042J - Large Deviations](https://www.youtube.com/watch?v=q4mwO2qS2z4&index=24&list=PLB7540DEDD482705B)
- [MIT 6.042J - Random Walks](https://www.youtube.com/watch?v=56iFMY8QW2k&list=PLB7540DEDD482705B&index=25)
* [Simonson: Approximation Algorithms (video)](https://www.youtube.com/watch?v=oDniZCmNmNw&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=19)
* **String Matching**
- [Simonson: Approximation Algorithms (video)](https://www.youtube.com/watch?v=oDniZCmNmNw&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=19)
- **String Matching**
- Rabin-Karp (videos):
- [Rabin Karps Algorithm](https://www.coursera.org/learn/data-structures/lecture/c0Qkw/rabin-karps-algorithm)
- [Precomputing](https://www.coursera.org/learn/data-structures/lecture/nYrc8/optimization-precomputation)
@ -1918,7 +1848,7 @@ You're never really done.
- nice explanation of tries
- can be skipped
* **Sorting**
- **Sorting**
- Stanford lectures on sorting:
- [Lecture 15 | Programming Abstractions (video)](https://www.youtube.com/watch?v=ENp00xylP7c&index=15&list=PLFE6E58F856038C69)
@ -1951,7 +1881,6 @@ Sit back and enjoy. "Netflix and skill" :P
- [Discrete Mathematics Part 1 by Sarada Herke (5 videos)](https://www.youtube.com/playlist?list=PLGxuz-nmYlQPOc4w1Kp2MZrdqOOm4Jxeo)
- CSE373 - Analysis of Algorithms (25 videos)
- [Skiena lectures from Algorithm Design Manual](https://www.youtube.com/watch?v=ZFjhkohHdAA&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=1)
- [UC Berkeley 61B (Spring 2014): Data Structures (25 videos)](https://archive.org/details/ucberkeley-webcast-PL-XXv-cvA_iAlnI-BQr9hjqADPBtujFJd)
@ -1991,7 +1920,6 @@ Sit back and enjoy. "Netflix and skill" :P
- [Stanford: Programming Paradigms (27 videos)](https://www.youtube.com/view_play_list?p=9D558D49CA734A02)
- [Introduction to Cryptography by Christof Paar](https://www.youtube.com/playlist?list=PL6N5qY2nvvJE8X75VkXglSrVhLv1tVcfy)
- [Course Website along with Slides and Problem Sets](http://www.crypto-textbook.com/)
- [Mining Massive Datasets - Stanford University (94 videos)](https://www.youtube.com/playlist?list=PLLssT5z_DsK9JDLcT8T62VtzwyW9LNepV)
@ -2010,7 +1938,7 @@ Sit back and enjoy. "Netflix and skill" :P
- [implemented in Go](https://godoc.org/github.com/thomas11/csp)
- [2003: The Google File System](http://static.googleusercontent.com/media/research.google.com/en//archive/gfs-sosp2003.pdf)
- replaced by Colossus in 2012
- [2004: MapReduce: Simplified Data Processing on Large Clusters](http://static.googleusercontent.com/media/research.google.com/en//archive/mapreduce-osdi04.pdf)
- [2004: MapReduce: Simplified Data Processing on Large Clusters]( http://static.googleusercontent.com/media/research.google.com/en//archive/mapreduce-osdi04.pdf)
- mostly replaced by Cloud Dataflow?
- [2006: Bigtable: A Distributed Storage System for Structured Data](https://static.googleusercontent.com/media/research.google.com/en//archive/bigtable-osdi06.pdf)
- [An Inside Look at Google BigQuery](https://cloud.google.com/files/BigQueryTechnicalWP.pdf)
@ -2031,10 +1959,11 @@ Sit back and enjoy. "Netflix and skill" :P
- [2014: Machine Learning: The High-Interest Credit Card of Technical Debt](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43146.pdf)
- [2015: Continuous Pipelines at Google](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43790.pdf)
- [2015: High-Availability at Massive Scale: Building Google’s Data Infrastructure for Ads](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/44686.pdf)
- [2015: TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems](http://download.tensorflow.org/paper/whitepaper2015.pdf)
- [2015: TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed Systems](http://download.tensorflow.org/paper/whitepaper2015.pdf )
- [2015: How Developers Search for Code: A Case Study](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43835.pdf)
- [2016: Borg, Omega, and Kubernetes](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/44843.pdf)
## LICENSE
[CC-BY-SA-4.0](./LICENSE.txt)