|
|
# Przygotowanie do rozmowy kwalifikacyjnej w Google - Coding Interview University
|
|
|
|
|
|
> Pierwotnie stworzyłem ten projekt, jako krótką listę tematów do nauki, które warto poznać aby zostać Software Engineer,
|
|
|
> ale powiększył się do dużej listy, którą widzisz dzisiaj. Po przejściu przez ten plan studiów [zostałem zatrudniony
|
|
|
> jako Software Development Engineer w Amazon](https://startupnextdoor.com/ive-been-acquired-by-amazon/?src=ciu)!
|
|
|
> Prawdopodobnie nie będziesz musiał uczyć się tak dużo jak ja. W każdym razie wszystko, czego potrzebujesz, jest tutaj.
|
|
|
>
|
|
|
> Przez kilka miesięcy uczyłem się około 8-12 godzin dziennie. Oto moja historia: [Dlaczego uczyłem się w pełnym wymiarze godzin przez 8 miesięcy na rozmowę w Google](https://medium.freecodecamp.org/why-i-studied-full-time-for-8-months-for-a-google-interview-cc662ce9bb13)
|
|
|
>
|
|
|
> Pozycje wymienione tutaj dobrze przygotują cię na wywiad techniczny w prawie każdej firmie zajmującej się wytwarzaniem oprogramowania, włączając w to takich gigantów jak: Amazon, Facebook, Google, and Microsoft.
|
|
|
>
|
|
|
> *Powodzenia!*
|
|
|
|
|
|
<details>
|
|
|
<summary>Tłumaczenia:</summary>
|
|
|
- [Bahasa Indonesia](translations/README-id.md)
|
|
|
- [Bulgarian](translations/README-bg.md)
|
|
|
- [Español](translations/README-es.md)
|
|
|
- [German](translations/README-de.md)
|
|
|
- [Japanese (日本語)](translations/README-ja.md)
|
|
|
- [Polish](translations/README-pl.md)
|
|
|
- [Português Brasileiro](translations/README-ptbr.md)
|
|
|
- [Russian](translations/README-ru.md)
|
|
|
- [Tiếng Việt - Vietnamese](translations/README-vi.md)
|
|
|
- [Urdu - اردو](tanslations/README-ur.md)
|
|
|
- [Uzbek](translations/README-uz.md)
|
|
|
- [বাংলা - Bangla](translations/README-bn.md)
|
|
|
- [ខ្មែរ - Khmer](translations/README-kh.md)
|
|
|
- [简体中文](translations/README-cn.md)
|
|
|
- [繁體中文](translations/README-tw.md)
|
|
|
</details>
|
|
|
|
|
|
<details>
|
|
|
<summary>Tłumaczenia w trakcie:</summary>
|
|
|
|
|
|
- [Afrikaans](https://github.com/jwasham/coding-interview-university/issues/1164)
|
|
|
- [Arabic](https://github.com/jwasham/coding-interview-university/issues/98)
|
|
|
- [French](https://github.com/jwasham/coding-interview-university/issues/89)
|
|
|
- [Greek](https://github.com/jwasham/coding-interview-university/issues/166)
|
|
|
- [Italian](https://github.com/jwasham/coding-interview-university/issues/1030)
|
|
|
- [Korean(한국어)](https://github.com/jwasham/coding-interview-university/issues/118)
|
|
|
- [Malayalam](https://github.com/jwasham/coding-interview-university/issues/239)
|
|
|
- [Persian - Farsi](https://github.com/jwasham/coding-interview-university/issues/186)
|
|
|
- [Telugu](https://github.com/jwasham/coding-interview-university/issues/117)
|
|
|
- [Thai](https://github.com/jwasham/coding-interview-university/issues/156)
|
|
|
- [Turkish](https://github.com/jwasham/coding-interview-university/issues/90)
|
|
|
- [Українська](https://github.com/jwasham/coding-interview-university/issues/106)
|
|
|
- [עברית](https://github.com/jwasham/coding-interview-university/issues/82)
|
|
|
- [हिन्दी](https://github.com/jwasham/coding-interview-university/issues/81)
|
|
|
</details>
|
|
|
|
|
|
<div align="center">
|
|
|
<hr />
|
|
|
<p>
|
|
|
<a href="https://github.com/sponsors/jwasham"><strong>Become a sponsor</strong> and support Coding Interview University!</a>
|
|
|
</p>
|
|
|
<hr />
|
|
|
</div>
|
|
|
## Co to jest?
|
|
|
|
|
|
To jest mój wielomiesięczny plan nauki od przejścia od programisty (samouka, bez dyplomu CS - informatyki) do inżyniera oprogramowania dla dużej firmy.
|
|
|
|
|
|
![Coding at the whiteboard - from HBO's Silicon Valley](https://d3j2pkmjtin6ou.cloudfront.net/coding-at-the-whiteboard-silicon-valley.png)
|
|
|
|
|
|
Jest to przeznaczone dla **początkujących software engineers** lub tych przełączających się z software/web development na software engineering (gdzie wiedza z informatyki jest wymagana). Jeśli masz wieloletnie doświadczenie i stwierdziłeś, że masz wieloletnie doświadczenie w inżynierii oprogramowania, oczekuj trudniejszej rozmowy.
|
|
|
|
|
|
Jeśli masz wieloletnie doświadczenie w tworzeniu oprogramowania/stron internetowych, pamiętaj, że duże firmy programistyczne, takie jak Google, Amazon, Facebook i Microsoft postrzegają inżynierię oprogramowania jako inną niż tworzenie oprogramowania / stron internetowych i wymagają wiedzy informatycznej.
|
|
|
|
|
|
Jeśli chcesz być inżynierem ds. niezawodności i bezpieczeństwa lub systemów, zapoznaj się z listą dodatkową (sieć, bezpieczeństwo).
|
|
|
|
|
|
---
|
|
|
|
|
|
## Spis treści
|
|
|
|
|
|
- [Co to jest?](#co-to-jest)
|
|
|
- [Dlaczego z tego korzystać?](#dlaczego-z-tego-korzystać)
|
|
|
- [Jak tego używać](#jak-tego-używać)
|
|
|
- [Nie uważaj, że jesteś niewystarczająco mądry](#nie-uważaj-że-jesteś-niewystarczająco-mądry)
|
|
|
- [Informacje o materiałach wideo](#informacje-o-materiałach-wideo)
|
|
|
- [Proces rozmowy i ogólne przygotowanie do rekrutacji](#proces-rozmowy-i-ogólne-przygotowanie-do-rekrutacji)
|
|
|
- [Wybierz jeden język do rozmowy kwalifikacyjnej](#wybierz-jeden-język-do-rozmowy-kwalifikacyjnej)
|
|
|
- [Lista książek](#lista-książek)
|
|
|
- [Zanim zaczniesz](#zanim-zaczniesz)
|
|
|
- [Czego tutaj nie zobaczysz](#czego-tutaj-nie-zobaczysz)
|
|
|
- [Wymagana wiedza](#wymagana-wiedza)
|
|
|
- [Plan dzienny](#plan-dzienny)
|
|
|
- [Złożoność algorytmiczna / Big-O / Analiza asymptotyczna](#złożoność-algorytmiczna--big-o--analiza-asymptotyczna)
|
|
|
- [Struktury danych](#struktury-danych)
|
|
|
- [Arrays](#arrays)
|
|
|
- [Listy łączone](#listy-łączone)
|
|
|
- [Stos](#stos)
|
|
|
- [Kolejka](#kolejka)
|
|
|
- [Hash table - tablica mieszająca](#hash-table--tablica-mieszająca)
|
|
|
- [Więcej wiedzy](#więcej-wiedzy)
|
|
|
- [Binary search](#binary-search)
|
|
|
- [Operacje bitowe](#operacje-bitowe)
|
|
|
- [Drzewa](#drzewa)
|
|
|
- [Drzewa - uwagi & zarys](#trees---uwagi--zarys)
|
|
|
- [Binary search trees: BSTs - drzewa binarne](#binary-search-trees-bsts--drzewa-binarne)
|
|
|
- [Sterta / kolejka priorytetowa / sterta binarna](#sterta--kolejka-priorytetowa--sterta-binarna)
|
|
|
- balanced search trees (general concept, not details)
|
|
|
- traversals: preorder, inorder, postorder, BFS, DFS
|
|
|
- [Sortowanie](#sortowanie)
|
|
|
- selection (sortowanie przez wybieranie)
|
|
|
- insertion (sortowanie przez wstawianie)
|
|
|
- heapsort (sortowanie przez kopcowanie)
|
|
|
- quicksort (sortowanie szybkie)
|
|
|
- merge sort (sortowanie przez scalanie)
|
|
|
- [Grafy](#grafy)
|
|
|
- skierowany
|
|
|
- nieskierowany
|
|
|
- macierz sąsiedztwa
|
|
|
- lista sąsiedztwa
|
|
|
- traversals: BFS, DFS
|
|
|
- [Znów więcej wiedzy](#znów-więcej-wiedzy)
|
|
|
- [Rekursja](#rekursja)
|
|
|
- [Programowanie dynamiczne](#programowanie-dynamiczne)
|
|
|
- [Object-Oriented Programming - programowanie obiektowe](#object-oriented-programming--programowanie-obiektowe)
|
|
|
- [wzorce-projektowe](#wzorce-projektowe)
|
|
|
- [Kombinatoryka (n choose k) & probabilistyka](#kombinatoryka-n-choose-k--probabilistyka)
|
|
|
- [NP, NP-Complete and Approximation Algorithms](#np-np-complete-and-approximation-algorithms)
|
|
|
- [Caches](#caches)
|
|
|
- [Procesy i wątki](#procesy-i-wątki)
|
|
|
- [Testowanie](#testowanie)
|
|
|
- [Scheduling](#scheduling)
|
|
|
- [String searching & manipulations](#string-searching--manipulations)
|
|
|
- [Tries](#tries)
|
|
|
- [Floating Point Numbers](#floating-point-numbers)
|
|
|
- [Unicode](#unicode)
|
|
|
- [Endianness](#endianness)
|
|
|
- [Networking](#networking)
|
|
|
- [Projektowanie systemu, skalowalność, przetwarzanie danych](#projektowanie-systemu-skalowalność-przetwarzanie-danych) (jeśli masz 4+ lat doświadczenia)
|
|
|
- [Końcowa rozmowa rekrutacyjna](#końcowa-rozmowa-rekrutacyjna)
|
|
|
- [Praktyka kodowania](#praktyka-kodowania)
|
|
|
- [Zadania/wyzwania programistyczne](#zadania-wyzwania-programistyczne)
|
|
|
- [Gdy już jesteś bliżej rozmowy rekrutacyjnej](#gdy-już-jesteś-bliżej-rozmowy-rekrutacyjnej)
|
|
|
- [Twoje CV](#twoje-cv)
|
|
|
- [Zastanów się, kiedy rozmowa kwalifikacyjna będzie nadchodzić](#zastanów-się-kiedy-rozmowa-kwalifikacyjna-będzie-nadchodzić)
|
|
|
- [Pytania dla rekrutera](#pytania-dla-rekrutera)
|
|
|
- [Gdy już zdobędziesz pracę](#gdy-już-zdobędziesz-pracę)
|
|
|
|
|
|
---------------- Wszystko poniżej tego punktu jest nadprogramowe ----------------
|
|
|
|
|
|
## Dodatkowe materiały
|
|
|
|
|
|
- [Dodatkowe książki](#dodatkowe-książki)
|
|
|
- [Dodatkowe materiały](#dodatkowe-materiały)
|
|
|
- [Kompilatory](#kompilatory)
|
|
|
- [Emacs oraz vi(m)](#emacs-oraz-vim)
|
|
|
- [Narzędzia wiersza poleceń systemu Unix](#narzędzia-wiersza-poleceń-systemu-unix)
|
|
|
- [Teoria informacji](#teoria-informacji-filmy)
|
|
|
- [Parity & Hamming Code](#parity--hamming-code-videos)
|
|
|
- [Entropia](#entropia)
|
|
|
- [Kryptografia](#kryptografia)
|
|
|
- [Kompresja](#kompresja)
|
|
|
- [Bezpieczeństwo komputerowe](#bezpieczeństwo-komputerowe)
|
|
|
- [Garbage collection - Odśmiecanie pamięci](#garbage-collection--odśmiecanie-pamięci)
|
|
|
- [Parallel Programming](#parallel-programming)
|
|
|
- [Messaging, Serialization, and Queueing Systems](#messaging-serialization-and-queueing-systems)
|
|
|
- [A*](#a)
|
|
|
- [Szybka transformata Fouriera](#szybka-transformata-fouriera)
|
|
|
- [Filtr Blooma](#filtr-blooma)
|
|
|
- [HyperLogLog](#hyperloglog)
|
|
|
- [Locality-Sensitive Hashing](#locality-sensitive-hashing)
|
|
|
- [van Emde Boas Trees](#van-emde-boas-trees)
|
|
|
- [Augmented Data Structures](#augmented-data-structures)
|
|
|
- [Balanced search trees](#balanced-search-trees)
|
|
|
- drzewa AVL
|
|
|
- drzewa Splay
|
|
|
- drzewa czerwono-czarne
|
|
|
- 2-3 search trees
|
|
|
- 2-3-4 Trees (aka 2-4 trees)
|
|
|
- N-ary (K-ary, M-ary) trees
|
|
|
- B-Trees
|
|
|
- [k-D Trees](#k-d-trees)
|
|
|
- [Skip lists](#skip-lists)
|
|
|
- [Network Flows](#network-flows)
|
|
|
- [Disjoint Sets & Union Find](#disjoint-sets--union-find)
|
|
|
- [Math for Fast Processing](#math-for-fast-processing)
|
|
|
- [Sterta](#sterta)
|
|
|
- [Programowanie liniowe](#programowanie-liniowe)
|
|
|
- [Geometry, Convex hull](#geometry-convex-hull-videos)
|
|
|
- [Matematyka dyskretna](#matematyka-dyskretna)
|
|
|
- [Machine Learning - Uczenie maszynowe](#machine-learning--uczenie-maszynowe)
|
|
|
- [Dodatkowe szczegóły na niektóre tematy](#dodatkowe-szczegóły-na-niektóre-tematy)
|
|
|
- [Serie wideo](#serie-wideo)
|
|
|
- [Kursy Computer Science](#kursy-computer-science)
|
|
|
- [Literatura](#literatura)
|
|
|
|
|
|
---
|
|
|
|
|
|
## Dlaczego z tego korzystać?
|
|
|
|
|
|
Kiedy rozpocząłem ten projekt, nie rozpoznawałem stosu (stack) od sterty (heap), nie znałem notacji dużego O (złożoności obliczeniowej algorytmów, asymptotycznego tempa wzrostu), nie wiedziałem nic o drzewach ani tego, jak przejść przez graf. Gdybym musiał kodować algorytm sortowania, mogę powiedzieć, że nie byłby zbyt dobry.
|
|
|
Wszystkie struktury danych, z którymi miałem kiedykolwiek do czynienia, były wbudowane w język i nie wiedziałem w ogóle, jak działają pod maską. Nigdy nie musiałem zarządzać pamięcią, chyba że uruchamiany przeze mnie proces wyrzuciłby błąd "out of
|
|
|
memory", a potem musiałbym znaleźć obejście. W swoim życiu użyłem kilku wielowymiarowych tablic i tysiące tablic asocjacyjnych, ale nigdy nie tworzyłem struktur danych od zera.
|
|
|
|
|
|
To długi plan. Może on zająć miesiące. Jeśli jednak znasz już co nieco z tego, zajmie ci to znacznie mniej czasu.
|
|
|
|
|
|
## Jak tego używać
|
|
|
|
|
|
Wszystko poniżej jest konspektem i powinieneś zajmować się tymi punktami w kolejności od góry do dołu.
|
|
|
|
|
|
Używam specjalnej odmiany Markdown GitHub, w tym list zadań do sprawdzania postępów.
|
|
|
|
|
|
**Utwórz nową gałąź (brancha), aby móc sprawdzać te pozycje, po prostu wstawiając x w nawiasach: [x]**
|
|
|
|
|
|
|
|
|
Fork a branch and follow the commands below
|
|
|
|
|
|
`git checkout -b progress`
|
|
|
|
|
|
`git remote add jwasham https://github.com/jwasham/coding-interview-university`
|
|
|
|
|
|
`git fetch --all`
|
|
|
|
|
|
Mark all boxes with X after you completed your changes
|
|
|
|
|
|
`git add .`
|
|
|
|
|
|
`git commit -m "Marked x"`
|
|
|
|
|
|
`git rebase jwasham/main`
|
|
|
|
|
|
`git push --force`
|
|
|
|
|
|
[Więcej na temat Github-flavored markdown](https://guides.github.com/features/mastering-markdown/#GitHub-flavored-markdown)
|
|
|
|
|
|
|
|
|
## Nie uważaj, że jesteś niewystarczająco mądry
|
|
|
|
|
|
- Odnoszący sukcesy inżynierowie oprogramowania są mądrzy, ale wielu nie ma pewności siebie odnośnie tego, że nie są wystarczająco mądrzy.
|
|
|
- [The myth of the Genius Programmer](https://www.youtube.com/watch?v=0SARbwvhupQ)
|
|
|
- [It's Dangerous to Go Alone: Battling the Invisible Monsters in Tech](https://www.youtube.com/watch?v=1i8ylq4j_EY)
|
|
|
|
|
|
## Informacje o materiałach wideo
|
|
|
|
|
|
Niektóre filmy są dostępne tylko po zapisaniu się na kurs Coursera lub EdX. Są to tak zwane MOOC.
|
|
|
Czasami zajęcia nie są w sesji, więc musisz poczekać kilka miesięcy, więc wtedy nie masz dostępu.
|
|
|
|
|
|
Będę wdzięczny za pomoc w dodawaniu bezpłatnych i zawsze dostępnych źródeł publicznych, takich jak filmy z YouTube, które towarzyszą filmom z kursów online.
|
|
|
Lubię korzystać z wykładów uniwersyteckich.
|
|
|
|
|
|
|
|
|
## Proces rozmowy i ogólne przygotowanie do rekrutacji
|
|
|
|
|
|
- [ ] [ABC: Always Be Coding](https://medium.com/always-be-coding/abc-always-be-coding-d5f8051afce2#.4heg8zvm4)
|
|
|
- [ ] [Whiteboarding](https://medium.com/@dpup/whiteboarding-4df873dbba2e#.hf6jn45g1)
|
|
|
- [ ] [Demystifying Tech Recruiting](https://www.youtube.com/watch?v=N233T0epWTs)
|
|
|
- [ ] How to Get a Job at the Big 4:
|
|
|
- [ ] [How to Get a Job at the Big 4 - Amazon, Facebook, Google & Microsoft (video)](https://www.youtube.com/watch?v=YJZCUhxNCv8)
|
|
|
- [ ] Cracking The Coding Interview Set 1:
|
|
|
- [ ] [Gayle L McDowell - Cracking The Coding Interview (video)](https://www.youtube.com/watch?v=rEJzOhC5ZtQ)
|
|
|
- [ ] [Cracking the Coding Interview with Author Gayle Laakmann McDowell (video)](https://www.youtube.com/watch?v=aClxtDcdpsQ)
|
|
|
- [ ] Cracking the Facebook Coding Interview
|
|
|
- [ ] [The Approach](https://www.youtube.com/watch?v=wCl9kvQGHPI)
|
|
|
- [ ] [Problem Walkthrough](https://www.youtube.com/watch?v=4UWDyJq8jZg)
|
|
|
- [ ] Prep Course:
|
|
|
- [ ] [Software Engineer Interview Unleashed (paid course)](https://www.udemy.com/software-engineer-interview-unleashed):
|
|
|
- Dowiedz się, jak przygotować się na rozmowę kwalifikacyjną na inżyniera oprogramowania od byłego rekrutera Google.
|
|
|
- [ ] [Python for Data Structures, Algorithms, and Interviews (paid course)](https://www.udemy.com/python-for-data-structures-algorithms-and-interviews/):
|
|
|
- Kurs przygotowujący do rekrutacji skoncentrowanej na Pythonie, który obejmuje struktury danych, algorytmy, próbne zadania i wiele innych.
|
|
|
- [ ] [Intro to Data Structures and Algorithms using Python (Udacity free course)](https://www.udacity.com/course/data-structures-and-algorithms-in-python--ud513):
|
|
|
- Darmowy kurs struktur i algorytmów skoncentrowanych na języku Python.
|
|
|
- [ ] [Data Structures and Algorithms Nanodegree! (Udacity paid Nanodegree)](https://www.udacity.com/course/data-structures-and-algorithms-nanodegree--nd256):
|
|
|
- Przećwicz praktyczne ćwiczenia z ponad 100 struktur danych i ćwiczeń algorytmicznych oraz wskazówek od dedykowanego mentora, aby pomóc Ci przygotować się na rozmowy kwalifikacyjne i scenariusze w miejscu pracy.
|
|
|
|
|
|
## Wybierz jeden język do rozmowy kwalifikacyjnej
|
|
|
|
|
|
Możesz użyć języka, w którym czujesz się komfortowo, aby wykonać część wywiadu dotyczącą programowania, ale w przypadku dużych firm są to solidne propozycje:
|
|
|
|
|
|
- C++
|
|
|
- Java
|
|
|
- Python
|
|
|
|
|
|
Możesz ich również użyć, ale najpierw przeczytaj co nieco. Mogą istnieć zastrzeżenia:
|
|
|
|
|
|
- JavaScript
|
|
|
- Ruby
|
|
|
|
|
|
Oto artykuł, który napisałem o wyborze języka do rozmowy kwalifikacyjnej: [Wybierz jeden język do wywiadu kodującego](https://startupnextdoor.com/important-pick-one-language-for-the-coding-interview/)
|
|
|
|
|
|
Musisz czuć się bardzo wygodnie w języku i posiadać z niego wiedzę.
|
|
|
|
|
|
Przeczytaj więcej na temat wyborów tutaj:
|
|
|
- http://www.byte-by-byte.com/choose-the-right-language-for-your-coding-interview/
|
|
|
- http://blog.codingforinterviews.com/best-programming-language-jobs/
|
|
|
|
|
|
[Zobacz materiały językowe tutaj](programming-language-resources.md)
|
|
|
|
|
|
Poniżej zobaczysz trochę uczenia się C, C ++ i Python, ponieważ uczę się. W grę wchodzi kilka książek, patrz na dole.
|
|
|
|
|
|
## Lista książek
|
|
|
|
|
|
To jest krótsza lista niż ta, której użyłem. Jest to skrócone, aby zaoszczędzić czas.
|
|
|
|
|
|
### Przygotowanie do rozmowy rekrutacyjnej
|
|
|
|
|
|
- [ ] [Programming Interviews Exposed: Coding Your Way Through the Interview, 4th Edition](https://www.amazon.com/Programming-Interviews-Exposed-Through-Interview/dp/111941847X/)
|
|
|
- odpowiedzi w C++ oraz Java
|
|
|
- to dobra rozgrzewka przed Cracking the Coding Interview
|
|
|
- nie jest zbyt trudne, większość problemów może być łatwiejsza niż to, co zobaczysz podczas rekrutacji (z tego, co przeczytałem)
|
|
|
- [ ] [Cracking the Coding Interview, 6th Edition](http://www.amazon.com/Cracking-Coding-Interview-6th-Programming/dp/0984782850/)
|
|
|
- odpowiedzi w Java
|
|
|
|
|
|
### Jeśli masz mnóstwo dodatkowego czasu:
|
|
|
|
|
|
Wybierz jeden:
|
|
|
|
|
|
- [ ] [Elements of Programming Interviews (C++ version)](https://www.amazon.com/Elements-Programming-Interviews-Insiders-Guide/dp/1479274836)
|
|
|
- [ ] [Elements of Programming Interviews in Python](https://www.amazon.com/Elements-Programming-Interviews-Python-Insiders/dp/1537713949/)
|
|
|
- [ ] Elements of Programming Interviews (Java version)
|
|
|
- [book](https://www.amazon.com/Elements-Programming-Interviews-Java-Insiders/dp/1517435803/)
|
|
|
- [Companion Project - Method Stub and Test Cases for Every Problem in the Book](https://github.com/gardncl/elements-of-programming-interviews)
|
|
|
|
|
|
### Konkretny język
|
|
|
|
|
|
**Musisz wybrać język do rozmowy kwalifikacyjnej (patrz powyżej).**
|
|
|
|
|
|
Oto moje rekomendacje według języka. Nie mam materiałów dla wszystkich języków. Miło widziane dodatki.
|
|
|
|
|
|
Jeśli zapoznasz się z jednym z nich, powinieneś mieć całą wiedzę na temat struktur danych i algorytmów, których potrzebujesz, aby zacząć robić problemy z kodowaniem.
|
|
|
**Możesz pominąć wszystkie wykłady wideo w tym projekcie**, chyba że chcesz recenzję.
|
|
|
|
|
|
[Dodatkowe materiały specyficzne dla języka tutaj.](programming-language-resources.md)
|
|
|
|
|
|
### C++
|
|
|
|
|
|
Nie przeczytałem tych dwóch, ale są wysoko ocenione i napisane przez Sedgewicka. On jest wspaniały.
|
|
|
|
|
|
- [ ] [Algorithms in C++, Parts 1-4: Fundamentals, Data Structure, Sorting, Searching](https://www.amazon.com/Algorithms-Parts-1-4-Fundamentals-Structure/dp/0201350882/)
|
|
|
- [ ] [Algorithms in C++ Part 5: Graph Algorithms](https://www.amazon.com/Algorithms-Part-Graph-3rd-Pt-5/dp/0201361183/)
|
|
|
|
|
|
Jeśli masz lepszą rekomendację dla C++, daj mi znać. W poszukiwaniu wyczerpującego materiału.
|
|
|
|
|
|
### Java
|
|
|
|
|
|
- [ ] [Algorithms (Sedgewick and Wayne)](https://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X/)
|
|
|
- filmy z zawartością książek (i Sedgewick!) na coursera:
|
|
|
- [Algorytmy I](https://www.coursera.org/learn/algorithms-part1)
|
|
|
- [Algorytmy II](https://www.coursera.org/learn/algorithms-part2)
|
|
|
|
|
|
LUB:
|
|
|
|
|
|
- [ ] [Data Structures and Algorithms in Java](https://www.amazon.com/Data-Structures-Algorithms-Michael-Goodrich/dp/1118771338/)
|
|
|
- od Goodrich, Tamassia, Goldwasser
|
|
|
- używany jako opcjonalny tekst dla kursu wprowadzającego dla informatyki na UC Berkeley
|
|
|
- zobacz moją recenzję książki na temat wersji Python poniżej. Ta książka obejmuje te same tematy.
|
|
|
|
|
|
### Python
|
|
|
|
|
|
- [ ] [Data Structures and Algorithms in Python](https://www.amazon.com/Structures-Algorithms-Python-Michael-Goodrich/dp/1118290275/)
|
|
|
- od Goodrich, Tamassia, Goldwasser
|
|
|
- Uwielbiam tę książkę. Obejmowała wszystko i więcej.
|
|
|
- kod Pythona
|
|
|
- moja entuzjastyczna recenzja: https://startupnextdoor.com/book-report-data-structures-and-algorithms-in-python/
|
|
|
|
|
|
|
|
|
## Zanim zaczniesz
|
|
|
|
|
|
Ta lista rosła przez wiele miesięcy i tak, wymknęła się spod kontroli.
|
|
|
|
|
|
Oto kilka błędów, które popełniłem, rzuć okiem - dzięki temu będziesz mieć lepsze odczucia.
|
|
|
|
|
|
### 1. Nie zapamiętasz tego wszystkiego
|
|
|
|
|
|
Oglądałem godziny filmów i robiłem obszerne notatki, a miesiące później wiele nie pamiętałem. Spędziłem 3 dni
|
|
|
na moje notatki i tworzenie fiszek, abym mógł je przejrzeć.
|
|
|
|
|
|
Przeczytaj proszę, żebyś nie popełnił moich błędów:
|
|
|
|
|
|
[Utrzymanie wiedzy informatycznej](https://startupnextdoor.com/retaining-computer-science-knowledge/).
|
|
|
|
|
|
Kurs zalecany mi (jeszcze go nie zacząłem): [Naucz się, jak się uczyć](https://www.coursera.org/learn/learning-how-to-learn)
|
|
|
|
|
|
### 2. Użyj Flashcards
|
|
|
|
|
|
Aby rozwiązać problem, stworzyłem małą stronę z fiszkami (flashcards), w której mogłem dodać fiszki 2 typów: ogólne i kod.
|
|
|
Każda karta ma inne formatowanie.
|
|
|
|
|
|
Stworzyłem witrynę mobilną, aby móc przeglądać na moim telefonie i tablecie, gdziekolwiek jestem.
|
|
|
|
|
|
Stwórz własną za darmo:
|
|
|
|
|
|
- [Flashcards site repo](https://github.com/jwasham/computer-science-flash-cards)
|
|
|
- [My flash cards database (old - 1200 cards)](https://github.com/jwasham/computer-science-flash-cards/blob/main/cards-jwasham.db):
|
|
|
- [My flash cards database (new - 1800 cards)](https://github.com/jwasham/computer-science-flash-cards/blob/main/cards-jwasham-extreme.db):
|
|
|
|
|
|
Pamiętaj, że poszedłem ostro i mam karty obejmujące wszystko, od języka asemblera i ciekawostek Python po uczenie maszynowe i statystyki. To o wiele za dużo na to, w stosunku do tego co jest wymagane.
|
|
|
|
|
|
**Uwaga odnośnie fiszek:** Gdy rozpoznasz odpowiedź po raz pierwszy, nie oznaczaj jej jako znanej. Musisz zobaczyć
|
|
|
tę samą kartę i odpowiedzieć kilka razy poprawnie, zanim się nauczysz porzadnie. Powtarzanie pogłębi tę wiedzę.
|
|
|
|
|
|
Alternatywą dla korzystania z mojej strony z kartami jest [Anki](http://ankisrs.net/), która była mi polecana wiele razy. Używa systemu powtarzania, aby pomóc Ci zapamiętać.
|
|
|
Jest przyjazna dla użytkownika, dostępna na wszystkich platformach i ma system synchronizacji w chmurze. Kosztuje $25 na iOS ale jest darmowa na innych platformach.
|
|
|
|
|
|
Moja baza danych fiszekw formacie Anki: https://ankiweb.net/shared/info/25173560 (dzięki [@xiewenya](https://github.com/xiewenya))
|
|
|
|
|
|
### 3. Zacznij robić pytania programistyczne do rozmowy kwalifikacyjnej, ucząc się struktur danych i algorytmów
|
|
|
|
|
|
Musisz zastosować zdobytą wiedzę do rozwiązywania problemów, inaczej zapomnisz. Popełniłem ten błąd. Gdy nauczysz się tematu,
|
|
|
aby czuć się z tym komfortowo, np. listy powiązane - otwórz jedną z książek o rekrutacji IT i zrób kilka pytań dotyczących list powiązanych (linked lists). Następnie przejdź do następnego tematu do nauki. Potem wróć i zrób kolejne zadanie z listą powiązaną, problem z rekurencją lub cokolwiek innego. Ale rób zadania podczas nauki. Nie jesteś zatrudniony do wiedzy,
|
|
|
ale do tego jak zastosować wiedzę. Polecam kilka książek i stron.
|
|
|
Zobacz tutaj, aby uzyskać więcej informacji: [Praktyczne pytania programistyczne](#praktyczne-pytania-programistyczne)
|
|
|
|
|
|
### 4. Przeglądaj, przeglądaj, przeglądaj
|
|
|
|
|
|
Trzymam zestaw ściąg na ASCII, stos OSI, notacje Big-O i inne. Przeglądam je, kiedy mam trochę wolnego czasu.
|
|
|
|
|
|
Zrób sobie przerwę od problemów programistycznych na pół godziny i przejrzyj swoje fiszki.
|
|
|
|
|
|
### 5. Skupienie
|
|
|
|
|
|
Istnieje wiele czynników, które mogą zająć cenny czas. Skupienie i koncentracja są trudne. Włącz muzykę bez słów, a będziesz w stanie całkiem dobrze się skupić.
|
|
|
|
|
|
## Czego tutaj nie zobaczysz
|
|
|
|
|
|
Są to dominujące technologie, ale nie są częścią tego planu nauki:
|
|
|
|
|
|
- SQL
|
|
|
- Javascript
|
|
|
- HTML, CSS, oraz inne technologie frontend
|
|
|
|
|
|
## Plan dzienny
|
|
|
|
|
|
Niektóre przedmioty zajmą jeden dzień, a inne kilka dni. Niektórzy dopiero się uczą nie mając nic do zaimplementowania.
|
|
|
|
|
|
Każdego dnia biorę jeden temat z poniższej listy, oglądam filmy na ten temat i piszę implementację w:
|
|
|
- C - używając struktur i funkcji, które mają * i coś jeszcze jako args.
|
|
|
- C++ - bez używania wbudowanych typów
|
|
|
- C++ - używając wbudowanych typów, takich jak z STL np. std::list dla linked list
|
|
|
- Python - używając wbudowanych typów (aby ćwiczyć Python)
|
|
|
- i piszę testy, aby upewnić się, że robię to dobrze, czasem używając prostych instrukcji assert()
|
|
|
- Możesz tak robić z Java lub czymś innym, to po prostu moje podejście.
|
|
|
|
|
|
Nie potrzebujesz tych wszystkich. Do rozmowy potrzebny jest tylko [jeden język](#pick-one-language-for-the-interview).
|
|
|
|
|
|
Po co kodować w tych wszystkich?
|
|
|
- Ćwiczenia, ćwiczenia, ćwiczenia, dopóki nie mam tego dość, i mogę to zrobić bez problemu (niektórzy mają wiele skrajnych przypadków i szczegółów księżek do zapamiętania)
|
|
|
- Praca w ramach surowych ograniczeń (przydzielanie / zwalnianie pamięci bez pomocy odśmiecania (z wyjątkiem Pythona lub Java))
|
|
|
- Korzystam z wbudowanych typów, więc mam doświadczenie w korzystaniu z wbudowanych narzędzi do użytku w świecie rzeczywistym (nie zamierzam pisać własnej implementacji list powiązanych na produkcji)
|
|
|
|
|
|
Może nie mam czasu na zrobienie wszystkich tych rzeczy dla każdego przedmiotu, ale próbuję.
|
|
|
|
|
|
Możesz zobaczyć moje kody tutaj:
|
|
|
- [C](https://github.com/jwasham/practice-c)
|
|
|
- [C++](https://github.com/jwasham/practice-cpp)
|
|
|
- [Python](https://github.com/jwasham/practice-python)
|
|
|
|
|
|
Nie musisz zapamiętywać wnętrzności każdego algorytmu.
|
|
|
|
|
|
Napisz kod na tablicy lub papierze, a nie na komputerze. Testuj z niektórymi przykładowymi danymi wejściowymi. Następnie przetestuj na komputerze.
|
|
|
|
|
|
## Wymagana wiedza
|
|
|
|
|
|
- [ ] **Nauka języka C**
|
|
|
- C jest wszędzie. Przykłady znajdziesz w książkach, wykładach, filmach, *wszędzie* podczas nauki.
|
|
|
- [ ] [C Programming Language, Vol 2](https://www.amazon.com/Programming-Language-Brian-W-Kernighan/dp/0131103628)
|
|
|
- Jest to krótka książka, ale zapewni doskonałą znajomość języka C i jeśli trochę go przećwiczysz
|
|
|
szybko osiągniesz biegłość. Zrozumienie C pomaga zrozumieć, jak działają programy i pamięć.
|
|
|
- [odpowiedzi na pytania](https://github.com/lekkas/c-algorithms)
|
|
|
|
|
|
- [ ] **Jak komputery przetwarzają program:**
|
|
|
- [ ] [Jak procesor wykonuje program (wideo)](https://www.youtube.com/watch?v=XM4lGflQFvA)
|
|
|
- [ ] [Jak komputery liczą - ALU (wideo)](https://youtu.be/1I5ZMmrOfnA)
|
|
|
- [ ] [Rejestry i pamięć RAM (wideo)](https://youtu.be/fpnE6UAfbtU)
|
|
|
- [ ] [Central Processing Unit (CPU) - procesor (wideo)](https://youtu.be/FZGugFqdr60)
|
|
|
- [ ] [Instrukcje i programy (wideo)](https://youtu.be/zltgXvg6r3k)
|
|
|
|
|
|
## Złożoność algorytmiczna / Big-O / Analiza asymptotyczna
|
|
|
|
|
|
- Nic do implementacji
|
|
|
- Tutaj jest wiele filmów. Po prostu oglądaj wystarczająco długo, aż zrozumiesz. Zawsze możesz wrócić i przejrzeć ponownie.
|
|
|
- Jeśli niektóre wykłady są zbyt matematyczne, możesz zeskoczyć na dół i obejrzeć filmy z matematyki dyskretnej, aby uzyskać podstawową wiedzę.
|
|
|
- [ ] [Harvard CS50 - Notacja asymptotyczna (wideo)](https://www.youtube.com/watch?v=iOq5kSKqeR4)
|
|
|
- [ ] [Big O Notations (ogólny szybki samouczek) (wideo)](https://www.youtube.com/watch?v=V6mKVRU1evU)
|
|
|
- [ ] [Big O Notation (oraz Omega i Theta) - najlepsze wyjaśnienia matematyczne (wideo)](https://www.youtube.com/watch?v=ei-A_wy5Yxw&index=2&list=PL1BaGV1cIH4UhkL8a9bJGG356covJ76qN)
|
|
|
- [ ] Skiena:
|
|
|
- [wideo](https://www.youtube.com/watch?v=gSyDMtdPNpU&index=2&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b)
|
|
|
- [prezentacja](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 (wideo)](https://www.coursera.org/lecture/algorithmic-thinking-1/orders-of-growth-6PKkX)
|
|
|
- [ ] [Asymptotics (wideo)](https://www.coursera.org/lecture/algorithmic-thinking-1/asymptotics-bXAtM)
|
|
|
- [ ] [UC Berkeley Big O (wideo)](https://archive.org/details/ucberkeley_webcast_VIS4YDpuP98)
|
|
|
- [ ] [UC Berkeley Big Omega (wideo)](https://archive.org/details/ucberkeley_webcast_ca3e7UVmeUc)
|
|
|
- [ ] [Amortized Analysis (wideo)](https://www.youtube.com/watch?v=B3SpQZaAZP4&index=10&list=PL1BaGV1cIH4UhkL8a9bJGG356covJ76qN)
|
|
|
- [ ] [Illustrating "Big O" (wideo)](https://www.coursera.org/lecture/algorithmic-thinking-1/illustrating-big-o-YVqzv)
|
|
|
- [ ] TopCoder (includes recurrence relations and master theorem):
|
|
|
- [Computational Complexity: Section 1](https://www.topcoder.com/community/competitive-programming/tutorials/computational-complexity-section-1/)
|
|
|
- [Computational Complexity: Section 2](https://www.topcoder.com/community/competitive-programming/tutorials/computational-complexity-section-2/)
|
|
|
- [ ] [Ściągawka](http://bigocheatsheet.com/)
|
|
|
- [ ] [[Review] Analyzing Algorithms (playlist) in 18 minutes (video)](https://www.youtube.com/playlist?list=PL9xmBV_5YoZMxejjIyFHWa-4nKg6sdoIv)
|
|
|
|
|
|
## Struktury danych
|
|
|
|
|
|
- ### Arrays
|
|
|
- Zaimplementuj wektor automatycznie zmieniający rozmiar.
|
|
|
- [ ] Opis:
|
|
|
- [Arrays (wideo)](https://www.coursera.org/learn/data-structures/lecture/OsBSF/arrays)
|
|
|
- [UC Berkeley CS61B - Linear and Multi-Dim Arrays (wideo)](https://archive.org/details/ucberkeley_webcast_Wp8oiO_CZZE) (Start watching from 15m 32s)
|
|
|
- [Dynamic Arrays (wideo)](https://www.coursera.org/learn/data-structures/lecture/EwbnV/dynamic-arrays)
|
|
|
- [Jagged Arrays (wideo)](https://www.youtube.com/watch?v=1jtrQqYpt7g)
|
|
|
- [ ] Zaimplementuj vector (mutable array z automatycznym zmienianiem rozmiaru):
|
|
|
- [ ] 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
|
|
|
- potraf zaalokować int array pod maską, bez używania gotowych funkcji
|
|
|
- zacznij z 16, lub jeśli liczba początkowa jest większa, użyj potęgi 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
|
|
|
- po osiągnięciu pojemności zmień rozmiar, aby podwoić rozmiar
|
|
|
- podczas usuwania elementu, jeśli rozmiar wynosi 1/4 pojemności, przeskaluj do połowy
|
|
|
- [ ] Czas (złożoność czasowa)
|
|
|
- O(1) to add/remove na koniec (amortized for allocations for more space), index, or update
|
|
|
- O(n) to insert/remove elsewhere
|
|
|
- [ ] Miejsce (złożoność pamięciowa)
|
|
|
- contiguous in memory, so proximity helps performance
|
|
|
- space needed = (array capacity, which is >= n) * size of item, but even if 2n, still O(n)
|
|
|
|
|
|
- ### Listy łączone
|
|
|
- [ ] Opis:
|
|
|
- [ ] [Singly Linked Lists (wideo)](https://www.coursera.org/learn/data-structures/lecture/kHhgK/singly-linked-lists)
|
|
|
- [ ] [CS 61B - Linked Lists 1 (wideo)](https://archive.org/details/ucberkeley_webcast_htzJdKoEmO0)
|
|
|
- [ ] [CS 61B - Linked Lists 2 (wideo)](https://archive.org/details/ucberkeley_webcast_-c4I3gFYe3w)
|
|
|
- [ ] [[Review] Linked lists in 4 minutes (video)](https://youtu.be/F8AbOfQwl1c)
|
|
|
- [ ] [C Code (wideo)](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 (wideo)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/rjBs9/core-linked-lists-vs-arrays)
|
|
|
- [In The Real World Linked Lists Vs Arrays (wideo)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/QUaUd/in-the-real-world-lists-vs-arrays)
|
|
|
- [ ] [why you should avoid linked lists (video)](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.
|
|
|
- [Pointers to Pointers](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
|
|
|
- [ ] Lista podwójnie łączona
|
|
|
- [Opis (wideo)](https://www.coursera.org/learn/data-structures/lecture/jpGKD/doubly-linked-lists)
|
|
|
- Bez potrzeby implementacji
|
|
|
|
|
|
- ### Stos
|
|
|
- [ ] [Stacks (wideo)](https://www.coursera.org/learn/data-structures/lecture/UdKzQ/stacks)
|
|
|
- [ ] [[Review] Stacks in 3 minutes (video)](https://youtu.be/KcT3aVgrrpU)
|
|
|
- [ ] Will not implement. Implementing with array is trivial.
|
|
|
|
|
|
- ### Kolejka
|
|
|
- [ ] [Queue (wideo)](https://www.coursera.org/lecture/data-structures/queues-EShpq)
|
|
|
- [ ] [Circular buffer/FIFO](https://en.wikipedia.org/wiki/Circular_buffer)
|
|
|
- [ ] [[Review] Queues in 3 minutes (video)](https://youtu.be/D6gu-_tmEpQ)
|
|
|
- [ ] 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 table - tablica mieszająca
|
|
|
- [ ] Materiały wideo:
|
|
|
- [ ] [Hashing with Chaining (wideo)](https://www.youtube.com/watch?v=0M_kIqhwbFo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=8)
|
|
|
- [ ] [Table Doubling, Karp-Rabin (wideo)](https://www.youtube.com/watch?v=BRO7mVIFt08&index=9&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
|
|
|
- [ ] [Open Addressing, Cryptographic Hashing (wideo)](https://www.youtube.com/watch?v=rvdJDijO2Ro&index=10&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
|
|
|
- [ ] [PyCon 2010: The Mighty Dictionary (wideo)](https://www.youtube.com/watch?v=C4Kc8xzcA68)
|
|
|
- [ ] [(Zaawansowane) Randomization: Universal & Perfect Hashing (wideo)](https://www.youtube.com/watch?v=z0lJ2k0sl1g&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=11)
|
|
|
- [ ] [(Zaawansowane) Perfect hashing (wideo)](https://www.youtube.com/watch?v=N0COwN14gt0&list=PL2B4EEwhKD-NbwZ4ezj7gyc_3yNrojKM9&index=4)
|
|
|
- [ ] [[Review] Hash tables in 4 minutes (video)](https://youtu.be/knV86FlSXJ8)
|
|
|
|
|
|
- [ ] Kursy online:
|
|
|
- [ ] [Core Hash Tables (wideo)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/m7UuP/core-hash-tables)
|
|
|
- [ ] [Data Structures (wideo)](https://www.coursera.org/learn/data-structures/home/week/4)
|
|
|
- [ ] [Phone Book Problem (wideo)](https://www.coursera.org/learn/data-structures/lecture/NYZZP/phone-book-problem)
|
|
|
- [ ] distributed hash tables:
|
|
|
- [Instant Uploads And Storage Optimization In Dropbox (wideo)](https://www.coursera.org/learn/data-structures/lecture/DvaIb/instant-uploads-and-storage-optimization-in-dropbox)
|
|
|
- [Distributed Hash Tables (video)](https://www.coursera.org/learn/data-structures/lecture/tvH8H/distributed-hash-tables)
|
|
|
|
|
|
- [ ] 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)
|
|
|
|
|
|
## Więcej wiedzy
|
|
|
|
|
|
- ### Binary search
|
|
|
- [ ] [Binary Search (wideo)](https://www.youtube.com/watch?v=D5SrAga1pno)
|
|
|
- [ ] [Binary Search (wideo)](https://www.khanacademy.org/computing/computer-science/algorithms/binary-search/a/binary-search)
|
|
|
- [ ] [detail](https://www.topcoder.com/community/competitive-programming/tutorials/binary-search/)
|
|
|
- [ ] [[Review] Binary search in 4 minutes (video)](https://youtu.be/fDKIpRe8GW4)
|
|
|
- [ ] Implement:
|
|
|
- binary search (on sorted array of integers)
|
|
|
- binary search using recursion
|
|
|
|
|
|
- ### Operacje bitowe
|
|
|
- [ ] [Bits cheat sheet](https://github.com/jwasham/coding-interview-university/blob/main/extras/cheat%20sheets/bits-cheat-sheet.pdf) - you should know many of the powers of 2 from (2^1 to 2^16 and 2^32)
|
|
|
- [ ] Dobrze zrozum manipulowanie bitami korzystając z: &, |, ^, ~, >>, <<
|
|
|
- [ ] [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)
|
|
|
- [ ] [Bit Manipulation](https://en.wikipedia.org/wiki/Bit_manipulation)
|
|
|
- [ ] [Bitwise Operation](https://en.wikipedia.org/wiki/Bitwise_operation)
|
|
|
- [ ] [Bithacks](https://graphics.stanford.edu/~seander/bithacks.html)
|
|
|
- [ ] [The Bit Twiddler](https://bits.stephan-brumme.com/)
|
|
|
- [ ] [The Bit Twiddler Interactive](https://bits.stephan-brumme.com/interactive.html)
|
|
|
- [ ] 2s and 1s complement
|
|
|
- [Binary: Plusses & Minuses (Why We Use Two's Complement) (video)](https://www.youtube.com/watch?v=lKTsv6iVxV4)
|
|
|
- [1s Complement](https://en.wikipedia.org/wiki/Ones%27_complement)
|
|
|
- [2s Complement](https://en.wikipedia.org/wiki/Two%27s_complement)
|
|
|
- [ ] count set bits
|
|
|
- [4 ways to count bits in a byte (video)](https://youtu.be/Hzuzo9NJrlc)
|
|
|
- [Count Bits](https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan)
|
|
|
- [How To Count The Number Of Set Bits In a 32 Bit Integer](http://stackoverflow.com/questions/109023/how-to-count-the-number-of-set-bits-in-a-32-bit-integer)
|
|
|
- [ ] swap values:
|
|
|
- [Swap](https://bits.stephan-brumme.com/swap.html)
|
|
|
- [ ] absolute value:
|
|
|
- [Absolute Integer](https://bits.stephan-brumme.com/absInteger.html)
|
|
|
|
|
|
## Drzewa
|
|
|
|
|
|
- ### Drzewa - uwagi & zarys
|
|
|
- [ ] [Series: Trees (wideo)](https://www.coursera.org/learn/data-structures/lecture/95qda/trees)
|
|
|
- podstawy budowy drzewa
|
|
|
- traversal (ścieżki)
|
|
|
- manipulation algorithms
|
|
|
- [ ] [BFS(breadth-first search) and DFS(depth-first search) (wideo)](https://www.youtube.com/watch?v=uWL6FJhq5fM)
|
|
|
- BFS notes:
|
|
|
- level order (BFS, using queue)
|
|
|
- złożoność czasowa: O(n)
|
|
|
- złożoność pamięciowa: best: O(1), worst: O(n/2)=O(n)
|
|
|
- DFS notes:
|
|
|
- złożoność czasowa: O(n)
|
|
|
- złożoność pamięciowa:
|
|
|
najlepsza: O(log n) - avg. height of tree
|
|
|
najgorsza: O(n)
|
|
|
- inorder (DFS: left, self, right)
|
|
|
- postorder (DFS: left, right, self)
|
|
|
- preorder (DFS: self, left, right)
|
|
|
- [ ] [[Review] Breadth-first search in 4 minutes (video)](https://youtu.be/HZ5YTanv5QE)
|
|
|
- [ ] [[Review] Depth-first search in 4 minutes (video)](https://youtu.be/Urx87-NMm6c)
|
|
|
- [ ] [[Review] Tree Traversal (playlist) in 11 minutes (video)](https://www.youtube.com/playlist?list=PL9xmBV_5YoZO1JC2RgEi04nLy6D-rKk6b)
|
|
|
|
|
|
- ### Binary search trees: BSTs - drzewa binarne
|
|
|
- [ ] [Binary Search Tree Review (wideo)](https://www.youtube.com/watch?v=x6At0nzX92o&index=1&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
|
|
|
- [ ] [Series (wideo)](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
|
|
|
- [ ] [Wprowadzenie (wideo)](https://www.coursera.org/learn/data-structures/lecture/E7cXP/introduction)
|
|
|
- [ ] [MIT (wideo)](https://www.youtube.com/watch?v=9Jry5-82I68)
|
|
|
- C/C++:
|
|
|
- [ ] [Binary search tree - Implementation in C/C++ (wideo)](https://www.youtube.com/watch?v=COZK7NATh4k&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=28)
|
|
|
- [ ] [BST implementation - memory allocation in stack and heap (wideo)](https://www.youtube.com/watch?v=hWokyBoo0aI&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=29)
|
|
|
- [ ] [Find min and max element in a binary search tree (wideo)](https://www.youtube.com/watch?v=Ut90klNN264&index=30&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P)
|
|
|
- [ ] [Find height of a binary tree (wideo)](https://www.youtube.com/watch?v=_pnqMz5nrRs&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=31)
|
|
|
- [ ] [Binary tree traversal - breadth-first and depth-first strategies (wideo)](https://www.youtube.com/watch?v=9RHO6jU--GU&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=32)
|
|
|
- [ ] [Binary tree: Level Order Traversal (wideo)](https://www.youtube.com/watch?v=86g8jAQug04&index=33&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P)
|
|
|
- [ ] [Binary tree traversal: Preorder, Inorder, Postorder (wideo)](https://www.youtube.com/watch?v=gm8DUJJhmY4&index=34&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P)
|
|
|
- [ ] [Check if a binary tree is binary search tree or not (wideo)](https://www.youtube.com/watch?v=yEwSGhSsT0U&index=35&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P)
|
|
|
- [ ] [Delete a node from Binary Search Tree (wideo)](https://www.youtube.com/watch?v=gcULXE7ViZw&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=36)
|
|
|
- [ ] [Inorder Successor in a binary search tree (wideo)](https://www.youtube.com/watch?v=5cPbNCrdotA&index=37&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P)
|
|
|
- [ ] Implement:
|
|
|
- [ ] insert // insert value into tree
|
|
|
- [ ] get_node_count // get count of values stored
|
|
|
- [ ] print_values // prints the values in the tree, from min to max
|
|
|
- [ ] delete_tree
|
|
|
- [ ] is_in_tree // returns true if given value exists in the tree
|
|
|
- [ ] get_height // returns the height in nodes (single node's height is 1)
|
|
|
- [ ] get_min // returns the minimum value stored in the tree
|
|
|
- [ ] get_max // returns the maximum value stored in the tree
|
|
|
- [ ] is_binary_search_tree
|
|
|
- [ ] delete_value
|
|
|
- [ ] get_successor // returns next-highest value in tree after given value, -1 if none
|
|
|
|
|
|
- ### Sterta / kolejka priorytetowa / sterta binarna
|
|
|
- przedstawiane jako drzewo, ale zwykle liniowo w pamięci (array, linked list)
|
|
|
- [ ] [Sterta](https://en.wikipedia.org/wiki/Heap_(data_structure))
|
|
|
- [ ] [Wprowadzenie (wideo)](https://www.coursera.org/learn/data-structures/lecture/2OpTs/introduction)
|
|
|
- [ ] [Naive Implementations (wideo)](https://www.coursera.org/learn/data-structures/lecture/z3l9N/naive-implementations)
|
|
|
- [ ] [Binary Trees (wideo)](https://www.coursera.org/learn/data-structures/lecture/GRV2q/binary-trees)
|
|
|
- [ ] [Tree Height Remark (wideo)](https://www.coursera.org/learn/data-structures/supplement/S5xxz/tree-height-remark)
|
|
|
- [ ] [Basic Operations (wideo)](https://www.coursera.org/learn/data-structures/lecture/0g1dl/basic-operations)
|
|
|
- [ ] [Complete Binary Trees (wideo)](https://www.coursera.org/learn/data-structures/lecture/gl5Ni/complete-binary-trees)
|
|
|
- [ ] [Pseudocode (wideo)](https://www.coursera.org/learn/data-structures/lecture/HxQo9/pseudocode)
|
|
|
- [ ] [Heap Sort - jumps to start (wideo)](https://youtu.be/odNJmw5TOEE?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=3291)
|
|
|
- [ ] [Heap Sort (wideo)](https://www.coursera.org/learn/data-structures/lecture/hSzMO/heap-sort)
|
|
|
- [ ] [Building a heap (wideo)](https://www.coursera.org/learn/data-structures/lecture/dwrOS/building-a-heap)
|
|
|
- [ ] [MIT: Heaps and Heap Sort (wideo)](https://www.youtube.com/watch?v=B7hVxCmfPtM&index=4&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
|
|
|
- [ ] [CS 61B Lecture 24: Priority Queues (wideo)](https://archive.org/details/ucberkeley_webcast_yIUFT6AKBGE)
|
|
|
- [ ] [Linear Time BuildHeap (max-heap)](https://www.youtube.com/watch?v=MiyLo8adrWw)
|
|
|
- [ ] [[Review] Heap (playlist) in 13 minutes (video)](https://www.youtube.com/playlist?list=PL9xmBV_5YoZNsyqgPW-DNwUeT8F8uhWc6)
|
|
|
- [ ] Implement a max-heap:
|
|
|
- [ ] insert
|
|
|
- [ ] sift_up - needed for insert
|
|
|
- [ ] get_max - returns the max item, without removing it
|
|
|
- [ ] get_size() - return number of elements stored
|
|
|
- [ ] is_empty() - returns true if heap contains no elements
|
|
|
- [ ] extract_max - returns the max item, removing it
|
|
|
- [ ] sift_down - needed for extract_max
|
|
|
- [ ] remove(i) - removes item at index x
|
|
|
- [ ] heapify - create a heap from an array of elements, needed for heap_sort
|
|
|
- [ ] heap_sort() - take an unsorted array and turn it into a sorted array in-place using a max heap
|
|
|
- note: using a min heap instead would save operations, but double the space needed (cannot do in-place).
|
|
|
|
|
|
## Sortowanie
|
|
|
|
|
|
- [ ] Uwagi:
|
|
|
- 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?")
|
|
|
- [Sorting Algorithm Stability](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability)
|
|
|
- [Stability In Sorting Algorithms](http://stackoverflow.com/questions/1517793/stability-in-sorting-algorithms)
|
|
|
- [Stability In Sorting Algorithms](http://www.geeksforgeeks.org/stability-in-sorting-algorithms/)
|
|
|
- [Sorting Algorithms - Stability](http://homepages.math.uic.edu/~leon/cs-mcs401-s08/handouts/stability.pdf)
|
|
|
- [ ] Which algorithms can be used on linked lists? Which on arrays? Which on both?
|
|
|
- I wouldn't recommend sorting a linked list, but merge sort is doable.
|
|
|
- [Merge Sort For Linked List](http://www.geeksforgeeks.org/merge-sort-for-linked-list/)
|
|
|
|
|
|
- dla heapsort, zobacz Struktury danych - sterta, powyżej. Heapsort jest świetny, ale niestabilny.
|
|
|
|
|
|
- [ ] [Sedgewick - Mergesort (5 wideo)](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)
|
|
|
- [ ] [4. Comparators](https://www.coursera.org/learn/algorithms-part1/lecture/9FYhS/comparators)
|
|
|
- [ ] [5. Stability](https://www.coursera.org/learn/algorithms-part1/lecture/pvvLZ/stability)
|
|
|
|
|
|
- [ ] [Sedgewick - Quicksort (4 wideo)](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 Wykład 29: Sortowanie I (wideo)](https://archive.org/details/ucberkeley_webcast_EiUvYS2DT6I)
|
|
|
- [ ] [CS 61B Wykład 30: Sortowanie II (wideo)](https://archive.org/details/ucberkeley_webcast_2hTY3t80Qsk)
|
|
|
- [ ] [CS 61B Wykład 32: Sortowanie III (wideo)](https://archive.org/details/ucberkeley_webcast_Y6LOLpxg6Dc)
|
|
|
- [ ] [CS 61B Wykład 33: Sortowanie V (wideo)](https://archive.org/details/ucberkeley_webcast_qNMQ4ly43p4)
|
|
|
|
|
|
- [ ] [Sortowanie bąbelkowe (wideo)](https://www.youtube.com/watch?v=P00xJgWzz2c&index=1&list=PL89B61F78B552C1AB)
|
|
|
- [ ] [Analiza sortowania bąbelkowego (wideo)](https://www.youtube.com/watch?v=ni_zk257Nqo&index=7&list=PL89B61F78B552C1AB)
|
|
|
- [ ] [Sortowanie przez wstawianie, Sortowanie przez scalanie (wideo)](https://www.youtube.com/watch?v=Kg4bqzAqRBM&index=3&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
|
|
|
- [ ] [Sortowanie przez wstawianie (wideo)](https://www.youtube.com/watch?v=c4BRHC7kTaQ&index=2&list=PL89B61F78B552C1AB)
|
|
|
- [ ] [Sortowanie przez scalanie (wideo)](https://www.youtube.com/watch?v=GCae1WNvnZM&index=3&list=PL89B61F78B552C1AB)
|
|
|
- [ ] [Sortowanie szybkie Quicksort (wideo)](https://www.youtube.com/watch?v=y_G9BkAm6B8&index=4&list=PL89B61F78B552C1AB)
|
|
|
- [ ] [Sortowanie przez wybieranie (wideo)](https://www.youtube.com/watch?v=6nDMgr0-Yyo&index=8&list=PL89B61F78B552C1AB)
|
|
|
|
|
|
- [ ] Merge sort code:
|
|
|
- [ ] [Using output array (C)](http://www.cs.yale.edu/homes/aspnes/classes/223/examples/sorting/mergesort.c)
|
|
|
- [ ] [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)
|
|
|
|
|
|
- [ ] [[Review] Sorting (playlist) in 18 minutes](https://www.youtube.com/playlist?list=PL9xmBV_5YoZOZSbGAXAPIq1BeUf4j20pl)
|
|
|
- [ ] [Quick sort in 4 minutes (video)](https://youtu.be/Hoixgm4-P4M)
|
|
|
- [ ] [Heap sort in 4 minutes (video)](https://youtu.be/2DmK_H7IdTo)
|
|
|
- [ ] [Merge sort in 3 minutes (video)](https://youtu.be/4VqmGXwpLqc)
|
|
|
- [ ] [Bubble sort in 2 minutes (video)](https://youtu.be/xli_FI7CuzA)
|
|
|
- [ ] [Selection sort in 3 minutes (video)](https://youtu.be/g-PGLbMth_g)
|
|
|
- [ ] [Insertion sort in 2 minutes (video)](https://youtu.be/JU767SDMDvA)
|
|
|
|
|
|
- [ ] 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
|
|
|
- For heapsort, see Heap data structure above.
|
|
|
|
|
|
- [ ] Not required, but I recommended them:
|
|
|
- [ ] [Sedgewick - Radix Sorts (6 wideo)](https://www.coursera.org/learn/algorithms-part2/home/week/3)
|
|
|
- [ ] [1. Strings in Java](https://www.coursera.org/learn/algorithms-part2/lecture/vGHvb/strings-in-java)
|
|
|
- [ ] [2. Key Indexed Counting](https://www.coursera.org/learn/algorithms-part2/lecture/2pi1Z/key-indexed-counting)
|
|
|
- [ ] [3. Least Significant Digit First String Radix Sort](https://www.coursera.org/learn/algorithms-part2/lecture/c1U7L/lsd-radix-sort)
|
|
|
- [ ] [4. Most Significant Digit First String Radix Sort](https://www.coursera.org/learn/algorithms-part2/lecture/gFxwG/msd-radix-sort)
|
|
|
- [ ] [5. 3 Way Radix Quicksort](https://www.coursera.org/learn/algorithms-part2/lecture/crkd5/3-way-radix-quicksort)
|
|
|
- [ ] [6. Suffix Arrays](https://www.coursera.org/learn/algorithms-part2/lecture/TH18W/suffix-arrays)
|
|
|
- [ ] [Radix Sort](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#radixSort)
|
|
|
- [ ] [Radix Sort (wideo)](https://www.youtube.com/watch?v=xhr26ia4k38)
|
|
|
- [ ] [Radix Sort, Counting Sort (linear time given constraints) (wideo)](https://www.youtube.com/watch?v=Nz1KZXbghj8&index=7&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
|
|
|
- [ ] [Randomization: Matrix Multiply, Quicksort, Freivalds' algorithm (wideo)](https://www.youtube.com/watch?v=cNB2lADK3_s&index=8&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
|
|
|
- [ ] [Sorting in Linear Time (wideo)](https://www.youtube.com/watch?v=pOKy3RZbSws&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf&index=14)
|
|
|
|
|
|
Podsumowując, oto wizualna reprezentacja [15 algorytmów sortowania](https://www.youtube.com/watch?v=kPRA0W1kECg).
|
|
|
Jeśli potrzebujesz więcej informacji na ten temat, zobacz sekcję "Sortowanie" w [Additional Detail on Some Subjects](#additional-detail-on-some-subjects)
|
|
|
|
|
|
## Grafy
|
|
|
|
|
|
Grafy mogą być wykorzystane do przedstawienia wielu problemów w informatyce, więc ta sekcja jest długa, podobnie jak drzewa i sortowanie.
|
|
|
|
|
|
- Uwagi:
|
|
|
- Są 4 podstawowe sposoby reprezentacji grafu w pamięci:
|
|
|
- objects and pointers (obiekty i wskaźniki)
|
|
|
- adjacency matrix (macierz sąsiedztwa)
|
|
|
- adjacency list (lista sąsiedztwa)
|
|
|
- adjacency map (mapa sąsiedztwa)
|
|
|
- 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
|
|
|
- When asked a question, look for a graph-based solution first, then move on if none.
|
|
|
|
|
|
- [ ] MIT (wideo):
|
|
|
- [ ] [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)
|
|
|
|
|
|
- [ ] Wykłady Skiena - świetne wprowadzenie:
|
|
|
- [ ] [CSE373 2012 - Lecture 11 - Graph Data Structures (wideo)](https://www.youtube.com/watch?v=OiXxhDrFruw&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=11)
|
|
|
- [ ] [CSE373 2012 - Lecture 12 - Breadth-First Search (wideo)](https://www.youtube.com/watch?v=g5vF8jscteo&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=12)
|
|
|
- [ ] [CSE373 2012 - Lecture 13 - Graph Algorithms (wideo)](https://www.youtube.com/watch?v=S23W6eTcqdY&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=13)
|
|
|
- [ ] [CSE373 2012 - Lecture 14 - Graph Algorithms (con't) (wideo)](https://www.youtube.com/watch?v=WitPBKGV0HY&index=14&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b)
|
|
|
- [ ] [CSE373 2012 - Lecture 15 - Graph Algorithms (con't 2) (wideo)](https://www.youtube.com/watch?v=ia1L30l7OIg&index=15&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b)
|
|
|
- [ ] [CSE373 2012 - Lecture 16 - Graph Algorithms (con't 3) (wideo)](https://www.youtube.com/watch?v=jgDOQq6iWy8&index=16&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b)
|
|
|
|
|
|
- [ ] Grafy (review and more):
|
|
|
|
|
|
- [ ] [6.006 Single-Source Shortest Paths Problem (wideo)](https://www.youtube.com/watch?v=Aa2sqUhIn-E&index=15&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
|
|
|
- [ ] [6.006 Dijkstra (wideo)](https://www.youtube.com/watch?v=2E7MmKv0Y24&index=16&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
|
|
|
- [ ] [6.006 Bellman-Ford (wideo)](https://www.youtube.com/watch?v=ozsuci5pIso&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=17)
|
|
|
- [ ] [6.006 Speeding Up Dijkstra (wideo)](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 (wideo)]( 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 (wideo)]( https://www.youtube.com/watch?v=ufj5_bppBsA&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=7)
|
|
|
- [ ] [Aduni: Graph Algorithms III: Shortest Path - Lecture 8 (wideo)](https://www.youtube.com/watch?v=DiedsPsMKXc&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=8)
|
|
|
- [ ] [Aduni: Graph Alg. IV: Intro to geometric algorithms - Lecture 9 (wideo)](https://www.youtube.com/watch?v=XIAQRlNkJAw&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=9)
|
|
|
- [ ] ~~[CS 61B 2014 (starting at 58:09) (wideo)](https://youtu.be/dgjX4HdMI-Q?list=PL-XXv-cvA_iAlnI-BQr9hjqADPBtujFJd&t=3489)~~
|
|
|
- [ ] [CS 61B 2014: Weighted graphs (wideo)](https://archive.org/details/ucberkeley_webcast_zFbq8vOZ_0k)
|
|
|
- [ ] [Greedy Algorithms: Minimum Spanning Tree (wideo)](https://www.youtube.com/watch?v=tKwnms5iRBU&index=16&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
|
|
|
- [ ] [Strongly Connected Components Kosaraju's Algorithm Graph Algorithm (wideo)](https://www.youtube.com/watch?v=RpgcYiky7uw)
|
|
|
- [ ] [[Review] Shortest Path Algorithms (playlist) in 16 minutes (video)](https://www.youtube.com/playlist?list=PL9xmBV_5YoZO-Y-H3xIC9DGSfVYJng9Yw)
|
|
|
- [ ] [[Review] Minimum Spanning Trees (playlist) in 4 minutes (video)](https://www.youtube.com/playlist?list=PL9xmBV_5YoZObEi3Hf6lmyW-CBfs7nkOV)
|
|
|
|
|
|
- Pełny kurs Coursera:
|
|
|
- [ ] [Algorithms on Graphs (wideo)](https://www.coursera.org/learn/algorithms-on-graphs/home/welcome)
|
|
|
|
|
|
- I'll implement:
|
|
|
- [ ] DFS with adjacency list (recursive)
|
|
|
- [ ] DFS with adjacency list (iterative with stack)
|
|
|
- [ ] DFS with adjacency matrix (recursive)
|
|
|
- [ ] DFS with adjacency matrix (iterative with stack)
|
|
|
- [ ] BFS with adjacency list
|
|
|
- [ ] BFS with adjacency matrix
|
|
|
- [ ] single-source shortest path (Dijkstra)
|
|
|
- [ ] minimum spanning tree
|
|
|
- DFS-based algorithms (see Aduni videos above):
|
|
|
- [ ] check for cycle (needed for topological sort, since we'll check for cycle before starting)
|
|
|
- [ ] topological sort
|
|
|
- [ ] count connected components in a graph
|
|
|
- [ ] list strongly connected components
|
|
|
- [ ] check for bipartite graph
|
|
|
|
|
|
## Znów więcej wiedzy
|
|
|
|
|
|
- ### Rekursja
|
|
|
- [ ] Stanford lectures on recursion & backtracking:
|
|
|
- [ ] [Wykład 8 | Programming Abstractions (wideo)](https://www.youtube.com/watch?v=gl3emqCuueQ&list=PLFE6E58F856038C69&index=8)
|
|
|
- [ ] [Wykład 9 | Programming Abstractions (wideo)](https://www.youtube.com/watch?v=uFJhEPrbycQ&list=PLFE6E58F856038C69&index=9)
|
|
|
- [ ] [Wykład 10 | Programming Abstractions (wideo)](https://www.youtube.com/watch?v=NdF1QDTRkck&index=10&list=PLFE6E58F856038C69)
|
|
|
- [ ] [Wykład 11 | Programming Abstractions (wideo)](https://www.youtube.com/watch?v=p-gpaIGRCQI&list=PLFE6E58F856038C69&index=11)
|
|
|
- when it is appropriate to use it
|
|
|
- how is tail recursion better than not?
|
|
|
- [ ] [What Is Tail Recursion Why Is It So Bad?](https://www.quora.com/What-is-tail-recursion-Why-is-it-so-bad)
|
|
|
- [ ] [Tail Recursion (wideo)](https://www.coursera.org/lecture/programming-languages/tail-recursion-YZic1)
|
|
|
|
|
|
- ### Programowanie dynamiczne
|
|
|
- Prawdopodobnie nie będziesz mieć programowania dynamicznego podczas swojej rekrutacji, ale warto umieć rozpoznawać problem, jako kandydata na ten właśnie rodzaj.
|
|
|
- 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.
|
|
|
- [ ] Videos:
|
|
|
- the Skiena videos can be hard to follow since he sometimes uses the whiteboard, which is too small to see
|
|
|
- [ ] [Skiena: CSE373 2012 - Wykład 19 - Introduction to Dynamic Programming (video)](https://youtu.be/Qc2ieXRgR0k?list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&t=1718)
|
|
|
- [ ] [Skiena: CSE373 2012 - Wykład 20 - Edit Distance (video)](https://youtu.be/IsmMhMdyeGY?list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&t=2749)
|
|
|
- [ ] [Skiena: CSE373 2012 - Wykład 21 - Dynamic Programming Examples (wideo)](https://youtu.be/o0V9eYF4UI8?list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&t=406)
|
|
|
- [ ] [Skiena: CSE373 2012 - Wykład 22 - Applications of Dynamic Programming (wideo)](https://www.youtube.com/watch?v=dRbMC1Ltl3A&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=22)
|
|
|
- [ ] [Simonson: Dynamic Programming 0 (starts at 59:18) (wideo)](https://youtu.be/J5aJEcOr6Eo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=3558)
|
|
|
- [ ] [Simonson: Dynamic Programming I - Wykład 11 (wideo)](https://www.youtube.com/watch?v=0EzHjQ_SOeU&index=11&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
|
|
|
- [ ] [Simonson: Dynamic programming II - Wykład 12 (wideo)](https://www.youtube.com/watch?v=v1qiRwuJU7g&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=12)
|
|
|
- [ ] List of individual DP problems (each is short):
|
|
|
[Dynamic Programming (wideo)](https://www.youtube.com/playlist?list=PLrmLmBdmIlpsHaNTPP_jHHDx_os9ItYXr)
|
|
|
- [ ] Yale Lecture notes:
|
|
|
- [ ] [Dynamic Programming](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#dynamicProgramming)
|
|
|
- [ ] Coursera:
|
|
|
- [ ] [The RNA secondary structure problem (wideo)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/80RrW/the-rna-secondary-structure-problem)
|
|
|
- [ ] [A dynamic programming algorithm (wideo)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/PSonq/a-dynamic-programming-algorithm)
|
|
|
- [ ] [Illustrating the DP algorithm (wideo)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/oUEK2/illustrating-the-dp-algorithm)
|
|
|
- [ ] [Running time of the DP algorithm (wideo)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/nfK2r/running-time-of-the-dp-algorithm)
|
|
|
- [ ] [DP vs. recursive implementation (wideo)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/M999a/dp-vs-recursive-implementation)
|
|
|
- [ ] [Global pairwise sequence alignment (wideo)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/UZ7o6/global-pairwise-sequence-alignment)
|
|
|
- [ ] [Local pairwise sequence alignment (wideo)](https://www.coursera.org/learn/algorithmic-thinking-2/lecture/WnNau/local-pairwise-sequence-alignment)
|
|
|
|
|
|
- ### Object-Oriented Programming - programowanie obiektowe
|
|
|
- [ ] [Optional: UML 2.0 Series (wideo)](https://www.youtube.com/watch?v=OkC7HKtiZC0&list=PLGLfVvz_LVvQ5G-LdJ8RLqe-ndo7QITYc)
|
|
|
- [ ] SOLID OOP Principles: [SOLID Principles (wideo)](https://www.youtube.com/playlist?list=PL4CE9F710017EA77A)
|
|
|
|
|
|
- ### Wzorce projektowe
|
|
|
- [ ] [Quick UML review (wideo)](https://www.youtube.com/watch?v=3cmzqZzwNDM&list=PLGLfVvz_LVvQ5G-LdJ8RLqe-ndo7QITYc&index=3)
|
|
|
- [ ] Naucz się tych wzorców:
|
|
|
- [ ] strategy (strategia)
|
|
|
- [ ] singleton
|
|
|
- [ ] adapter
|
|
|
- [ ] prototype (prototyp)
|
|
|
- [ ] decorator (dekorator)
|
|
|
- [ ] visitor (odwiedzający)
|
|
|
- [ ] factory, abstract factory (fabryka, fabryka abstrakcyjna)
|
|
|
- [ ] facade (fasada)
|
|
|
- [ ] observer (obserwator)
|
|
|
- [ ] proxy (pełnomocnik)
|
|
|
- [ ] delegate (delegat)
|
|
|
- [ ] command (polecenie)
|
|
|
- [ ] state (stan)
|
|
|
- [ ] memento (pamiątka)
|
|
|
- [ ] iterator
|
|
|
- [ ] composite (kompozyt)
|
|
|
- [ ] flyweight (pyłek)
|
|
|
- [ ] [Rozdział 6 (Część 1) - Patterns (wideo)](https://youtu.be/LAP2A80Ajrg?list=PLJ9pm_Rc9HesnkwKlal_buSIHA-jTZMpO&t=3344)
|
|
|
- [ ] [Rozdział 6 (Część 2) - Abstraction-Occurrence, General Hierarchy, Player-Role, Singleton, Observer, Delegation (wideo)](https://www.youtube.com/watch?v=U8-PGsjvZc4&index=12&list=PLJ9pm_Rc9HesnkwKlal_buSIHA-jTZMpO)
|
|
|
- [ ] [Rozdział 6 (Część 3) - Adapter, Facade, Immutable, Read-Only Interface, Proxy (wideo)](https://www.youtube.com/watch?v=7sduBHuex4c&index=13&list=PLJ9pm_Rc9HesnkwKlal_buSIHA-jTZMpO)
|
|
|
- [ ] [Series of videos (27 wideo)](https://www.youtube.com/playlist?list=PLF206E906175C7E07)
|
|
|
- [ ] [Head First Design Patterns](https://www.amazon.com/Head-First-Design-Patterns-Freeman/dp/0596007124)
|
|
|
- I know the canonical book is "Design Patterns: Elements of Reusable Object-Oriented Software", but Head First is great for beginners to OO.
|
|
|
- [ ] [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)
|
|
|
|
|
|
|
|
|
- ### Kombinatoryka (n choose k) & probabilistyka
|
|
|
- [ ] [Math Skills: How to find Factorial, Permutation and Combination (Choose) (wideo)](https://www.youtube.com/watch?v=8RRo6Ti9d0U)
|
|
|
- [ ] [Make School: Probability (wideo)](https://www.youtube.com/watch?v=sZkAAk9Wwa4)
|
|
|
- [ ] [Make School: More Probability and Markov Chains (wideo)](https://www.youtube.com/watch?v=dNaJg-mLobQ)
|
|
|
- [ ] Khan Academy:
|
|
|
- Course layout:
|
|
|
- [ ] [Basic Theoretical Probability](https://www.khanacademy.org/math/probability/probability-and-combinatorics-topic)
|
|
|
- Just the videos - 41 (each are simple and each are short):
|
|
|
- [ ] [Probability Explained (wideo)](https://www.youtube.com/watch?v=uzkc-qNVoOk&list=PLC58778F28211FA19)
|
|
|
|
|
|
- ### 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.
|
|
|
- [ ] [Computational Complexity (wideo)](https://www.youtube.com/watch?v=moPtwq_cVH8&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=23)
|
|
|
- [ ] Simonson:
|
|
|
- [ ] [Greedy Algs. II & Intro to NP Completeness (wideo)](https://youtu.be/qcGnJ47Smlo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=2939)
|
|
|
- [ ] [NP Completeness II & Reductions (wideo)](https://www.youtube.com/watch?v=e0tGC6ZQdQE&index=16&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
|
|
|
- [ ] [NP Completeness III (wideo)](https://www.youtube.com/watch?v=fCX1BGT3wjE&index=17&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
|
|
|
- [ ] [NP Completeness IV (wideo)](https://www.youtube.com/watch?v=NKLDp3Rch3M&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=18)
|
|
|
- [ ] Skiena:
|
|
|
- [ ] [CSE373 2012 - Wykład 23 - Introduction to NP-Completeness (wideo)](https://youtu.be/KiK5TVgXbFg?list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&t=1508)
|
|
|
- [ ] [CSE373 2012 - Wykład 24 - NP-Completeness Proofs (wideo)](https://www.youtube.com/watch?v=27Al52X3hd4&index=24&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b)
|
|
|
- [ ] [CSE373 2012 - Wykład 25 - NP-Completeness Challenge (wideo)](https://www.youtube.com/watch?v=xCPH4gwIIXM&index=25&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b)
|
|
|
- [ ] [Complexity: P, NP, NP-completeness, Reductions (wideo)](https://www.youtube.com/watch?v=eHZifpgyH_4&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=22)
|
|
|
- [ ] [Complexity: Approximation Algorithms (wideo)](https://www.youtube.com/watch?v=MEz1J9wY2iM&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=24)
|
|
|
- [ ] [Complexity: Fixed-Parameter Algorithms (wideo)](https://www.youtube.com/watch?v=4q-jmGrmxKs&index=25&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
|
|
|
- Peter Norvig discusses near-optimal solutions to traveling salesman problem:
|
|
|
- [Jupyter Notebook](http://nbviewer.jupyter.org/url/norvig.com/ipython/TSP.ipynb)
|
|
|
- Pages 1048 - 1140 in CLRS if you have it.
|
|
|
|
|
|
- ### Caches
|
|
|
- [ ] LRU cache:
|
|
|
- [ ] [The Magic of LRU Cache (100 Days of Google Dev) (wideo)](https://www.youtube.com/watch?v=R5ON3iwx78M)
|
|
|
- [ ] [Implementing LRU (wideo)](https://www.youtube.com/watch?v=bq6N7Ym81iI)
|
|
|
- [ ] [LeetCode - 146 LRU Cache (C++) (wideo)](https://www.youtube.com/watch?v=8-FZRAjR7qU)
|
|
|
- [ ] CPU cache:
|
|
|
- [ ] [MIT 6.004 L15: The Memory Hierarchy (wideo)](https://www.youtube.com/watch?v=vjYF_fAZI5E&list=PLrRW1w6CGAcXbMtDFj205vALOGmiRc82-&index=24)
|
|
|
- [ ] [MIT 6.004 L16: Cache Issues (wideo)](https://www.youtube.com/watch?v=ajgC3-pyGlk&index=25&list=PLrRW1w6CGAcXbMtDFj205vALOGmiRc82-)
|
|
|
|
|
|
- ### Procesy i wątki
|
|
|
- [ ] Computer Science 162 - Operating Systems (25 wideo):
|
|
|
- dla procesów i wątków zobacz wideo 1-11
|
|
|
- [Operating Systems and System Programming (wideo)](https://archive.org/details/ucberkeley-webcast-PL-XXv-cvA_iBDyz-ba4yDskqMDY6A1w_c)
|
|
|
- [What Is The Difference Between A Process And A Thread?](https://www.quora.com/What-is-the-difference-between-a-process-and-a-thread)
|
|
|
- Pokrywa:
|
|
|
- Procesy, wątki, problemy z współbieżnością
|
|
|
- różnica między procesami a wątkami
|
|
|
- procesy
|
|
|
- wątki
|
|
|
- locks (zamki)
|
|
|
- mutexes (muteksy)
|
|
|
- semaphores (semafory)
|
|
|
- monitors (monitory)
|
|
|
- jak działają
|
|
|
- deadlock (zakleszczenie)
|
|
|
- livelock (specjalny przypadek zagłodzenia)
|
|
|
- CPU activity, interrupts, context switching
|
|
|
- Modern concurrency constructs with multicore processors
|
|
|
- [Paging, segmentation and virtual memory (wideo)](https://www.youtube.com/watch?v=LKe7xK0bF7o&list=PLCiOXwirraUCBE9i_ukL8_Kfg6XNv7Se8&index=2)
|
|
|
- [Przerwania (wideo)](https://www.youtube.com/watch?v=uFKi2-J-6II&list=PLCiOXwirraUCBE9i_ukL8_Kfg6XNv7Se8&index=3)
|
|
|
- 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.
|
|
|
- Context switching
|
|
|
- How context switching is initiated by the operating system and underlying hardware
|
|
|
- [ ] [threads in C++ (series - 10 wideo)](https://www.youtube.com/playlist?list=PL5jc9xFGsL8E12so1wlMS0r0hTQoJL74M)
|
|
|
- [ ] współbieżność w Python (wideo):
|
|
|
- [ ] [Short series on threads](https://www.youtube.com/playlist?list=PL1H1sBF1VAKVMONJWJkmUh6_p8g4F2oy1)
|
|
|
- [ ] [Python Threads](https://www.youtube.com/watch?v=Bs7vPNbB9JM)
|
|
|
- [ ] [Understanding the Python GIL (2010)](https://www.youtube.com/watch?v=Obt-vMVdM8s)
|
|
|
- [reference](http://www.dabeaz.com/GIL)
|
|
|
- [ ] [David Beazley - Python Concurrency From the Ground Up: LIVE! - PyCon 2015](https://www.youtube.com/watch?v=MCs5OvhV9S4)
|
|
|
- [ ] [Keynote David Beazley - Topics of Interest (Python Asyncio)](https://www.youtube.com/watch?v=ZzfHjytDceU)
|
|
|
- [ ] [Muteks w Python](https://www.youtube.com/watch?v=0zaPs8OtyKY)
|
|
|
|
|
|
- ### Testowanie
|
|
|
- Aby pokryć:
|
|
|
- jak działają testy jednostkowe (unit tests)
|
|
|
- czym są mock objects (mockowanie)
|
|
|
- co to testy integracyjne
|
|
|
- czym jest dependency injection (wstrzykiwanie zależności)
|
|
|
- [ ] [Agile Software Testing with James Bach (wideo)](https://www.youtube.com/watch?v=SAhJf36_u5U)
|
|
|
- [ ] [Open Lecture by James Bach on Software Testing (wideo)](https://www.youtube.com/watch?v=ILkT_HV9DVU)
|
|
|
- [ ] [Steve Freeman - Test-Driven Development (that’s not what we meant) (wideo)](https://vimeo.com/83960706)
|
|
|
- [prezentacja](http://gotocon.com/dl/goto-berlin-2013/slides/SteveFreeman_TestDrivenDevelopmentThatsNotWhatWeMeant.pdf)
|
|
|
- [ ] Dependency injection:
|
|
|
- [ ] [wideo](https://www.youtube.com/watch?v=IKD2-MAkXyQ)
|
|
|
- [ ] [Tao Of Testing](http://jasonpolites.github.io/tao-of-testing/ch3-1.1.html)
|
|
|
- [ ] [Jak pisać testy](http://jasonpolites.github.io/tao-of-testing/ch4-1.1.html)
|
|
|
|
|
|
- ### Scheduling
|
|
|
- in an OS, how it works
|
|
|
- can be gleaned from Operating System videos
|
|
|
|
|
|
- ### String searching & manipulations
|
|
|
- [ ] [Sedgewick - Suffix Arrays (wideo)](https://www.coursera.org/learn/algorithms-part2/lecture/TH18W/suffix-arrays)
|
|
|
- [ ] [Sedgewick - Substring Search (wideo)](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)
|
|
|
- [ ] [2. Brute-Force Substring Search](https://www.coursera.org/learn/algorithms-part2/lecture/2Kn5i/brute-force-substring-search)
|
|
|
- [ ] [3. Knuth-Morris Pratt](https://www.coursera.org/learn/algorithms-part2/lecture/TAtDr/knuth-morris-pratt)
|
|
|
- [ ] [4. Boyer-Moore](https://www.coursera.org/learn/algorithms-part2/lecture/CYxOT/boyer-moore)
|
|
|
- [ ] [5. Rabin-Karp](https://www.coursera.org/learn/algorithms-part2/lecture/3KiqT/rabin-karp)
|
|
|
- [ ] [Search pattern in text (wideo)](https://www.coursera.org/learn/data-structures/lecture/tAfHI/search-pattern-in-text)
|
|
|
|
|
|
If you need more detail on this subject, see "String Matching" section in [Additional Detail on Some Subjects](#additional-detail-on-some-subjects)
|
|
|
|
|
|
- ### Tries
|
|
|
|
|
|
Trie to drzewo węzłów, które obsługuje operacje Znajdź i Wstaw [etc (...)](https://pl.wikipedia.org/wiki/Drzewo_trie)
|
|
|
|
|
|
- Uwaga: istnieją różne rodzaje drzew tries. Niektóre mają prefixy, niektóre nie, a niektóre używają stringów zamiast bitów
|
|
|
do śledzenia ścieżki.
|
|
|
- Czytam kod, ale go nie implementuję.
|
|
|
- [ ] [Sedgewick - Tries (3 videos)](https://www.coursera.org/learn/algorithms-part2/home/week/4)
|
|
|
- [ ] [1. R Way Tries](https://www.coursera.org/learn/algorithms-part2/lecture/CPVdr/r-way-tries)
|
|
|
- [ ] [2. Ternary Search Tries](https://www.coursera.org/learn/algorithms-part2/lecture/yQM8K/ternary-search-tries)
|
|
|
- [ ] [3. Character Based Operations](https://www.coursera.org/learn/algorithms-part2/lecture/jwNmV/character-based-operations)
|
|
|
- [ ] [Notes on Data Structures and Programming Techniques](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#Tries)
|
|
|
- [ ] Short course videos:
|
|
|
- [ ] [Introduction To Tries (wideo)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/08Xyf/core-introduction-to-tries)
|
|
|
- [ ] [Performance Of Tries (wideo)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/PvlZW/core-performance-of-tries)
|
|
|
- [ ] [Implementing A Trie (wideo)](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/DFvd3/core-implementing-a-trie)
|
|
|
- [ ] [The Trie: A Neglected Data Structure](https://www.toptal.com/java/the-trie-a-neglected-data-structure)
|
|
|
- [ ] [TopCoder - Using Tries](https://www.topcoder.com/community/competitive-programming/tutorials/using-tries/)
|
|
|
- [ ] [Stanford Lecture (real world use case) (wideo)](https://www.youtube.com/watch?v=TJ8SkcUSdbU)
|
|
|
- [ ] [MIT, Advanced Data Structures, Strings (can get pretty obscure about halfway through) (wideo)](https://www.youtube.com/watch?v=NinWEPPrkDQ&index=16&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf)
|
|
|
|
|
|
- ### 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)
|
|
|
- [ ] [What Every Programmer Absolutely, Positively Needs To Know About Encodings And Character Sets To Work With Text](http://kunststube.net/encoding/)
|
|
|
|
|
|
- ### 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)
|
|
|
- Bardzo techniczna rozmowa dla programistów jądra. Nie martw się, jeśli większość jest zbyt ciężka.
|
|
|
- Pierwsza połowa wystarczy.
|
|
|
|
|
|
- ### Sieci komputerowe
|
|
|
- **jeśli masz doświadczenie w pracy w sieci etc, oczekuj podobnych pytań**
|
|
|
- tak czy inaczej, dobrze to znać
|
|
|
- [ ] [Khan Academy](https://www.khanacademy.org/computing/computer-science/internet-intro)
|
|
|
- [ ] [UDP oraz TCP: Porównanie protokołów warstwy transportowej (wideo)](https://www.youtube.com/watch?v=Vdc8TCESIg8)
|
|
|
- [ ] [TCP/IP and the OSI Model Explained! (wideo)](https://www.youtube.com/watch?v=e5DEVa9eSN0)
|
|
|
- [ ] [Packet Transmission across the Internet. Networking & TCP/IP tutorial. (wideo)](https://www.youtube.com/watch?v=nomyRJehhnM)
|
|
|
- [ ] [HTTP (wideo)](https://www.youtube.com/watch?v=WGJrLqtX7As)
|
|
|
- [ ] [SSL oraz HTTPS (wideo)](https://www.youtube.com/watch?v=S2iBR2ZlZf0)
|
|
|
- [ ] [SSL/TLS (wideo)](https://www.youtube.com/watch?v=Rp3iZUvXWlM)
|
|
|
- [ ] [HTTP 2.0 (wideo)](https://www.youtube.com/watch?v=E9FxNzv1Tr8)
|
|
|
- [ ] [Serie wideo (21 wideo) (wideo)](https://www.youtube.com/playlist?list=PLEbnTDJUr_IegfoqO4iPnPYQui46QqT0j)
|
|
|
- [ ] [Subnetting Demystified - Part 5 CIDR Notation (video)](https://www.youtube.com/watch?v=t5xYI0jzOf4)
|
|
|
- [ ] Sockets:
|
|
|
- [ ] [Java - Sockets - Wprowadzenie (wideo)](https://www.youtube.com/watch?v=6G_W54zuadg&t=6s)
|
|
|
- [ ] [Socket Programming (wideo)](https://www.youtube.com/watch?v=G75vN2mnJeQ)
|
|
|
|
|
|
## Projektowanie systemu, skalowalność, przetwarzanie danych
|
|
|
|
|
|
**Jeśli masz ponad 4-letnie doświadczenie, możesz spodziewać się pytań dotyczących projektowania systemu.**
|
|
|
|
|
|
- Skalowalność i projektowanie systemu to bardzo duże tematy z wieloma innymi tematami i materiałami,
|
|
|
przy projektowaniu systemu oprogramowania/sprzętu, który można skalować, należy wziąć pod uwagę wiele kwestii.
|
|
|
Spodziewaj się, że poświęcisz temu sporo czasu.
|
|
|
- Przemyślenia:
|
|
|
- skalowalność
|
|
|
- Wyodrębnij duże zestawy danych do pojedynczych wartości
|
|
|
- Przekształć jeden zestaw danych w inny
|
|
|
- Obsługa nieprzyzwoicie dużych ilości danych
|
|
|
- projektowanie systemu
|
|
|
- zestawy funkcji
|
|
|
- interfejsy
|
|
|
- hierarchie klas
|
|
|
- projektowanie systemu z pewnymi ograniczeniami
|
|
|
- prostota i solidność
|
|
|
- kompromisy
|
|
|
- analiza wydajności i optymalizacja
|
|
|
- [ ] **ZACZNIJ TUTAJ**: [The System Design Primer](https://github.com/donnemartin/system-design-primer)
|
|
|
- [ ] [System Design from HiredInTech](http://www.hiredintech.com/system-design/)
|
|
|
- [ ] [How Do I Prepare To Answer Design Questions In A Technical Inverview?](https://www.quora.com/How-do-I-prepare-to-answer-design-questions-in-a-technical-interview?redirected_qid=1500023)
|
|
|
- [ ] [8 Things You Need to Know Before a System Design Interview](http://blog.gainlo.co/index.php/2015/10/22/8-things-you-need-to-know-before-system-design-interviews/)
|
|
|
- [ ] [Algorithm design](http://www.hiredintech.com/algorithm-design/)
|
|
|
- [ ] [Database Normalization - 1NF, 2NF, 3NF and 4NF (video)](https://www.youtube.com/watch?v=UrYLYV7WSHM)
|
|
|
- [ ] [System Design Interview](https://github.com/checkcheckzz/system-design-interview) - There are a lot of resources in this one. Look through the articles and examples. I put some of them below.
|
|
|
- [ ] [How to ace a systems design interview](http://www.palantir.com/2011/10/how-to-rock-a-systems-design-interview/)
|
|
|
- [ ] [Numbers Everyone Should Know](http://everythingisdata.wordpress.com/2009/10/17/numbers-everyone-should-know/)
|
|
|
- [ ] [How long does it take to make a context switch?](http://blog.tsunanet.net/2010/11/how-long-does-it-take-to-make-context.html)
|
|
|
- [ ] [Transactions Across Datacenters (video)](https://www.youtube.com/watch?v=srOgpXECblk)
|
|
|
- [ ] [A plain English introduction to CAP Theorem](http://ksat.me/a-plain-english-introduction-to-cap-theorem/)
|
|
|
- [ ] Consensus Algorithms:
|
|
|
- [ ] Paxos - [Paxos Agreement - Computerphile (video)](https://www.youtube.com/watch?v=s8JqcZtvnsM)
|
|
|
- [ ] Raft - [An Introduction to the Raft Distributed Consensus Algorithm (video)](https://www.youtube.com/watch?v=P9Ydif5_qvE)
|
|
|
- [ ] [Easy-to-read paper](https://raft.github.io/)
|
|
|
- [ ] [Infographic](http://thesecretlivesofdata.com/raft/)
|
|
|
- [ ] [Consistent Hashing](http://www.tom-e-white.com/2007/11/consistent-hashing.html)
|
|
|
- [ ] [NoSQL Patterns](http://horicky.blogspot.com/2009/11/nosql-patterns.html)
|
|
|
- [ ] Skalowalność:
|
|
|
- You don't need all of these. Just pick a few that interest you.
|
|
|
- [ ] [Great overview (wideo)](https://www.youtube.com/watch?v=-W9F__D3oY4)
|
|
|
- [ ] Short series:
|
|
|
- [Clones](http://www.lecloud.net/post/7295452622/scalability-for-dummies-part-1-clones)
|
|
|
- [Database](http://www.lecloud.net/post/7994751381/scalability-for-dummies-part-2-database)
|
|
|
- [Cache](http://www.lecloud.net/post/9246290032/scalability-for-dummies-part-3-cache)
|
|
|
- [Asynchronism](http://www.lecloud.net/post/9699762917/scalability-for-dummies-part-4-asynchronism)
|
|
|
- [ ] [Scalable Web Architecture and Distributed Systems](http://www.aosabook.org/en/distsys.html)
|
|
|
- [ ] [Fallacies of Distributed Computing Explained](https://pages.cs.wisc.edu/~zuyu/files/fallacies.pdf)
|
|
|
- [ ] [Pragmatic Programming Techniques](http://horicky.blogspot.com/2010/10/scalable-system-design-patterns.html)
|
|
|
- [extra: Google Pregel Graph Processing](http://horicky.blogspot.com/2010/07/google-pregel-graph-processing.html)
|
|
|
- [ ] [Jeff Dean - Building Software Systems At Google and Lessons Learned (video)](https://www.youtube.com/watch?v=modXC5IWTJI)
|
|
|
- [ ] [Introduction to Architecting Systems for Scale](http://lethain.com/introduction-to-architecting-systems-for-scale/)
|
|
|
- [ ] [Scaling mobile games to a global audience using App Engine and Cloud Datastore (video)](https://www.youtube.com/watch?v=9nWyWwY2Onc)
|
|
|
- [ ] [How Google Does Planet-Scale Engineering for Planet-Scale Infra (video)](https://www.youtube.com/watch?v=H4vMcD7zKM0)
|
|
|
- [ ] [The Importance of Algorithms](https://www.topcoder.com/community/competitive-programming/tutorials/the-importance-of-algorithms/)
|
|
|
- [ ] [Sharding](http://highscalability.com/blog/2009/8/6/an-unorthodox-approach-to-database-design-the-coming-of-the.html)
|
|
|
- [ ] [Scale at Facebook (2012), "Building for a Billion Users" (video)](https://www.youtube.com/watch?v=oodS71YtkGU)
|
|
|
- [ ] [Engineering for the Long Game - Astrid Atkinson Keynote(video)](https://www.youtube.com/watch?v=p0jGmgIrf_M&list=PLRXxvay_m8gqVlExPC5DG3TGWJTaBgqSA&index=4)
|
|
|
- [ ] [7 Years Of YouTube Scalability Lessons In 30 Minutes](http://highscalability.com/blog/2012/3/26/7-years-of-youtube-scalability-lessons-in-30-minutes.html)
|
|
|
- [video](https://www.youtube.com/watch?v=G-lGCC4KKok)
|
|
|
- [ ] [How PayPal Scaled To Billions Of Transactions Daily Using Just 8VMs](http://highscalability.com/blog/2016/8/15/how-paypal-scaled-to-billions-of-transactions-daily-using-ju.html)
|
|
|
- [ ] [How to Remove Duplicates in Large Datasets](https://blog.clevertap.com/how-to-remove-duplicates-in-large-datasets/)
|
|
|
- [ ] [A look inside Etsy's scale and engineering culture with Jon Cowie (video)](https://www.youtube.com/watch?v=3vV4YiqKm1o)
|
|
|
- [ ] [What Led Amazon to its Own Microservices Architecture](http://thenewstack.io/led-amazon-microservices-architecture/)
|
|
|
- [ ] [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)
|
|
|
- [ ] [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)
|
|
|
- [ ] [A Patreon Architecture Short](http://highscalability.com/blog/2016/2/1/a-patreon-architecture-short.html)
|
|
|
- [ ] [Tinder: How Does One Of The Largest Recommendation Engines Decide Who You'll See Next?](http://highscalability.com/blog/2016/1/27/tinder-how-does-one-of-the-largest-recommendation-engines-de.html)
|
|
|
- [ ] [Design Of A Modern Cache](http://highscalability.com/blog/2016/1/25/design-of-a-modern-cache.html)
|
|
|
- [ ] [Live Video Streaming At Facebook Scale](http://highscalability.com/blog/2016/1/13/live-video-streaming-at-facebook-scale.html)
|
|
|
- [ ] [A Beginner's Guide To Scaling To 11 Million+ Users On Amazon's AWS](http://highscalability.com/blog/2016/1/11/a-beginners-guide-to-scaling-to-11-million-users-on-amazons.html)
|
|
|
- [ ] [How Does The Use Of Docker Effect Latency?](http://highscalability.com/blog/2015/12/16/how-does-the-use-of-docker-effect-latency.html)
|
|
|
- [ ] [A 360 Degree View Of The Entire Netflix Stack](http://highscalability.com/blog/2015/11/9/a-360-degree-view-of-the-entire-netflix-stack.html)
|
|
|
- [ ] [Latency Is Everywhere And It Costs You Sales - How To Crush It](http://highscalability.com/latency-everywhere-and-it-costs-you-sales-how-crush-it)
|
|
|
- [ ] [Serverless (very long, just need the gist)](http://martinfowler.com/articles/serverless.html)
|
|
|
- [ ] [What Powers Instagram: Hundreds of Instances, Dozens of Technologies](http://instagram-engineering.tumblr.com/post/13649370142/what-powers-instagram-hundreds-of-instances)
|
|
|
- [ ] [Cinchcast Architecture - Producing 1,500 Hours Of Audio Every Day](http://highscalability.com/blog/2012/7/16/cinchcast-architecture-producing-1500-hours-of-audio-every-d.html)
|
|
|
- [ ] [Justin.Tv's Live Video Broadcasting Architecture](http://highscalability.com/blog/2010/3/16/justintvs-live-video-broadcasting-architecture.html)
|
|
|
- [ ] [Playfish's Social Gaming Architecture - 50 Million Monthly Users And Growing](http://highscalability.com/blog/2010/9/21/playfishs-social-gaming-architecture-50-million-monthly-user.html)
|
|
|
- [ ] [TripAdvisor Architecture - 40M Visitors, 200M Dynamic Page Views, 30TB Data](http://highscalability.com/blog/2011/6/27/tripadvisor-architecture-40m-visitors-200m-dynamic-page-view.html)
|
|
|
- [ ] [PlentyOfFish Architecture](http://highscalability.com/plentyoffish-architecture)
|
|
|
- [ ] [Salesforce Architecture - How They Handle 1.3 Billion Transactions A Day](http://highscalability.com/blog/2013/9/23/salesforce-architecture-how-they-handle-13-billion-transacti.html)
|
|
|
- [ ] [ESPN's Architecture At Scale - Operating At 100,000 Duh Nuh Nuhs Per Second](http://highscalability.com/blog/2013/11/4/espns-architecture-at-scale-operating-at-100000-duh-nuh-nuhs.html)
|
|
|
- [ ] See "Messaging, Serialization, and Queueing Systems" way below for info on some of the technologies that can glue services together
|
|
|
- [ ] Twitter:
|
|
|
- [O'Reilly MySQL CE 2011: Jeremy Cole, "Big and Small Data at @Twitter" (video)](https://www.youtube.com/watch?v=5cKTP36HVgI)
|
|
|
- [Timelines at Scale](https://www.infoq.com/presentations/Twitter-Timeline-Scalability)
|
|
|
- For even more, see "Mining Massive Datasets" video series in the [Video Series](#video-series) section.
|
|
|
- [ ] Practicing the system design process: Here are some ideas to try working through on paper, each with some documentation on how it was handled in the real world:
|
|
|
- review: [The System Design Primer](https://github.com/donnemartin/system-design-primer)
|
|
|
- [System Design from HiredInTech](http://www.hiredintech.com/system-design/)
|
|
|
- [cheat sheet](https://github.com/jwasham/coding-interview-university/blob/main/extras/cheat%20sheets/system-design.pdf)
|
|
|
- flow:
|
|
|
1. Zrozumienie problemu i zakresu:
|
|
|
- zdefiniowanie przypadków użycia, z pomocą rekrutera
|
|
|
- sugestia dodatkowych funkcji
|
|
|
- remove items that interviewer deems out of scope
|
|
|
- assume high availability is required, add as a use case
|
|
|
2. Think about constraints:
|
|
|
- ask how many requests per month
|
|
|
- ask how many requests per second (they may volunteer it or make you do the math)
|
|
|
- estimate reads vs. writes percentage
|
|
|
- keep 80/20 rule in mind when estimating
|
|
|
- how much data written per second
|
|
|
- total storage required over 5 years
|
|
|
- how much data read per second
|
|
|
3. Abstract design:
|
|
|
- layers (service, data, caching)
|
|
|
- infrastructure: load balancing, messaging
|
|
|
- rough overview of any key algorithm that drives the service
|
|
|
- consider bottlenecks and determine solutions
|
|
|
- Ćwiczenia:
|
|
|
- [Design a CDN network: old article](http://repository.cmu.edu/cgi/viewcontent.cgi?article=2112&context=compsci)
|
|
|
- [Design a random unique ID generation system](https://blog.twitter.com/2010/announcing-snowflake)
|
|
|
- [Design an online multiplayer card game](http://www.indieflashblog.com/how-to-create-an-asynchronous-multiplayer-game.html)
|
|
|
- [Design a key-value database](http://www.slideshare.net/dvirsky/introduction-to-redis)
|
|
|
- [Design a picture sharing system](http://highscalability.com/blog/2011/12/6/instagram-architecture-14-million-users-terabytes-of-photos.html)
|
|
|
- [Design a recommendation system](http://ijcai13.org/files/tutorial_slides/td3.pdf)
|
|
|
- [Design a URL-shortener system: copied from above](http://www.hiredintech.com/system-design/the-system-design-process/)
|
|
|
- [Design a cache system](https://www.adayinthelifeof.nl/2011/02/06/memcache-internals/)
|
|
|
|
|
|
---
|
|
|
|
|
|
## Końcowa rozmowa rekrutacyjna
|
|
|
|
|
|
W tej sekcji znajdują się krótsze filmy, które można dość szybko obejrzeć, aby przejrzeć większość ważnych pojęć.
|
|
|
Fajnie, jeśli często chcesz sobie odświeżać.
|
|
|
|
|
|
- [ ] Seria 2-3 minutowych, krótkich filmów tematycznych (23 wideo)
|
|
|
- [Videos](https://www.youtube.com/watch?v=r4r1DZcx1cM&list=PLmVb1OknmNJuC5POdcDv5oCS7_OUkDgpj&index=22)
|
|
|
- [ ] Seria 2–5 minutowych, krótkich filmów tematycznych - Michael Sambol (48 wideo):
|
|
|
- [Wideo](https://www.youtube.com/@MichaelSambol)
|
|
|
- [Code Examples](https://github.com/msambol/dsa)
|
|
|
- [ ] [Sedgewick Videos - Algorytmy I](https://www.coursera.org/learn/algorithms-part1)
|
|
|
- [ ] [Sedgewick Videos - Algorytmy II](https://www.coursera.org/learn/algorithms-part2)
|
|
|
|
|
|
---
|
|
|
|
|
|
## Praktyka kodowania
|
|
|
|
|
|
Teraz, gdy znasz już wszystkie powyższe tematy informatyki, nadszedł czas, aby poćwiczyć odpowiadanie na problemy z kodowaniem.
|
|
|
|
|
|
**Praktyka kodowania nie polega na zapamiętywaniu odpowiedzi, ale rozwiązywaniu problemów.**
|
|
|
|
|
|
Dlaczego musisz ćwiczyć rozwiązywanie problemów programistycznych:
|
|
|
- rozpoznawanie problemów i ustalenie gdzie pasują odpowiednie struktury danych i algorytmy
|
|
|
- zbieranie wymagań dla problemu
|
|
|
- omawianie problemu tak, jak podczas rozmowy rekrutacyjnej
|
|
|
- kodowanie na tablicy lub papierze, a nie na komputerze
|
|
|
- wymyślanie złożoności czasowej i pamięciowej dla swoich rozwiązań
|
|
|
- testowanie twoich rozwiązań
|
|
|
|
|
|
Tam jest świetny wstęp do metodycznego, komunikatywnego rozwiązywania problemu podczas rozmowy. Znajdziesz to również w książkach z rozmów rekrutacyjnych programistycznych, ale to znalazłem i uznałem za wybitne:
|
|
|
[Algorithm design canvas](http://www.hiredintech.com/algorithm-design/)
|
|
|
|
|
|
Brak tablicy w domu? To ma sens. Jestem dziwakiem i mam dużą tablicę. Zamiast tablicy, podnieś
|
|
|
duża podkładka do rysowania ze sklepu ze sztuką. Możesz usiąść na kanapie i ćwiczyć. To moja "sofa whiteboard".
|
|
|
Do zdjęcia dodałem pióro na skali. Jeśli używasz pióra, możesz wymazać. Szybko się psuje. Używam ołówka i gumki.
|
|
|
|
|
|
![my sofa whiteboard](https://d3j2pkmjtin6ou.cloudfront.net/art_board_sm_2.jpg)
|
|
|
|
|
|
Uzupełniające:
|
|
|
|
|
|
- [Mathematics for Topcoders](https://www.topcoder.com/community/competitive-programming/tutorials/mathematics-for-topcoders/)
|
|
|
- [Dynamic Programming – From Novice to Advanced](https://www.topcoder.com/community/competitive-programming/tutorials/dynamic-programming-from-novice-to-advanced/)
|
|
|
- [MIT Interview Materials](https://web.archive.org/web/20160906124824/http://courses.csail.mit.edu/iap/interview/materials.php)
|
|
|
|
|
|
**Przeczytaj i wykonaj zadania z programowania (w tej kolejności):**
|
|
|
|
|
|
- [ ] [Programming Interviews Exposed: Secrets to Landing Your Next Job, 2nd Edition](http://www.wiley.com/WileyCDA/WileyTitle/productCd-047012167X.html)
|
|
|
- answers in C, C++ and Java
|
|
|
- [ ] [Cracking the Coding Interview, 6th Edition](http://www.amazon.com/Cracking-Coding-Interview-6th-Programming/dp/0984782850/)
|
|
|
- odpowiedzi w Java
|
|
|
|
|
|
Zobacz [Lista książek powyżej](#book-list)
|
|
|
|
|
|
|
|
|
## Zadania/wyzwania programistyczne
|
|
|
|
|
|
Gdy już się nauczysz, pozwól popracować swojemu mózgowi.
|
|
|
Podejmuj wyzwania programistyczne każdego dnia, tak dużo, jak to możliwe.
|
|
|
|
|
|
- [How to Find a Solution](https://www.topcoder.com/community/competitive-programming/tutorials/how-to-find-a-solution/)
|
|
|
- [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)
|
|
|
- Super for walkthroughs of problem solutions.
|
|
|
- [Nick White - LeetCode Solutions (187 Videos)](https://www.youtube.com/playlist?list=PLU_sdQYzUj2keVENTP0a5rdykRSgg9Wp-)
|
|
|
- Good explanations of solution and the code.
|
|
|
- You can watch several in a short time.
|
|
|
- [FisherCoder - LeetCode Solutions](https://youtube.com/FisherCoder)
|
|
|
|
|
|
Challenge sites:
|
|
|
- [LeetCode](https://leetcode.com/)
|
|
|
- My favorite coding problem site. It's worth the subscription money for the 1-2 months you'll likely be preparing.
|
|
|
- [LeetCode solutions from FisherCoder](https://github.com/fishercoder1534/Leetcode)
|
|
|
- See Nick White Videos above for short code-throughs
|
|
|
- [HackerRank](https://www.hackerrank.com/)
|
|
|
- [TopCoder](https://www.topcoder.com/)
|
|
|
- [InterviewCake](https://www.interviewcake.com/)
|
|
|
- [Geeks for Geeks](http://www.geeksforgeeks.org/)
|
|
|
- [InterviewBit](https://www.interviewbit.com)
|
|
|
- [Project Euler (math-focused)](https://projecteuler.net/index.php?section=problems)
|
|
|
|
|
|
Language-learning sites, with challenges:
|
|
|
- [Codewars](http://www.codewars.com)
|
|
|
- [Codility](https://codility.com/programmers/)
|
|
|
- [HackerEarth](https://www.hackerearth.com/)
|
|
|
- [Sphere Online Judge (spoj)](http://www.spoj.com/)
|
|
|
- [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.
|
|
|
|
|
|
|
|
|
## Gdy już jesteś bliżej rozmowy rekrutacyjnej
|
|
|
|
|
|
- Cracking The Coding Interview Set 2 (videos):
|
|
|
- [Cracking The Code Interview](https://www.youtube.com/watch?v=4NIb9l3imAo)
|
|
|
- [Cracking the Coding Interview - Fullstack Speaker Series](https://www.youtube.com/watch?v=Eg5-tdAwclo)
|
|
|
|
|
|
## Twoje CV
|
|
|
|
|
|
- Zobacz elementy przygotowujące do CV w Cracking The Coding Interview i wróć do Programming Interviews Exposed
|
|
|
|
|
|
|
|
|
## Zastanów się, kiedy rozmowa kwalifikacyjna będzie nadchodzić
|
|
|
|
|
|
Pomyśl o około 20 pytaniach, które otrzymasz, wraz z wierszami poniższych pozycji. Po 2-3 odpowiedzi dla każdego.
|
|
|
Dobrze mieć historię, a nie tylko dane, opowiedz o czymś co osiągnąłeś.
|
|
|
|
|
|
- Czemu chcesz tę pracę?
|
|
|
- Jaki jest najcięższy problem, który rozwiązałeś?
|
|
|
- Największe wyzwanie z jakim się spotkałeś?
|
|
|
- Najlepsze/najgorsze projekty jaki widziałeś?
|
|
|
- Pomysły na ulepszenie istniejącego produktu.
|
|
|
- Jak pracujesz najlepiej, indywidualnie, czy jako część zespołu?
|
|
|
- Które z twoich umiejętności lub doświadczeń byłyby atutem w tej roli i dlaczego?
|
|
|
- Co najbardziej ci się podobało w [pracy x / projekcie y]?
|
|
|
- Jakie było największe wyzwanie, przed którym stanąłeś w [pracy x / projekcie y]?
|
|
|
- Jaki był najtrudniejszy bug, z jakim się spotkałeś w [pracy x / projekcie y]?
|
|
|
- Czego się nauczyłeś w [pracy x / projekcie y]?
|
|
|
- Co zrobiłbyś lepiej w [pracy x / projekcie y]?
|
|
|
|
|
|
## Pytania dla rekrutera
|
|
|
|
|
|
Niektóre z nich są moje (mogę już znać odpowiedź, ale chcę znać ich opinię lub perspektywę zespołu):
|
|
|
|
|
|
- Jak duży jest twój zespół?
|
|
|
- Jak wygląda twój cykl deweloperski? Czy pracujecie waterfall/sprints/agile?
|
|
|
- Czy pośpiech związany z deadline'ami jest częsty? Czy jest elastyczność?
|
|
|
- Jak podejmowane są decyzje w twoim zespole?
|
|
|
- Ile spotkań masz na tydzień?
|
|
|
- Czy uważasz, że twoje środowisko pracy pomaga ci się skoncentrować?
|
|
|
- Nad czym pracujesz?
|
|
|
- Co w tym lubisz?
|
|
|
- Jak wygląda życie zawodowe?
|
|
|
- Jak wygląda równowaga między pracą, a życiem prywatnym?
|
|
|
|
|
|
## Gdy już zdobędziesz pracę
|
|
|
|
|
|
Gratulacje!
|
|
|
|
|
|
Ucz się.
|
|
|
|
|
|
Tak na prawdę nigdy nie skończyłeś.
|
|
|
|
|
|
---
|
|
|
|
|
|
*****************************************************************************************************
|
|
|
*****************************************************************************************************
|
|
|
|
|
|
Wszystko poniżej tego punktu jest opcjonalne.
|
|
|
Ucząc się ich, zyskasz większą ekspozycję na więcej koncepcji informatyki i będziesz lepiej przygotowany do
|
|
|
dowolnych zadań inżynierii oprogramowania. Będziesz o wiele bardziej wszechstronnym inżynierem oprogramowania.
|
|
|
|
|
|
*****************************************************************************************************
|
|
|
*****************************************************************************************************
|
|
|
|
|
|
---
|
|
|
|
|
|
## Dodatkowe książki
|
|
|
|
|
|
Są tutaj, abyś mógł zagłębić się w interesujący ciebie temat.
|
|
|
|
|
|
- [The Unix Programming Environment](https://www.amazon.com/dp/013937681X)
|
|
|
- staruszek ale dobry
|
|
|
- [The Linux Command Line: A Complete Introduction](https://www.amazon.com/dp/1593273894/)
|
|
|
- współczesna wersja
|
|
|
- [TCP/IP Illustrated Series](https://en.wikipedia.org/wiki/TCP/IP_Illustrated)
|
|
|
- [Head First Design Patterns](https://www.amazon.com/gp/product/0596007124/)
|
|
|
- łagodne wprowadzenie do wzorców projektowych
|
|
|
- [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612)
|
|
|
- znane też jako książka "Banda czworga" lub GOF
|
|
|
- kanoniczna książka wzorców projektowych
|
|
|
- [UNIX and Linux System Administration Handbook, 5th Edition](https://www.amazon.com/UNIX-Linux-System-Administration-Handbook/dp/0134277554/)
|
|
|
- [Algorithm Design Manual](http://www.amazon.com/Algorithm-Design-Manual-Steven-Skiena/dp/1849967202) (Skiena)
|
|
|
- Jako przegląd i rozpoznanie problemu
|
|
|
- Część katalogu algorytmów znacznie wykracza poza zakres trudności, jakie napotkasz podczas rekrutacji.
|
|
|
- Ta książka składa się z 2 części:
|
|
|
- class textbook on data structures and algorithms
|
|
|
- plusy:
|
|
|
- is a good review as any algorithms textbook would be
|
|
|
- nice stories from his experiences solving problems in industry and academia
|
|
|
- code examples in C
|
|
|
- minusy:
|
|
|
- can be as dense or impenetrable as CLRS, and in some cases, CLRS may be a better alternative for some subjects
|
|
|
- chapters 7, 8, 9 can be painful to try to follow, as some items are not explained well or require more brain than I have
|
|
|
- don't get me wrong: I like Skiena, his teaching style, and mannerisms, but I may not be Stony Brook material.
|
|
|
- algorithm catalog:
|
|
|
- this is the real reason you buy this book.
|
|
|
- about to get to this part. Will update here once I've made my way through it.
|
|
|
- Można pożyczyć na kindle
|
|
|
- Odpowiedzi:
|
|
|
- [Rozwiązania](http://www.algorithm.cs.sunysb.edu/algowiki/index.php/The_Algorithms_Design_Manual_(Second_Edition))
|
|
|
- [Rozwiązania](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)
|
|
|
- The book was published in 2004, and is somewhat outdated, but it's a terrific resource for understanding a computer in brief.
|
|
|
- The author invented [HLA](https://en.wikipedia.org/wiki/High_Level_Assembly), so take mentions and examples in HLA with a grain of salt. Not widely used, but decent examples of what assembly looks like.
|
|
|
- These chapters are worth the read to give you a nice foundation:
|
|
|
- Rozdział 2 - Numeric Representation
|
|
|
- Rozdział 3 - Binary Arithmetic and Bit Operations
|
|
|
- Rozdział 4 - Floating-Point Representation
|
|
|
- Rozdział 5 - Character Representation
|
|
|
- Rozdział 6 - Memory Organization and Access
|
|
|
- Rozdział 7 - Composite Data Types and Memory Objects
|
|
|
- Rozdział 9 - CPU Architecture
|
|
|
- Rozdział 10 - Instruction Set Architecture
|
|
|
- Rozdział 11 - Memory Architecture and Organization
|
|
|
- [Wprowadzenie do algorytmów](https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844)
|
|
|
- **Ważne:** 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)
|
|
|
- The first couple of chapters present clever solutions to programming problems (some very old using data tape) but
|
|
|
that is just an intro. This a guidebook on program design and architecture.
|
|
|
|
|
|
## Dodatkowe materiały
|
|
|
|
|
|
Dodałem je, aby pomóc Ci zostać wszechstronnym inżynierem oprogramowania i mieć świadomość
|
|
|
technologii i algorytiki, dzięki czemu będziesz mieć większy zestaw narzędzi.
|
|
|
|
|
|
- ### Kompilatory
|
|
|
- [How a Compiler Works in ~1 minute (wideo)](https://www.youtube.com/watch?v=IhC7sdYe-Jg)
|
|
|
- [Harvard CS50 - Compilers (wideo)](https://www.youtube.com/watch?v=CSZLNYF4Klo)
|
|
|
- [C++ (wideo)](https://www.youtube.com/watch?v=twodd1KFfGk)
|
|
|
- [Understanding Compiler Optimization (C++) (wideo)](https://www.youtube.com/watch?v=FnGCDLhaxKU)
|
|
|
|
|
|
- ### Emacs oraz vi(m)
|
|
|
- Familiarize yourself with a unix-based code editor
|
|
|
- vi(m):
|
|
|
- [Editing With vim 01 - Installation, Setup, and The Modes (wideo)](https://www.youtube.com/watch?v=5givLEMcINQ&index=1&list=PL13bz4SHGmRxlZVmWQ9DvXo1fEg4UdGkr)
|
|
|
- [VIM Adventures](http://vim-adventures.com/)
|
|
|
- zestaw 4 wideo:
|
|
|
- [Edytor vi/vim - Lekcja 1](https://www.youtube.com/watch?v=SI8TeVMX8pk)
|
|
|
- [Edytor vi/vim - Lekcja 2](https://www.youtube.com/watch?v=F3OO7ZIOaJE)
|
|
|
- [Edytor vi/vim - Lekcja 3](https://www.youtube.com/watch?v=ZYEccA_nMaI)
|
|
|
- [Edytor vi/vim - Lekcja 4](https://www.youtube.com/watch?v=1lYD5gwgZIA)
|
|
|
- [Używanie Vi zamiast Emacs](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#Using_Vi_instead_of_Emacs)
|
|
|
- emacs:
|
|
|
- [Basics Emacs Tutorial (wideo)](https://www.youtube.com/watch?v=hbmV1bnQ-i0)
|
|
|
- zestaw 3-ch (wideo):
|
|
|
- [Emacs Tutorial (Beginners) -Part 1- File commands, cut/copy/paste, cursor commands](https://www.youtube.com/watch?v=ujODL7MD04Q)
|
|
|
- [Emacs Tutorial (Beginners) -Part 2- Buffer management, search, M-x grep and rgrep modes](https://www.youtube.com/watch?v=XWpsRupJ4II)
|
|
|
- [Emacs Tutorial (Beginners) -Part 3- Expressions, Statements, ~/.emacs file and packages](https://www.youtube.com/watch?v=paSgzPso-yc)
|
|
|
- [Evil Mode: Or, How I Learned to Stop Worrying and Love Emacs (wideo)](https://www.youtube.com/watch?v=JWD1Fpdd4Pc)
|
|
|
- [Writing C Programs With Emacs](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#Writing_C_programs_with_Emacs)
|
|
|
- [(maybe) Org Mode In Depth: Managing Structure (wideo)](https://www.youtube.com/watch?v=nsGYet02bEk)
|
|
|
|
|
|
- ### Narzędzia wiersza poleceń systemu Unix
|
|
|
- I filled in the list below from good tools.
|
|
|
- bash
|
|
|
- cat
|
|
|
- grep
|
|
|
- sed
|
|
|
- awk
|
|
|
- curl or wget
|
|
|
- sort
|
|
|
- tr
|
|
|
- uniq
|
|
|
- [strace](https://en.wikipedia.org/wiki/Strace)
|
|
|
- [tcpdump](https://danielmiessler.com/study/tcpdump/)
|
|
|
|
|
|
- ### Teoria informacji (filmy)
|
|
|
- [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)
|
|
|
- [Core Implementing Markov Text Generation](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/gZhiC/core-implementing-markov-text-generation)
|
|
|
- [Project = Markov Text Generation Walk Through](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/EUjrq/project-markov-text-generation-walk-through)
|
|
|
- See more in MIT 6.050J Information and Entropy series below.
|
|
|
|
|
|
- ### Parity & Hamming Code (wideo)
|
|
|
- [Wprowadzenie](https://www.youtube.com/watch?v=q-3BctoUpHE)
|
|
|
- [Kontrola parzystości](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)
|
|
|
|
|
|
- ### Entropia
|
|
|
- zobacz też materiały wideo poniżej
|
|
|
- upewnij się że widziałeś wcześniej wideo z teorii informacji
|
|
|
- [Information Theory, Claude Shannon, Entropy, Redundancy, Data Compression & Bits (video)](https://youtu.be/JnJq3Py0dyM?t=176)
|
|
|
|
|
|
- ### Kryptografia
|
|
|
- zobacz też materiały wideo poniżej
|
|
|
- upewnij się że widziałeś wcześniej wideo z teorii informacji
|
|
|
- [Khan Academy Series](https://www.khanacademy.org/computing/computer-science/cryptography)
|
|
|
- [Cryptography: Hash Functions](https://www.youtube.com/watch?v=KqqOXndnvic&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=30)
|
|
|
- [Cryptography: Encryption](https://www.youtube.com/watch?v=9TNI2wHmaeI&index=31&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
|
|
|
|
|
|
- ### Kompresja
|
|
|
- upewnij się że widziałeś wcześniej wideo z teorii informacji
|
|
|
- Computerphile (wideo):
|
|
|
- [Kompresja](https://www.youtube.com/watch?v=Lto-ajuqW3w)
|
|
|
- [Entropia w kompresji](https://www.youtube.com/watch?v=M5c_RFKVkko)
|
|
|
- [Upside Down Trees (Drzewa Huffman)](https://www.youtube.com/watch?v=umTbivyJoiI)
|
|
|
- [EXTRA BITS/TRITS - Drzewa Huffman](https://www.youtube.com/watch?v=DV8efuB3h2g)
|
|
|
- [Elegant Compression in Text (The LZ 77 Method)](https://www.youtube.com/watch?v=goOa3DGezUA)
|
|
|
- [Text Compression Meets Probabilities](https://www.youtube.com/watch?v=cCDCfoHTsaU)
|
|
|
- [Compressor Head videos](https://www.youtube.com/playlist?list=PLOU2XLYxmsIJGErt5rrCqaSGTMyyqNt2H)
|
|
|
- [(opcjonalnie) Google Developers Live: GZIP is not enough!](https://www.youtube.com/watch?v=whGwm0Lky2s)
|
|
|
|
|
|
- ### Bezpieczeństwo komputerowe
|
|
|
- [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)
|
|
|
- [Buffer Overflow Exploits and Defenses](https://www.youtube.com/watch?v=drQyrzRoRiA&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh&index=3)
|
|
|
- [Privilege Separation](https://www.youtube.com/watch?v=6SIJmoE9L9g&index=4&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
|
|
|
- [Capabilities](https://www.youtube.com/watch?v=8VqTSY-11F4&index=5&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
|
|
|
- [Sandboxing Native Code](https://www.youtube.com/watch?v=VEV74hwASeU&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh&index=6)
|
|
|
- [Web Security Model](https://www.youtube.com/watch?v=chkFBigodIw&index=7&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
|
|
|
- [Securing Web Applications](https://www.youtube.com/watch?v=EBQIGy1ROLY&index=8&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
|
|
|
- [Symbolic Execution](https://www.youtube.com/watch?v=yRVZPvHYHzw&index=9&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
|
|
|
- [Network Security](https://www.youtube.com/watch?v=SIEVvk3NVuk&index=11&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
|
|
|
- [Network Protocols](https://www.youtube.com/watch?v=QOtA76ga_fY&index=12&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
|
|
|
- [Side-Channel Attacks](https://www.youtube.com/watch?v=PuVMkSEcPiI&index=15&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
|
|
|
|
|
|
- ### Garbage collection - Odśmiecanie pamięci
|
|
|
- [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 (wideo)](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 (wideo)](https://www.youtube.com/watch?v=uY85GkaYzBk)
|
|
|
|
|
|
- ### Messaging, Serialization, and Queueing Systems
|
|
|
- [Thrift](https://thrift.apache.org/)
|
|
|
- [Samouczek](http://thrift-tutorial.readthedocs.io/en/latest/intro.html)
|
|
|
- [Protocol Buffers](https://developers.google.com/protocol-buffers/)
|
|
|
- [Samouczki](https://developers.google.com/protocol-buffers/docs/tutorials)
|
|
|
- [gRPC](http://www.grpc.io/)
|
|
|
- [gRPC 101 for Java Developers (wideo)](https://www.youtube.com/watch?v=5tmPvSe7xXQ&list=PLcTqM9n_dieN0k1nSeN36Z_ppKnvMJoly&index=1)
|
|
|
- [Redis](http://redis.io/)
|
|
|
- [Samouczek](http://try.redis.io/)
|
|
|
- [Amazon SQS (kolejka)](https://aws.amazon.com/sqs/)
|
|
|
- [Amazon SNS (pub-sub)](https://aws.amazon.com/sns/)
|
|
|
- [RabbitMQ](https://www.rabbitmq.com/)
|
|
|
- [Rozpocznij](https://www.rabbitmq.com/getstarted.html)
|
|
|
- [Celery](http://www.celeryproject.org/)
|
|
|
- [Pierwsze kroki z Celery](http://docs.celeryproject.org/en/latest/getting-started/first-steps-with-celery.html)
|
|
|
- [ZeroMQ](http://zeromq.org/)
|
|
|
- [Wstęp - przeczytaj podręcznik](http://zeromq.org/intro:read-the-manual)
|
|
|
- [ActiveMQ](http://activemq.apache.org/)
|
|
|
- [Kafka](http://kafka.apache.org/documentation.html#introduction)
|
|
|
- [MessagePack](http://msgpack.org/index.html)
|
|
|
- [Avro](https://avro.apache.org/)
|
|
|
|
|
|
- ### A*
|
|
|
- [A Search Algorithm](https://en.wikipedia.org/wiki/A*_search_algorithm)
|
|
|
- [A* Pathfinding Tutorial (wideo)](https://www.youtube.com/watch?v=KNXfSOx4eEE)
|
|
|
- [A* Pathfinding (E01: algorithm explanation) (wideo)](https://www.youtube.com/watch?v=-L-WgKMFuhE)
|
|
|
|
|
|
- ### Szybka transformata Fouriera
|
|
|
- [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? (wideo)](https://www.youtube.com/watch?v=Xxut2PN-V8Q)
|
|
|
- [Divide & Conquer: FFT (wideo)](https://www.youtube.com/watch?v=iTMn0Kt18tg&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=4)
|
|
|
- [Understanding The FFT](http://jakevdp.github.io/blog/2013/08/28/understanding-the-fft/)
|
|
|
|
|
|
- ### Filtr Blooma
|
|
|
- Given a Bloom filter with m bits and k hashing functions, both insertion and membership testing are O(k)
|
|
|
- [Bloom Filters (wideo)](https://www.youtube.com/watch?v=-SuTGoFYjZs)
|
|
|
- [Bloom Filters | Mining of Massive Datasets | Stanford University (video)](https://www.youtube.com/watch?v=qBTdukbzc78)
|
|
|
- [Tutorial](http://billmill.org/bloomfilter-tutorial/)
|
|
|
- [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 (wideo)](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)
|
|
|
|
|
|
- ### Rozszerzone struktury danych
|
|
|
- [CS 61B Lecture 39: Augmenting Data Structures](https://archive.org/details/ucberkeley_webcast_zksIj9O8_jc)
|
|
|
|
|
|
- ### Zrównoważone drzewa wyszukiwania
|
|
|
- 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
|
|
|
to move any accessed key to the root." - Skiena
|
|
|
- Of these, I chose to implement a splay tree. From what I've read, you won't implement a
|
|
|
balanced search tree in your interview. But I wanted exposure to coding one up
|
|
|
and let's face it, splay trees are the bee's knees. I did read a lot of red-black tree code.
|
|
|
- splay tree: insert, search, delete functions
|
|
|
If you end up implementing red/black tree try just these:
|
|
|
- search and insertion functions, skipping delete
|
|
|
- I want to learn more about B-Tree since it's used so widely with very large data sets.
|
|
|
- [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
|
|
|
balanced than red–black trees, leading to slower insertion and removal but faster retrieval. This makes it
|
|
|
attractive for data structures that may be built once and loaded without reconstruction, such as language
|
|
|
dictionaries (or program dictionaries, such as the opcodes of an assembler or interpreter).
|
|
|
- [MIT AVL Trees / AVL Sort (wideo)](https://www.youtube.com/watch?v=FNeL18KsWPc&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=6)
|
|
|
- [AVL Trees (wideo)](https://www.coursera.org/learn/data-structures/lecture/Qq5E0/avl-trees)
|
|
|
- [AVL Tree Implementation (wideo)](https://www.coursera.org/learn/data-structures/lecture/PKEBC/avl-tree-implementation)
|
|
|
- [Split And Merge](https://www.coursera.org/learn/data-structures/lecture/22BgE/split-and-merge)
|
|
|
- [[Review] AVL Trees (playlist) in 19 minutes (video)](https://www.youtube.com/playlist?list=PL9xmBV_5YoZOUFgdIeOPuH6cfSnNRMau-)
|
|
|
|
|
|
- **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,
|
|
|
networking and file system code) etc.
|
|
|
- [CS 61B: Splay Trees (wideo)](https://archive.org/details/ucberkeley_webcast_G5QIXywcJlY)
|
|
|
- MIT Lecture: Splay Trees:
|
|
|
- Gets very mathy, but watch the last 10 minutes for sure.
|
|
|
- [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.
|
|
|
Not only does this make them valuable in time-sensitive applications such as real-time applications,
|
|
|
but it makes them valuable building blocks in other data structures which provide worst-case guarantees;
|
|
|
for example, many data structures used in computational geometry can be based on red–black trees, and
|
|
|
the Completely Fair Scheduler used in current Linux kernels uses red–black trees. In the version 8 of Java,
|
|
|
the Collection HashMap has been modified such that instead of using a LinkedList to store identical elements with poor
|
|
|
hashcodes, a Red-Black tree is used.
|
|
|
- [Aduni - Algorithms - Lecture 4 (link jumps to starting point) (wideo)](https://youtu.be/1W3x0f_RmUo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=3871)
|
|
|
- [Aduni - Algorithms - Lecture 5 (wideo)](https://www.youtube.com/watch?v=hm2GHwyKF1o&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=5)
|
|
|
- [Red-Black Tree](https://en.wikipedia.org/wiki/Red%E2%80%93black_tree)
|
|
|
- [An Introduction To Binary Search And Red Black Tree](https://www.topcoder.com/thrive/articles/An%20Introduction%20to%20Binary%20Search%20and%20Red-Black%20Trees)
|
|
|
- [[Review] Red-Black Trees (playlist) in 30 minutes (video)](https://www.youtube.com/playlist?list=PL9xmBV_5YoZNqDI8qfOZgzbqahCUmUEin)
|
|
|
|
|
|
- **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.
|
|
|
- [23-Tree Intuition and Definition (wideo)](https://www.youtube.com/watch?v=C3SsdUqasD4&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6&index=2)
|
|
|
- [Binary View of 23-Tree](https://www.youtube.com/watch?v=iYvBtGKsqSg&index=3&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
|
|
|
- [2-3 Trees (student recitation) (wideo)](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
|
|
|
important tool for understanding the logic behind red–black trees, and this is why many introductory algorithm texts introduce
|
|
|
2-4 trees just before red–black trees, even though **2-4 trees are not often used in practice**.
|
|
|
- [CS 61B Lecture 26: Balanced Search Trees (wideo)](https://archive.org/details/ucberkeley_webcast_zqrqYXkth6Q)
|
|
|
- [Bottom Up 234-Trees (wideo)](https://www.youtube.com/watch?v=DQdMYevEyE4&index=4&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
|
|
|
- [Top Down 234-Trees (wideo)](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
|
|
|
- [K-Ary Tree](https://en.wikipedia.org/wiki/K-ary_tree)
|
|
|
|
|
|
- **B-Trees**
|
|
|
- fun fact: it's a mystery, but the B could stand for Boeing, Balanced, or Bayer (co-inventor)
|
|
|
- In Practice:
|
|
|
B-Trees are widely used in databases. Most modern filesystems use B-trees (or Variants). In addition to
|
|
|
its use in databases, the B-tree is also used in filesystems to allow quick random access to an arbitrary
|
|
|
block in a particular file. The basic problem is turning the file block i address into a disk block
|
|
|
(or perhaps to a cylinder-head-sector) address.
|
|
|
- [B-Tree](https://en.wikipedia.org/wiki/B-tree)
|
|
|
- [B-Tree Datastructure](http://btechsmartclass.com/data_structures/b-trees.html)
|
|
|
- [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)
|
|
|
- [[Review] B-Trees (playlist) in 26 minutes (video)](https://www.youtube.com/playlist?list=PL9xmBV_5YoZNFPPv98DjTdD9X6UI9KMHz)
|
|
|
|
|
|
|
|
|
- ### 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 (wideo)](https://www.youtube.com/watch?v=W94M9D_yXKk)
|
|
|
- [kNN K-d tree algorithm (wideo)](https://www.youtube.com/watch?v=Y4ZgLlDfKDg)
|
|
|
|
|
|
- ### Skip lists
|
|
|
- "These are somewhat of a cult data structure" - Skiena
|
|
|
- [Randomization: Skip Lists (wideo)](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
|
|
|
- [Ford-Fulkerson in 5 minutes — Step by step example (wideo)](https://www.youtube.com/watch?v=Tl90tNtKvxs)
|
|
|
- [Ford-Fulkerson Algorithm (wideo)](https://www.youtube.com/watch?v=v1VgJmkEJW0)
|
|
|
- [Network Flows (wideo)](https://www.youtube.com/watch?v=2vhN4Ice5jI)
|
|
|
|
|
|
- ### Disjoint Sets & Union Find
|
|
|
- [UCB 61B - Disjoint Sets; Sorting & selection (wideo)](https://archive.org/details/ucberkeley_webcast_MAEGXTwmUsI)
|
|
|
- [Sedgewick Algorithms - Union-Find (6 wideo)](https://www.coursera.org/learn/algorithms-part1/home/week/1)
|
|
|
|
|
|
- ### Math for Fast Processing
|
|
|
- [Integer Arithmetic, Karatsuba Multiplication (wideo)](https://www.youtube.com/watch?v=eCaXlAaN2uE&index=11&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
|
|
|
- [The Chinese Remainder Theorem (used in cryptography) (wideo)](https://www.youtube.com/watch?v=ru7mWZJlRQg)
|
|
|
|
|
|
- ### Sterta
|
|
|
- Combination of a binary search tree and a heap
|
|
|
- [Sterta](https://en.wikipedia.org/wiki/Treap)
|
|
|
- [Struktury danych: wytłumaczenie sterty (wideo)](https://www.youtube.com/watch?v=6podLUYinH8)
|
|
|
- [Applications in set operations](https://www.cs.cmu.edu/~scandal/papers/treaps-spaa98.pdf)
|
|
|
|
|
|
- ### Programowanie liniowe (wideo)
|
|
|
- [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)
|
|
|
- [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)
|
|
|
|
|
|
- ### Matematyka dyskretna
|
|
|
- zobacz wideo poniżej
|
|
|
|
|
|
- ### Machine Learning - Uczenie maszynowe
|
|
|
- Czemu 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)
|
|
|
- [Deep Learning and Understandability versus Software Engineering and Verification by Peter Norvig](https://www.youtube.com/watch?v=X769cyzBNVw)
|
|
|
- [Google's Cloud Machine learning tools (video)](https://www.youtube.com/watch?v=Ja2hxBAwG_0)
|
|
|
- [Google Developers' Machine Learning Recipes (Scikit Learn & Tensorflow) (video)](https://www.youtube.com/playlist?list=PLOU2XLYxmsIIuiBfYad6rFYQU_jL2ryal)
|
|
|
- [Tensorflow (video)](https://www.youtube.com/watch?v=oZikw5k_2FM)
|
|
|
- [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)
|
|
|
- [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)
|
|
|
- Resources:
|
|
|
- Books:
|
|
|
- [Python Machine Learning](https://www.amazon.com/Python-Machine-Learning-Sebastian-Raschka/dp/1783555130/)
|
|
|
- [Data Science from Scratch: First Principles with Python](https://www.amazon.com/Data-Science-Scratch-Principles-Python/dp/149190142X)
|
|
|
- [Introduction to Machine Learning with Python](https://www.amazon.com/Introduction-Machine-Learning-Python-Scientists/dp/1449369413/)
|
|
|
- [Machine Learning for Software Engineers](https://github.com/ZuzooVn/machine-learning-for-software-engineers)
|
|
|
- Data School: http://www.dataschool.io/
|
|
|
|
|
|
---
|
|
|
|
|
|
## Dodatkowe szczegóły na niektóre tematy
|
|
|
|
|
|
I added these to reinforce some ideas already presented above, but didn't want to include them
|
|
|
above because it's just too much. It's easy to overdo it on a subject.
|
|
|
You want to get hired in this century, right?
|
|
|
|
|
|
- **SOLID**
|
|
|
- [ ] [Bob Martin SOLID Principles of Object Oriented and Agile Design (video)](https://www.youtube.com/watch?v=TMuno5RZNeE)
|
|
|
- [ ] S - [Single Responsibility Principle](http://www.oodesign.com/single-responsibility-principle.html) | [Single responsibility to each Object](http://www.javacodegeeks.com/2011/11/solid-single-responsibility-principle.html)
|
|
|
- [more flavor](https://docs.google.com/open?id=0ByOwmqah_nuGNHEtcU5OekdDMkk)
|
|
|
- [ ] O - [Open/Closed Principal](http://www.oodesign.com/open-close-principle.html) | [On production level Objects are ready for extension but not for modification](https://en.wikipedia.org/wiki/Open/closed_principle)
|
|
|
- [more flavor](http://docs.google.com/a/cleancoder.com/viewer?a=v&pid=explorer&chrome=true&srcid=0BwhCYaYDn8EgN2M5MTkwM2EtNWFkZC00ZTI3LWFjZTUtNTFhZGZiYmUzODc1&hl=en)
|
|
|
- [ ] L - [Liskov Substitution Principal](http://www.oodesign.com/liskov-s-substitution-principle.html) | [Base Class and Derived class follow ‘IS A’ principal](http://stackoverflow.com/questions/56860/what-is-the-liskov-substitution-principle)
|
|
|
- [more flavor](http://docs.google.com/a/cleancoder.com/viewer?a=v&pid=explorer&chrome=true&srcid=0BwhCYaYDn8EgNzAzZjA5ZmItNjU3NS00MzQ5LTkwYjMtMDJhNDU5ZTM0MTlh&hl=en)
|
|
|
- [ ] I - [Interface segregation principle](http://www.oodesign.com/interface-segregation-principle.html) | clients should not be forced to implement interfaces they don't use
|
|
|
- [Interface Segregation Principle in 5 minutes (wideo)](https://www.youtube.com/watch?v=3CtAfl7aXAQ)
|
|
|
- [more flavor](http://docs.google.com/a/cleancoder.com/viewer?a=v&pid=explorer&chrome=true&srcid=0BwhCYaYDn8EgOTViYjJhYzMtMzYxMC00MzFjLWJjMzYtOGJiMDc5N2JkYmJi&hl=en)
|
|
|
- [ ] D -[Dependency Inversion principle](http://www.oodesign.com/dependency-inversion-principle.html) | Reduce the dependency In composition of objects.
|
|
|
- [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**
|
|
|
- [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)
|
|
|
- [Union By Rank](https://www.coursera.org/learn/data-structures/lecture/qb4c2/union-by-rank)
|
|
|
- [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)
|
|
|
|
|
|
- **Bardziej dynamiczne programowanie** (wideo)
|
|
|
- [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)
|
|
|
- [6.006: DP IV: Guitar Fingering, Tetris, Super Mario Bros.](https://www.youtube.com/watch?v=tp4_UXaVyx8&index=22&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
|
|
|
- [6.046: Dynamic Programming & Advanced DP](https://www.youtube.com/watch?v=Tw1k46ywN6E&index=14&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
|
|
|
- [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)
|
|
|
|
|
|
- **Zaawansowane przetwarzanie wykresów** (wideos)
|
|
|
- [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 **Prawdopodobieństwo** (matma, i idź po mału, co jest dobre dla takich rzeczy) (wideos):
|
|
|
- [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)
|
|
|
- [MIT 6.042J - Random Variables](https://www.youtube.com/watch?v=MOfhhFaQdjw&list=PLB7540DEDD482705B&index=21)
|
|
|
- [MIT 6.042J - Expectation I](https://www.youtube.com/watch?v=gGlMSe7uEkA&index=22&list=PLB7540DEDD482705B)
|
|
|
- [MIT 6.042J - Expectation II](https://www.youtube.com/watch?v=oI9fMUqgfxY&index=23&list=PLB7540DEDD482705B)
|
|
|
- [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**
|
|
|
- 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)
|
|
|
- [Optimization: Implementation and Analysis](https://www.coursera.org/learn/data-structures/lecture/h4ZLc/optimization-implementation-and-analysis)
|
|
|
- [Table Doubling, Karp-Rabin](https://www.youtube.com/watch?v=BRO7mVIFt08&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=9)
|
|
|
- [Rolling Hashes, Amortized Analysis](https://www.youtube.com/watch?v=w6nuXg0BISo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=32)
|
|
|
- Knuth-Morris-Pratt (KMP):
|
|
|
- [TThe Knuth-Morris-Pratt (KMP) String Matching Algorithm](https://www.youtube.com/watch?v=5i7oKodCRJo)
|
|
|
- Boyer–Moore string search algorithm
|
|
|
- [Boyer-Moore String Search Algorithm](https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm)
|
|
|
- [Advanced String Searching Boyer-Moore-Horspool Algorithms (wideo)](https://www.youtube.com/watch?v=QDZpzctPf10)
|
|
|
- [Coursera: Algorithms on Strings](https://www.coursera.org/learn/algorithms-on-strings/home/week/1)
|
|
|
- starts off great, but by the time it gets past KMP it gets more complicated than it needs to be
|
|
|
- nice explanation of tries
|
|
|
- can be skipped
|
|
|
|
|
|
- **Sortowania**
|
|
|
|
|
|
- Stanford lectures on sorting:
|
|
|
- [Lecture 15 | Programming Abstractions (wideo)](https://www.youtube.com/watch?v=ENp00xylP7c&index=15&list=PLFE6E58F856038C69)
|
|
|
- [Lecture 16 | Programming Abstractions (wideo)](https://www.youtube.com/watch?v=y4M9IVgrVKo&index=16&list=PLFE6E58F856038C69)
|
|
|
- Shai Simonson, [Aduni.org](http://www.aduni.org/):
|
|
|
- [Algorithms - Sorting - Lecture 2 (wideo)](https://www.youtube.com/watch?v=odNJmw5TOEE&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=2)
|
|
|
- [Algorithms - Sorting II - Lecture 3 (wideo)](https://www.youtube.com/watch?v=hj8YKFTFKEE&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=3)
|
|
|
- Steven Skiena lectures on sorting:
|
|
|
- [lecture begins at 26:46 (wideo)](https://youtu.be/ute-pmMkyuk?list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&t=1600)
|
|
|
- [lecture begins at 27:40 (wideo)](https://www.youtube.com/watch?v=yLvp-pB8mak&index=8&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b)
|
|
|
- [lecture begins at 35:00 (wideo)](https://www.youtube.com/watch?v=q7K9otnzlfE&index=9&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b)
|
|
|
- [lecture begins at 23:50 (wideo)](https://www.youtube.com/watch?v=TvqIGu9Iupw&list=PLOtl7M3yp-DV69F32zdK7YJcNXpTunF2b&index=10)
|
|
|
|
|
|
## Serie wideo
|
|
|
|
|
|
Usiądź i spędź miło czas. "Netflix and skill" :P
|
|
|
|
|
|
- [List of individual Dynamic Programming problems (each is short)](https://www.youtube.com/playlist?list=PLrmLmBdmIlpsHaNTPP_jHHDx_os9ItYXr)
|
|
|
|
|
|
- [x86 Architecture, Assembly, Applications (11 wideo)](https://www.youtube.com/playlist?list=PL038BE01D3BAEFDB0)
|
|
|
|
|
|
- [MIT 18.06 Linear Algebra, Spring 2005 (35 wideo)](https://www.youtube.com/playlist?list=PLE7DDD91010BC51F8)
|
|
|
|
|
|
- [Excellent - MIT Calculus Revisited: Single Variable Calculus](https://www.youtube.com/playlist?list=PL3B08AE665AB9002A)
|
|
|
|
|
|
- [Computer Science 70, 001 - Spring 2015 - Discrete Mathematics and Probability Theory](http://www.infocobuild.com/education/audio-video-courses/computer-science/cs70-spring2015-berkeley.html)
|
|
|
|
|
|
- [Discrete Mathematics by Shai Simonson (19 wideo)](https://www.youtube.com/playlist?list=PLWX710qNZo_sNlSWRMVIh6kfTjolNaZ8t)
|
|
|
|
|
|
- [Discrete Mathematics Part 1 by Sarada Herke (5 wideo)](https://www.youtube.com/playlist?list=PLGxuz-nmYlQPOc4w1Kp2MZrdqOOm4Jxeo)
|
|
|
|
|
|
- CSE373 - Analysis of Algorithms (25 filmy)
|
|
|
- [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 wideo)](https://archive.org/details/ucberkeley-webcast-PL-XXv-cvA_iAlnI-BQr9hjqADPBtujFJd)
|
|
|
|
|
|
- [UC Berkeley 61B (Fall 2006): Data Structures (39 wideo)](https://archive.org/details/ucberkeley-webcast-PL4BBB74C7D2A1049C)
|
|
|
|
|
|
- [UC Berkeley 61C: Machine Structures (26 wideo)](https://archive.org/details/ucberkeley-webcast-PL-XXv-cvA_iCl2-D-FS5mk0jFF6cYSJs_)
|
|
|
|
|
|
- [OOSE: Software Dev Using UML and Java (21 wideo)](https://www.youtube.com/playlist?list=PLJ9pm_Rc9HesnkwKlal_buSIHA-jTZMpO)
|
|
|
|
|
|
- ~~[UC Berkeley CS 152: Computer Architecture and Engineering (20 filmy)](https://www.youtube.com/watch?v=UH0QYvtP7Rk&index=20&list=PLkFD6_40KJIwEiwQx1dACXwh-2Fuo32qr)~~
|
|
|
|
|
|
- [MIT 6.004: Computation Structures (49 wideo)](https://www.youtube.com/playlist?list=PLDSlqjcPpoL64CJdF0Qee5oWqGS6we_Yu)
|
|
|
|
|
|
- [Carnegie Mellon - Computer Architecture Lectures (39 wideo)](https://www.youtube.com/playlist?list=PL5PHm2jkkXmi5CxxI7b3JCL1TWybTDtKq)
|
|
|
|
|
|
- [MIT 6.006: Intro to Algorithms (47 wideo)](https://www.youtube.com/watch?v=HtSuA80QTyo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&nohtml5=False)
|
|
|
|
|
|
- [MIT 6.033: Computer System Engineering (22 wideo)](https://www.youtube.com/watch?v=zm2VP0kHl1M&list=PL6535748F59DCA484)
|
|
|
|
|
|
- [MIT 6.034 Artificial Intelligence, Fall 2010 (30 wideo)](https://www.youtube.com/playlist?list=PLUl4u3cNGP63gFHB6xb-kVBiQHYe_4hSi)
|
|
|
|
|
|
- [MIT 6.042J: Mathematics for Computer Science, Fall 2010 (25 wideo)](https://www.youtube.com/watch?v=L3LMbpZIKhQ&list=PLB7540DEDD482705B)
|
|
|
|
|
|
- [MIT 6.046: Design and Analysis of Algorithms (34 wideo)](https://www.youtube.com/watch?v=2P-yW7LQr08&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
|
|
|
|
|
|
- [MIT 6.050J: Information and Entropy, Spring 2008 (19 wideo)](https://www.youtube.com/watch?v=phxsQrZQupo&list=PL_2Bwul6T-A7OldmhGODImZL8KEVE38X7)
|
|
|
|
|
|
- [MIT 6.851: Advanced Data Structures (22 wideo)](https://www.youtube.com/watch?v=T0yzrZL1py0&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf&index=1)
|
|
|
|
|
|
- [MIT 6.854: Advanced Algorithms, Spring 2016 (24 wideo)](https://www.youtube.com/playlist?list=PL6ogFv-ieghdoGKGg2Bik3Gl1glBTEu8c)
|
|
|
|
|
|
- [Harvard COMPSCI 224: Advanced Algorithms (25 wideo)](https://www.youtube.com/playlist?list=PL2SOU6wwxB0uP4rJgf5ayhHWgw7akUWSf)
|
|
|
|
|
|
- [MIT 6.858 Computer Systems Security, Fall 2014](https://www.youtube.com/watch?v=GqmQg-cszw4&index=1&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
|
|
|
|
|
|
- [Stanford: Programming Paradigms (27 wideo)](https://www.youtube.com/playlist?list=PL9D558D49CA734A02)
|
|
|
|
|
|
- [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 wideo)](https://www.youtube.com/playlist?list=PLLssT5z_DsK9JDLcT8T62VtzwyW9LNepV)
|
|
|
|
|
|
- [Graph Theory by Sarada Herke (67 wideo)](https://www.youtube.com/user/DrSaradaHerke/playlists?shelf_id=5&view=50&sort=dd)
|
|
|
|
|
|
## Kursy Computer Science
|
|
|
|
|
|
- [Katalog internetowych kursów informatyki](https://github.com/open-source-society/computer-science)
|
|
|
- [Katalog kursów informatyki (wiele z wykładami online)](https://github.com/prakhar1989/awesome-courses)
|
|
|
|
|
|
## Literatura
|
|
|
|
|
|
- [Lubisz tradycyjne prace naukowe?](https://www.cs.cmu.edu/~crary/819-f09/)
|
|
|
- [1978: Communicating Sequential Processes](http://spinroot.com/courses/summer/Papers/hoare_1978.pdf)
|
|
|
- [zaimplementowane w Go](https://godoc.org/github.com/thomas11/csp)
|
|
|
- [2003: System plików Google](http://static.googleusercontent.com/media/research.google.com/en//archive/gfs-sosp2003.pdf)
|
|
|
- zastąpiony przez Colossus w 2012 r
|
|
|
- [2004: MapReduce: Uproszczone przetwarzanie danych w dużych klastrach]( http://static.googleusercontent.com/media/research.google.com/en//archive/mapreduce-osdi04.pdf)
|
|
|
- w większości zastąpiony przez Cloud Dataflow?
|
|
|
- [2006: Bigtable: Rozproszony system przechowywania danych strukturalnych](https://static.googleusercontent.com/media/research.google.com/en//archive/bigtable-osdi06.pdf)
|
|
|
- [Spojrzenie od wewnątrz na Google BigQuery](https://cloud.google.com/files/BigQueryTechnicalWP.pdf)
|
|
|
- [2006: The Chubby Lock Service for Loosely-Coupled Distributed Systems](https://research.google.com/archive/chubby-osdi06.pdf)
|
|
|
- [2007: Dynamo: Wysoce dostępny magazyn Amazon o kluczowej wartości](http://s3.amazonaws.com/AllThingsDistributed/sosp/amazon-dynamo-sosp2007.pdf)
|
|
|
- The Dynamo paper kicked off the NoSQL revolution
|
|
|
- [2007: Co każdy programista powinien wiedzieć o pamięci (bardzo długie, ale autor zachęca do pomijania niektórych sekcji)](https://www.akkadia.org/drepper/cpumemory.pdf)
|
|
|
- [2010: Dapper, a Large-Scale Distributed Systems Tracing Infrastructure](https://research.google.com/pubs/archive/36356.pdf)
|
|
|
- [2010: Dremel: Interactive Analysis of Web-Scale Datasets](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/36632.pdf)
|
|
|
- [2012: Google's Colossus](https://www.wired.com/2012/07/google-colossus/)
|
|
|
- paper not available
|
|
|
- 2012: AddressSanitizer: A Fast Address Sanity Checker:
|
|
|
- [praca (pdf)](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/37752.pdf)
|
|
|
- [film](https://www.usenix.org/conference/atc12/technical-sessions/presentation/serebryany)
|
|
|
- 2013: Spanner: Google’s Globally-Distributed Database:
|
|
|
- [praca (pdf)](http://static.googleusercontent.com/media/research.google.com/en//archive/spanner-osdi2012.pdf)
|
|
|
- [film](https://www.usenix.org/node/170855)
|
|
|
- [2014: Machine Learning: Wysokooprocentowana karta kredytowa długu technicznego](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43146.pdf)
|
|
|
- [2015: Continuous Pipelines w Google](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43790.pdf)
|
|
|
- [2015: Wysoka dostępność na masową skalę: budowanie infrastruktury danych Google dla reklam](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/44686.pdf)
|
|
|
- [2015: TensorFlow: Wielkoskalowe uczenie maszynowe w heterogenicznych systemach rozproszonych](http://download.tensorflow.org/paper/whitepaper2015.pdf )
|
|
|
- [2015: Jak programiści szukają kodu: studium przypadku](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/43835.pdf)
|
|
|
- [2016: Borg, Omega oraz Kubernetes](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/44843.pdf)
|
|
|
|
|
|
|
|
|
## LICENCJA
|
|
|
|
|
|
[CC-BY-SA-4.0](./LICENSE.txt)
|
|
|
|
|
|
Polska wersja od: @[mbiesiad](https://github.com/mbiesiad)
|