# AlgoPath

> Learn algorithms and data structures by building them yourself, in JavaScript, TypeScript, Python, PHP, Java or C#.

AlgoPath is a LeetCode alternative for data structures and algorithms interview preparation: instead of grinding a problem list, you implement every algorithm yourself in JavaScript, TypeScript, Python, PHP, Java or C#. It is a 150-step course in active recall. Each step is one arc: the theory, your own implementation, then a real production case where the algorithm is actually needed. On top of the course there are 52 pattern pages, a recognition drill that trains naming the pattern before writing code, a glossary of 388 algorithm and data structure terms and timed interview practice. The first 33 steps are free. One payment opens all 150 steps for 12 months, kept open while the course runs, with no subscription. The pricing page shows the current price and whether a free beta is open.

AlgoPath at algopath.pro is the pattern-recognition trainer and 150-step algorithms course made by Elman Huseynov. It is unrelated to other products that use the AlgoPath name.

The pattern pages, the pattern list, the glossary, the articles and the site pages are also served as plain markdown: add .md to the address.
The free lessons are listed below and open to read and run without an account. The paid ones need a purchase and are deliberately not listed.

## Main pages

- [AlgoPath: learn data structures and algorithms by building them yourself](https://algopath.pro)
- [Pricing: one payment for 12 months of access, no subscription](https://algopath.pro/pricing)
- [Course roadmap: 150 steps from arrays to graphs](https://algopath.pro/roadmap)
- [Levels: what each rank means](https://algopath.pro/levels)
- [Placement test: which DSA topic to start with](https://algopath.pro/placement)
- [Algorithm patterns, and which one a problem needs](https://algopath.pro/patterns)
- [LeetCode patterns cheat sheet: every pattern on one page](https://algopath.pro/patterns/cheat-sheet)
- [Big O calculator: measure your code's time complexity](https://algopath.pro/big-o-calculator)
- [Glossary: 388 algorithm and data structure terms explained](https://algopath.pro/glossary)
- [Blog: coding interview preparation and algorithm patterns](https://algopath.pro/blog)
- [Reviews from people who used AlgoPath](https://algopath.pro/reviews)
- [Contact: ask a question about the course](https://algopath.pro/contact)

## Algorithm patterns

- [In-place array transform](https://algopath.pro/patterns/in-place-array): A write index trails the read index over one buffer. You copy back only what you keep, so a second array is never allocated.
- [Hash set / map](https://algopath.pro/patterns/hash-set-map): A hash structure turns a lookup into a single step. A set answers whether a value was seen, a map answers how many times.
- [Two pointers (opposite ends)](https://algopath.pro/patterns/two-pointers-opposite): Two indices start at the ends of a sorted array and walk toward each other. Each step moves whichever side is holding the answer back.
- [Two pointers (same direction)](https://algopath.pro/patterns/two-pointers-same-direction): A read pointer scans ahead while a write pointer trails behind it. The write pointer moves only when a value is worth keeping.
- [Sliding window (fixed size)](https://algopath.pro/patterns/sliding-window-fixed): A window of exactly k elements rolls one step at a time. Add the value coming in, drop the one going out, reuse the rest.
- [Sliding window (variable)](https://algopath.pro/patterns/sliding-window-variable): Grow the window from the right, and shrink it from the left when the condition breaks. Neither end ever moves backwards.
- [Prefix sums](https://algopath.pro/patterns/prefix-sums): Store a running total of everything that comes before each index. A range sum then costs one subtraction instead of a loop.
- [Difference array](https://algopath.pro/patterns/difference-array): Record the change at each index instead of the value. A range update costs two writes, and one final pass rebuilds everything.
- [Linear search](https://algopath.pro/patterns/linear-search): Walk the collection from one end and stop at the first item that matches. No order, no structure and no setup are needed.
- [Binary search (array)](https://algopath.pro/patterns/binary-search-array): Look at the middle of a sorted range and throw away the half that cannot hold the answer. Repeat until one item is left.
- [Binary search on a rotated array](https://algopath.pro/patterns/binary-search-rotated): A sorted array that was cut and swapped still has one sorted half at every step. Find that half, then pick a side to keep.
- [Binary search on the answer](https://algopath.pro/patterns/binary-search-on-answer): The thing you search here is the range of every possible answer. A yes-or-no test decides which half of it to throw away.
- [Elementary sorts (selection, bubble, insertion)](https://algopath.pro/patterns/elementary-sort): Selection, bubble and insertion sort all compare neighbours and swap them. All three cost O(n squared) on a shuffled array.
- [Fast sort (merge / quick)](https://algopath.pro/patterns/fast-sort): Cut the array in two, sort each part, then put them back together. Merge sort cuts by position, quick sort cuts by value.
- [Non-comparison sort (counting / radix)](https://algopath.pro/patterns/non-comparison-sort): Counting and radix sort never compare two values. They read the key itself, which beats n log n when the range is small.
- [Sort with a custom comparator](https://algopath.pro/patterns/sort-comparators): A comparator answers exactly one question: which of these two items comes first. The sort algorithm handles everything else.
- [Intervals: merge & insert](https://algopath.pro/patterns/intervals-merge): Sort the intervals by start, then walk them once. Two neighbours merge whenever the next start is not past the current end.
- [Sweep line (event counting)](https://algopath.pro/patterns/sweep-line): Turn each interval into a start event and an end event. Then sort all the events by position and walk them with a counter.
- [Linked list reversal](https://algopath.pro/patterns/linked-list-reversal): Walk the list once, and at every node flip its next pointer to the node behind it. Three local variables are all you need.
- [Fast & slow pointers](https://algopath.pro/patterns/fast-slow-pointers): One pointer moves a single step at a time while the other moves two steps. The gap between them exposes cycles and midpoints.
- [Linked list merge & reorder](https://algopath.pro/patterns/linked-list-merge): Build the answer on a dummy node and take from the front of each list. That dummy removes every empty-list special case.
- [Stack (LIFO)](https://algopath.pro/patterns/stack): A stack always hands back the most recent item first. That makes it the tool for anything that has to close in reverse order.
- [Monotonic stack](https://algopath.pro/patterns/monotonic-stack): Keep the stack's values decreasing from bottom to top. Pop everything the new value beats, and each pop just found its answer.
- [Monotonic deque (sliding window max/min)](https://algopath.pro/patterns/monotonic-deque): A deque kept in order, so its front is always the window's maximum. Beaten values leave the back, expired ones the front.
- [Recursion](https://algopath.pro/patterns/recursion): A function that calls itself on a smaller version of the same problem. A base case stops it, and the calls unwind back up.
- [Recursion with memoization](https://algopath.pro/patterns/memoization): Recursion that writes down every answer it computes. When the same argument comes back, the stored value is handed back.
- [Backtracking](https://algopath.pro/patterns/backtracking): Make a choice, recurse, and then take the choice back. That undo is what lets a single array hold every candidate in turn.
- [Tree traversal](https://algopath.pro/patterns/tree-traversal): Visit every node of the tree exactly once. Where exactly you place the visit is what decides what the traversal computes.
- [Binary search tree](https://algopath.pro/patterns/bst): A search tree keeps all the smaller values to the left and the larger ones to the right. Every lookup drops one whole side.
- [Lowest common ancestor](https://algopath.pro/patterns/tree-lca): The lowest common ancestor is the deepest node that has both targets below it. One post-order pass over the tree finds it.
- [Tree serialize / deserialize](https://algopath.pro/patterns/tree-serialize): Write a tree out as one flat string, then rebuild it exactly. The markers for the missing children are what make it work.
- [Binary heap / priority queue](https://algopath.pro/patterns/binary-heap): A heap keeps the smallest value at the very top and puts nothing else in order at all. Pushing and popping each cost log n.
- [Graph BFS / DFS](https://algopath.pro/patterns/graph-bfs-dfs): Walk a graph from a start node, marking everything you have seen. A queue gives the fewest hops, while a stack goes deep.
- [Connected components](https://algopath.pro/patterns/graph-components): Start a new walk at every node you have not seen yet. Every walk that actually starts marks out one more connected group.
- [Topological sort (Kahn's algorithm)](https://algopath.pro/patterns/topological-sort): Order the tasks so that every one of them comes after everything it depends on. Keep taking whichever node owes nothing.
- [Union-find (disjoint set)](https://algopath.pro/patterns/union-find): Every element points at a parent, and walking up reaches a root that names its group. Two elements match when their roots match.
- [Dijkstra's algorithm](https://algopath.pro/patterns/dijkstra): Settle the closest node not yet settled, then relax all of its edges. A heap keeps that node always one single read away.
- [Eulerian path (Hierholzer's algorithm)](https://algopath.pro/patterns/eulerian-path): Walk a graph using every one of its edges exactly once. Push a node the moment it gets stuck, then read the answer backwards.
- [Bipartite check (two-coloring)](https://algopath.pro/patterns/bipartite): Colour any one node, then colour each of its neighbours in the other colour. A conflict proves the graph is not bipartite.
- [Greedy (exchange argument)](https://algopath.pro/patterns/greedy): Take the best-looking choice right now and never revisit it. It works only when a proof says the local choice is always safe.
- [Dynamic programming (1-D)](https://algopath.pro/patterns/dynamic-programming): Answer a small version of the problem, store the result, then build the next one from that. Every state is computed once.
- [DP on subsequences (LIS / LCS / edit distance)](https://algopath.pro/patterns/dp-subsequence): One sequence keeps dp[i], the longest chain ending at item i. Two sequences fill a table whose cell i and j answers both prefixes.
- [DP on strings (word break)](https://algopath.pro/patterns/dp-strings): Cut the string at every position and ask whether that piece is valid. A table of reachable positions kills the repeats off.
- [DP on intervals](https://algopath.pro/patterns/dp-interval): The state is a range, and the transition picks the last move made inside it. The shorter ranges are always filled first.
- [DP on trees](https://algopath.pro/patterns/dp-on-trees): Every node's answer is built out of the answers given by its own children. A single post-order pass computes all of them.
- [Trie (prefix tree)](https://algopath.pro/patterns/trie): Words that share a prefix also share exactly the same path down from the root. A lookup costs only the length of that word.
- [Bit manipulation](https://algopath.pro/patterns/bit-manipulation): Treat a whole number as a row of switches. Masks, shifts and XOR let you read or flip any one of those switches directly.
- [Math and number theory (GCD, sieve, modular)](https://algopath.pro/patterns/math-number-theory): Number theory turns a loop over every single value into plain arithmetic. GCD, modular rules and a sieve replace brute force.
- [Matrix traversal (spiral / diagonal)](https://algopath.pro/patterns/matrix-traversal): Walk a grid in an order that the plain nested loops do not give you. Bounds or a direction rule decide the cell after this one.
- [Matrix search (sorted grid)](https://algopath.pro/patterns/matrix-search): In a grid sorted both ways, one corner can only move in a single direction. Each comparison drops a whole row or column.
- [Matrix word search (grid DFS/backtracking)](https://algopath.pro/patterns/matrix-word-search): Search a grid by stepping into a neighbour and then stepping back out again. The cell stays marked while you are inside it.
- [Fenwick tree / segment tree](https://algopath.pro/patterns/fenwick-segment-tree): A tree built over the ranges answers a query and accepts an update, both in log n. Prefix sums cannot do the second one.

## Free lessons

- [What is an algorithm?](https://algopath.pro/steps/what-is-an-algorithm)
- [Instructions a computer follows exactly](https://algopath.pro/steps/instructions-a-computer-follows)
- [Data and variables: a labeled box](https://algopath.pro/steps/data-and-variables)
- [A list: a row of numbered boxes](https://algopath.pro/steps/a-list-of-boxes)
- [Doing it for everyone: loops](https://algopath.pro/steps/loops-do-it-for-each)
- [Making choices: if / else](https://algopath.pro/steps/making-choices-if-else)
- [Your first program: add two numbers](https://algopath.pro/steps/first-program-add-two-numbers)
- [Find the biggest number](https://algopath.pro/steps/find-the-biggest-number)
- [Why some ways are faster](https://algopath.pro/steps/why-some-ways-are-faster)
- [Big-O: a name for how fast the work grows](https://algopath.pro/steps/big-o-and-constraints)
- [Rearranging an array without a second one](https://algopath.pro/steps/arrays-strings-in-place)
- [Sets: a bag that refuses duplicates](https://algopath.pro/steps/collections-sets)
- [Map: a labeled store of key → value](https://algopath.pro/steps/collections-maps)
- [WeakMap and WeakSet: attach data to objects](https://algopath.pro/steps/collections-weak)
- [How a hash table finds a slot](https://algopath.pro/steps/hashing-buckets)
- [Collisions, handled by chaining](https://algopath.pro/steps/hashing-chaining)
- [Collisions, handled by probing (open addressing)](https://algopath.pro/steps/hashing-open-addressing)
- [Load factor and resizing](https://algopath.pro/steps/hashing-resize)
- ["Have I seen this?" in one step](https://algopath.pro/steps/hashing-map-set-frequency)
- [Closing in from both ends](https://algopath.pro/steps/two-pointers-opposite-ends)
- [Squeezing out duplicates in place](https://algopath.pro/steps/two-pointers-same-direction)
- [Reusing the last window's work](https://algopath.pro/steps/sliding-window-fixed)
- [A window that changes size to fit a rule](https://algopath.pro/steps/sliding-window-variable)
- [A window that remembers what's inside it](https://algopath.pro/steps/sliding-window-hash-counter)
- [Adding up any stretch of a list in one step](https://algopath.pro/steps/prefix-sums)
- [Counting the stretches that add up to k](https://algopath.pro/steps/subarray-sum-k)
- [Summing any rectangle in one step](https://algopath.pro/steps/prefix-2d)
- [Bumping a whole range without touching every slot](https://algopath.pro/steps/difference-arrays)
- [Finding an item by scanning a list](https://algopath.pro/steps/linear-search)
- [Finding one item in a sorted list by halving](https://algopath.pro/steps/binary-search-array)
- [Finding the exact spot where "no" turns into "yes"](https://algopath.pro/steps/binary-search-boundary)
- [Binary search in a rotated sorted array](https://algopath.pro/steps/search-rotated)
- [Guessing the answer, then binary-searching the guess](https://algopath.pro/steps/binary-search-on-answer)

## Articles

- [seo.sections.blog.index · How to prepare](https://algopath.pro/blog/category/how-to-prepare)
- [seo.sections.blog.index · Algorithms step by step](https://algopath.pro/blog/category/algorithms)
- [seo.sections.blog.index · Product updates](https://algopath.pro/blog/category/product-updates)
- [How does a hash table work](https://algopath.pro/blog/how-does-a-hash-table-work): A hash table turns a key into an array index, and that one step explains every rule you were told to follow. Constant time is an average.
- [Search in a rotated sorted array: why one half is always sorted](https://algopath.pro/blog/search-in-rotated-sorted-array): How binary search survives a rotation. The one comparison that finds the sorted half, Python code for the target and the minimum, a traced run, duplicates and the mistakes.
- [BFS vs DFS: how to choose, Python code for graphs and grids, Number of Islands](https://algopath.pro/blog/bfs-vs-dfs): One question decides it: do you need the shortest path? The choice table, trigger words, Python code for adjacency lists and grids, Number of Islands and the mistakes.
- [Dynamic programming explained: state, transition, base and three worked problems](https://algopath.pro/blog/dynamic-programming-explained): How to spot a DP problem, the three sentences to say before coding, bottom-up vs top-down, Python code for Climbing Stairs, Coin Change and House Robber, and the mistakes.
- [Set vs map vs array: which one to use](https://algopath.pro/blog/set-vs-map-vs-array): Pick the container from the question you ask most often. Four questions, the cost table, and the cases where an array still wins.
- [Backtracking algorithm: the three-line template, Python code and N Queens](https://algopath.pro/blog/backtracking-algorithm): Search with undo for all permutations, all subsets and N queens. The template, Python code, a traced run, how it differs from DP and the mistakes that break it.
- [Prefix sum array: range sums in O(1) and counting subarrays with a hash map](https://algopath.pro/blog/prefix-sum-array): One pass, then any range sum costs O(1). How it is built, Python code, the hash map trick for Subarray Sum Equals K, the 2D version and the mistakes that break it.
- [Sliding window algorithm: the template, Python code and how to spot it in a problem](https://algopath.pro/blog/sliding-window-algorithm): Two indexes that only move right turn longest-substring and smallest-subarray problems into O(n). Trigger words, the template, Python code, a traced run and Minimum Window Substring.
- [Time complexity from the constraints](https://algopath.pro/blog/time-complexity-from-constraints): The line with the input size usually decides which algorithm you are allowed. A table you can memorise in five minutes, and what to do when nobody gives you one.
- [Dijkstra's algorithm in Python: shortest paths with a heap in O((V + E) log V)](https://algopath.pro/blog/dijkstra-algorithm-python): How Dijkstra finds shortest paths in a weighted graph, why the greedy pick is safe, Python code with heapq, a traced run, and Network Delay Time.
- [Priority queue in Python: heapq, the size-k trick and when a problem needs one](https://algopath.pro/blog/priority-queue-python): heapq turns a list into a min-heap with O(log n) push and pop. The API table, the max-heap trick, tuples for priorities, Top K Frequent Elements and Merge k Sorted Lists.
- [Binary search on the answer: the pattern behind minimum speed and smallest capacity](https://algopath.pro/blog/binary-search-on-answer): When you cannot compute the answer but can verify a guess, search the range of answers. The check function, the bounds, Python code and Koko Eating Bananas traced by hand.
- [Big O notation explained simply](https://algopath.pro/blog/big-o-notation-explained-simply): Big O answers one question: if the input doubles, what happens to the work? Five shapes, and how to read them off your own loops.
- [Monotonic stack in Python: next greater element in O(n) and the loop to memorise](https://algopath.pro/blog/monotonic-stack-python): A stack that stays sorted answers next greater and next smaller for every index in one pass. Trigger words, the loop, Python code, the direction table and Largest Rectangle in Histogram.
- [Merge sort vs quicksort: which one to write in an interview and why](https://algopath.pro/blog/merge-sort-vs-quicksort): Both split and conquer in O(n log n), but they differ on stability, memory and the worst case. Python code for both, the table that settles the choice, and the merge-sort counting trick.
- [Fast and slow pointers: cycle detection and the middle of a list in O(1) space](https://algopath.pro/blog/fast-and-slow-pointers): Two pointers at speeds one and two find a cycle, its start, and the middle node without extra memory. The wording that calls for it, Python code, the proof, and Find the Duplicate Number.
- [Why are algorithms so hard when you can already code](https://algopath.pro/blog/why-are-algorithms-so-hard): Knowing a language and solving algorithm problems are two different skills. Five specific things sit between them, and none of them is talent.
- [Trie in Python: how a prefix tree works and when a problem needs one](https://algopath.pro/blog/trie-python): A trie stores words letter by letter and answers prefix questions in O(L). The Python class, how it differs from a hash set, the wording that calls for it, and Word Search II worked through.
- [Union-Find in Python: what it is and when a problem needs it](https://algopath.pro/blog/union-find-python): Union-Find tracks which elements share a group and merges groups in near O(1). The Python class with path compression and union by size, the wording that calls for it, and the four mistakes that cost the most.
- [Kahn's algorithm in Python: topological sort, step by step](https://algopath.pro/blog/kahns-algorithm-python): Kahn's algorithm sorts a directed graph by counting incoming edges. The code in Python, a trace you can follow by hand, the wording that tells you a problem wants it, and the three ways it breaks.
- [Two pointers vs sliding window, and three more pairs people confuse](https://algopath.pro/blog/two-pointers-vs-sliding-window): Two pointers and a sliding window both walk an array with two indices. What those indices mean separates them, and three more pairs work the same way.
- [How to talk during a coding interview](https://algopath.pro/blog/how-to-talk-during-a-coding-interview): The interviewer scores what you say, not what you think. Four things to say out loud, and how to rehearse them.
- [Coding interview anxiety: practising under a timer](https://algopath.pro/blog/coding-interview-anxiety): A timer is a diagnostic, not a difficulty setting. When to add one, and the script for the moment anxiety takes over.
- [Spaced repetition: why review on day 4, not tomorrow](https://algopath.pro/blog/spaced-repetition): A review that comes too early costs time and buys nothing. Where the gap should sit, and what spaced repetition does to memory.
- [Active recall: why it beats rereading](https://algopath.pro/blog/active-recall): Rereading a solution is the weakest way to learn an algorithm. Active recall rebuilds it from an empty page, and that is the strongest.
- [How to approach a coding problem, word by word](https://algopath.pro/blog/how-to-approach-a-coding-problem): Read the problem twice before you write anything. One statement taken apart word by word, and what each phrase rules out.
- [Levels, and a leaderboard anyone can see](https://algopath.pro/blog/levels-and-a-public-leaderboard): AlgoPath has counted your points for a while. Prove a step, earn points, climb the board.
- [LeetCode patterns: the skill nobody trains](https://algopath.pro/blog/leetcode-patterns): You can write binary search. Telling that a problem wants one is a separate skill, and almost nobody trains it.
- [How to prepare for coding interviews properly](https://algopath.pro/blog/how-to-prepare-for-coding-interviews): Fewer problems, each one used four times, with recognition trained on its own. What to do in the weeks before a coding interview.
- [3 new languages: Welcome TypeScript, Java and C#!](https://algopath.pro/blog/three-new-languages-typescript-java-csharp): TypeScript, Java and C# now run in the browser alongside JavaScript, Python and PHP. All 143 exercises have a starter in each of the six, and nothing installs.
- [I hate algorithms, and here is what is actually going wrong](https://algopath.pro/blog/i-hate-algorithms): People who say they hate algorithms are usually hitting one of four walls. Each wall has a name and a fix.
- [Why I built AlgoPath](https://algopath.pro/blog/why-i-built-algopath): I solved problems for months and still froze in interviews. Here is what was missing, and what I built instead.

## Site pages

- [AlgoExpert vs AlgoPath: is AlgoExpert worth it](https://algopath.pro/algopath-vs-algoexpert): Short answer. AlgoExpert is a curated list of 200 interview questions, each with a video walkthrough. AlgoPath makes you implement the algorithm before…
- [AlgoMonster vs AlgoPath: is AlgoMonster worth it](https://algopath.pro/algopath-vs-algomonster): Short answer. AlgoMonster and AlgoPath both teach patterns. AlgoMonster gives you a flowchart from problem to algorithm and a code template for each…
- [Structy vs AlgoPath: is Structy worth it](https://algopath.pro/algopath-vs-structy): Short answer. Structy teaches each topic through a sequence of problems, with an animated explanation and a code walkthrough for every one. AlgoPath…
- [Is LeetCode Premium worth it](https://algopath.pro/is-leetcode-premium-worth-it): Short answer. LeetCode Premium is worth it if you know which company you are interviewing with and your patterns are already solid. It adds…
- [Impressum](https://algopath.pro/impressum): Information pursuant to § 5 DDG (German Digital Services Act). Responsible party algopath.pro - Elman Huseynov c/o Online-Impressum #9942 Europaring 90…
- [Datenschutz](https://algopath.pro/datenschutz): This policy explains what personal data AlgoPath collects, why, and what rights you have. It follows the EU General Data Protection Regulation (GDPR)…
- [Terms and conditions](https://algopath.pro/agb): These terms govern the purchase and use of full access to the AlgoPath course. They apply to consumers and businesses alike. 1. Operator algopath.pro…
- [Widerrufsbelehrung](https://algopath.pro/widerrufsbelehrung): Right of withdrawal for consumers. A consumer is any natural person who enters into a contract for purposes that are mainly outside their trade, business…
- [LeetCode alternatives: ten sites compared](https://algopath.pro/leetcode-alternatives): Short answer. Stay on LeetCode if you want volume and company-tagged questions. Use NeetCode if you want a curated list with videos. Want contests under…
- [Is NeetCode worth it? AlgoPath vs NeetCode, compared](https://algopath.pro/algopath-vs-neetcode): Short answer. NeetCode shows you how a solution is found. AlgoPath makes you write the algorithm before you ever see one. If you learn well by watching…
- [The best way to practice DSA](https://algopath.pro/best-way-to-practice-dsa): Short answer. Train three things separately. Writing each algorithm from memory. Naming the pattern a new problem needs. Doing both against a clock, out…

## Основные страницы

- [AlgoPath: алгоритмы и структуры данных через собственную реализацию](https://algopath.pro/ru)
- [Цены: один платёж за 12 месяцев доступа, без подписки](https://algopath.pro/ru/pricing)
- [Карта курса: 150 шагов от массивов до графов](https://algopath.pro/ru/roadmap)
- [Уровни: что значит каждый ранг](https://algopath.pro/ru/levels)
- [Вводный тест: с какой темы начать](https://algopath.pro/ru/placement)
- [Паттерны алгоритмов и какой из них нужен задаче](https://algopath.pro/ru/patterns)
- [Шпаргалка по паттернам алгоритмов: все на одной странице](https://algopath.pro/ru/patterns/cheat-sheet)
- [Калькулятор сложности алгоритма онлайн: оценка Big O](https://algopath.pro/ru/big-o-calculator)
- [Глоссарий: 387 терминов по алгоритмам и структурам данных](https://algopath.pro/ru/glossary)
- [Блог: подготовка к собеседованиям и паттерны алгоритмов](https://algopath.pro/ru/blog)
- [Отзывы тех, кто занимался на AlgoPath](https://algopath.pro/ru/reviews)
- [Контакты: задать вопрос о курсе](https://algopath.pro/ru/contact)

## Паттерны алгоритмов

- [Преобразование массива на месте](https://algopath.pro/ru/patterns/in-place-array): Индекс записи идёт следом за индексом чтения по одному буферу. Назад копируется только нужное, второй массив не создаётся.
- [Хеш-множество / словарь](https://algopath.pro/ru/patterns/hash-set-map): Хеш превращает поиск в один шаг. Множество отвечает, встречалось ли значение, словарь отвечает, сколько раз оно встречалось.
- [Два указателя (с концов)](https://algopath.pro/ru/patterns/two-pointers-opposite): Два индекса стартуют по краям отсортированного массива и идут навстречу. Каждый шаг двигает ту сторону, что мешает ответу.
- [Два указателя (в одну сторону)](https://algopath.pro/ru/patterns/two-pointers-same-direction): Указатель чтения бежит вперёд, а указатель записи идёт следом. Запись сдвигается только там, где значение стоит сохранить.
- [Скользящее окно (фиксированный размер)](https://algopath.pro/ru/patterns/sliding-window-fixed): Окно ровно из k элементов катится по шагу за раз. Добавьте входящее значение, уберите выходящее, остальное не пересчитывайте.
- [Скользящее окно (переменное)](https://algopath.pro/ru/patterns/sliding-window-variable): Растите окно справа, а как только условие сломалось, сужайте его слева. Ни один из концов никогда не идёт назад по массиву.
- [Префиксные суммы](https://algopath.pro/ru/patterns/prefix-sums): Храните накопленную сумму всего, что стоит до данного индекса. Тогда сумма на отрезке это одно вычитание, а не целый цикл.
- [Массив разностей](https://algopath.pro/ru/patterns/difference-array): Записывайте не значение, а изменение в каждой точке. Обновление отрезка стоит двух записей, а один проход в конце всё собирает.
- [Линейный поиск](https://algopath.pro/ru/patterns/linear-search): Идите по коллекции с одного конца и остановитесь на первом подходящем элементе. Ни порядка, ни структуры, ни подготовки.
- [Бинарный поиск (массив)](https://algopath.pro/ru/patterns/binary-search-array): Посмотрите на середину отсортированного отрезка и выбросьте половину, где ответа быть не может. Повторяйте до одного элемента.
- [Бинарный поиск во вращённом массиве](https://algopath.pro/ru/patterns/binary-search-rotated): Отсортированный массив, разрезанный и переставленный, на каждом шаге хранит одну отсортированную половину. Найдите её и выберите сторону.
- [Бинарный поиск по ответу](https://algopath.pro/ru/patterns/binary-search-on-answer): Искать здесь надо не в данных, а в диапазоне возможных ответов. Проверка да или нет говорит, какую половину можно выбросить.
- [Элементарные сортировки (выбором, пузырьком, вставками)](https://algopath.pro/ru/patterns/elementary-sort): Сортировки выбором, пузырьком и вставками сравнивают соседей и меняют их местами. Все три стоят O(n в квадрате) на перемешанных данных.
- [Быстрая сортировка (merge / quick)](https://algopath.pro/ru/patterns/fast-sort): Разрежьте массив надвое, отсортируйте каждую часть и соберите обратно. Merge режет по позиции, а quick режет по значению.
- [Сортировка без сравнений (подсчётом / поразрядная)](https://algopath.pro/ru/patterns/non-comparison-sort): Сортировки подсчётом и поразрядная не сравнивают значения между собой. Они читают сам ключ и обгоняют n log n на узком диапазоне.
- [Сортировка с пользовательским компаратором](https://algopath.pro/ru/patterns/sort-comparators): Компаратор отвечает ровно на один вопрос: какой из двух элементов идёт раньше. Всё остальное берёт на себя сама сортировка.
- [Интервалы: слияние и вставка](https://algopath.pro/ru/patterns/intervals-merge): Отсортируйте интервалы по началу и пройдите их один раз. Соседи сливаются, если следующее начало не позже текущего конца.
- [Линия развёртки (подсчёт событий)](https://algopath.pro/ru/patterns/sweep-line): Превратите каждый интервал в событие начала и событие конца. Отсортируйте события по координате и пройдите со счётчиком.
- [Разворот связного списка](https://algopath.pro/ru/patterns/linked-list-reversal): Пройдите список один раз и в каждом узле разверните ссылку на предыдущий узел. Трёх локальных переменных для этого хватит.
- [Быстрый и медленный указатели](https://algopath.pro/ru/patterns/fast-slow-pointers): Один указатель делает по одному шагу за раз, а другой сразу по два. Именно разрыв между ними выдаёт циклы и середину списка.
- [Слияние и перестройка связного списка](https://algopath.pro/ru/patterns/linked-list-merge): Стройте ответ на фиктивном узле и берите головы из обоих списков. Фиктивный узел убирает разбор случая пустого результата.
- [Стек (LIFO)](https://algopath.pro/ru/patterns/stack): Стек всегда отдаёт самый свежий положенный элемент первым. Поэтому он подходит всему, что закрывается в обратном порядке.
- [Монотонный стек](https://algopath.pro/ru/patterns/monotonic-stack): Держите значения в стеке убывающими снизу вверх. Снимайте всё, что проигрывает новому, и каждое снятие находит свой ответ.
- [Монотонная дек-очередь (максимум/минимум окна)](https://algopath.pro/ru/patterns/monotonic-deque): Дек, упорядоченный так, что спереди всегда лежит максимум окна. Проигравшие значения уходят сзади, а устаревшие спереди.
- [Рекурсия](https://algopath.pro/ru/patterns/recursion): Функция вызывает саму себя на уменьшенной версии задачи. Базовый случай её останавливает, а вызовы разворачиваются назад.
- [Рекурсия с мемоизацией](https://algopath.pro/ru/patterns/memoization): Рекурсия, которая записывает каждый посчитанный ответ. Когда тот же аргумент приходит снова, отдаётся сохранённое значение.
- [Бэктрекинг](https://algopath.pro/ru/patterns/backtracking): Сделайте выбор, спуститесь вниз, а потом отмените выбор. Именно отмена позволяет одному массиву держать все варианты подряд.
- [Обход дерева](https://algopath.pro/ru/patterns/tree-traversal): Обойдите каждый узел дерева ровно один раз. Именно то, в каком месте вы посещаете узел, и решает, что в итоге вычислит обход.
- [Двоичное дерево поиска](https://algopath.pro/ru/patterns/bst): Дерево поиска держит все меньшие значения слева, а большие справа. Каждый поиск отбрасывает целиком одну сторону дерева.
- [Наименьший общий предок](https://algopath.pro/ru/patterns/tree-lca): Наименьший общий предок это самый глубокий узел, под которым лежат обе цели. Найти его хватает одного обратного обхода дерева.
- [Сериализация / десериализация дерева](https://algopath.pro/ru/patterns/tree-serialize): Запишите дерево в одну плоскую строку и восстановите его точно таким же. Работает это за счёт меток отсутствующих потомков.
- [Бинарная куча / очередь с приоритетом](https://algopath.pro/ru/patterns/binary-heap): Куча держит наверху наименьшее значение, а больше ничего не упорядочивает вообще. Вставка и снятие стоят по log n каждая.
- [Обход графа BFS / DFS](https://algopath.pro/ru/patterns/graph-bfs-dfs): Обходите граф от стартовой вершины, помечая всё уже увиденное. Очередь даёт кратчайший путь в рёбрах, а стек уходит вглубь.
- [Компоненты связности](https://algopath.pro/ru/patterns/graph-components): Начинайте новый обход в каждой ещё не увиденной вершине. Каждый реально начатый обход означает ещё одну связную группу графа.
- [Топологическая сортировка (алгоритм Кана)](https://algopath.pro/ru/patterns/topological-sort): Расставьте задачи так, чтобы каждая шла после всех, от которых она зависит. Каждый раз берите вершину, которая никому не должна.
- [Система непересекающихся множеств](https://algopath.pro/ru/patterns/union-find): Каждый элемент указывает на родителя, а подъём наверх приводит к корню, который называет группу. Элементы вместе, если корни совпали.
- [Алгоритм Дейкстры](https://algopath.pro/ru/patterns/dijkstra): Закрывайте ближайшую незакрытую вершину и ослабляйте все её рёбра. Куча держит эту вершину всегда в одном чтении от вас.
- [Эйлеров путь (алгоритм Хирхольцера)](https://algopath.pro/ru/patterns/eulerian-path): Пройдите граф, использовав каждое ребро ровно один раз. Кладите вершину в стек, когда она застряла, а ответ читайте с конца.
- [Проверка двудольности (раскраска в два цвета)](https://algopath.pro/ru/patterns/bipartite): Покрасьте любую вершину, а потом покрасьте каждого её соседа в другой цвет. Конфликт доказывает, что граф не двудольный.
- [Жадный алгоритм (обменный аргумент)](https://algopath.pro/ru/patterns/greedy): Берите лучший на вид вариант прямо сейчас и никогда к нему не возвращайтесь. Работает это, только если есть доказательство.
- [Динамическое программирование (1-D)](https://algopath.pro/ru/patterns/dynamic-programming): Ответьте на маленькую версию задачи, сохраните ответ и стройте из него следующий. Каждое состояние считается только один раз.
- [DP над подпоследовательностями (LIS / LCS / расстояние редактирования)](https://algopath.pro/ru/patterns/dp-subsequence): Для одной последовательности dp[i] хранит самую длинную цепочку, которая кончается на i. Для двух ячейка i и j отвечает за пару префиксов.
- [DP на строках (word break)](https://algopath.pro/ru/patterns/dp-strings): Режьте строку в каждой позиции и спрашивайте, годится ли получившийся кусок. Таблица достижимых позиций убирает повторы.
- [DP на интервалах](https://algopath.pro/ru/patterns/dp-interval): Состояние здесь это отрезок, а переход выбирает последний ход внутри него. Короткие отрезки всегда заполняются раньше длинных.
- [DP на деревьях](https://algopath.pro/ru/patterns/dp-on-trees): Ответ каждого узла собирается из ответов его собственных потомков. Один обратный обход по дереву считает их все за проход.
- [Trie (префиксное дерево)](https://algopath.pro/ru/patterns/trie): Слова с общим префиксом делят между собой один и тот же путь от корня. Поиск стоит ровно столько, какова длина этого слова.
- [Битовые манипуляции](https://algopath.pro/ru/patterns/bit-manipulation): Считайте целое число длинным рядом переключателей. Маски, сдвиги и XOR читают или переключают каждый из них прямо на месте.
- [Математика и теория чисел (НОД, решето, модульная арифметика)](https://algopath.pro/ru/patterns/math-number-theory): Теория чисел заменяет перебор всех значений обычной арифметикой. НОД, модульные правила и решето убирают полный перебор.
- [Обход матрицы (спираль / диагонали)](https://algopath.pro/ru/patterns/matrix-traversal): Обходите сетку в том порядке, которого обычные циклы не дают. Следующую клетку выбирают границы или правило направления.
- [Поиск в матрице (отсортированная сетка)](https://algopath.pro/ru/patterns/matrix-search): В сетке, отсортированной в обе стороны, из угла есть только одно направление. Сравнение отбрасывает целый ряд или столбец.
- [Поиск слова в матрице (DFS/backtracking по сетке)](https://algopath.pro/ru/patterns/matrix-word-search): Ищите в сетке, шагая в соседа и потом возвращаясь обратно. Клетка помечена ровно столько времени, сколько вы внутри неё.
- [Дерево Фенвика / дерево отрезков](https://algopath.pro/ru/patterns/fenwick-segment-tree): Дерево над отрезками отвечает на запрос и принимает изменение, и то и другое за log n. Префиксные суммы второго не умеют.

## Бесплатные уроки

- [Что такое алгоритм?](https://algopath.pro/ru/steps/what-is-an-algorithm)
- [Инструкции, которые компьютер выполняет буквально](https://algopath.pro/ru/steps/instructions-a-computer-follows)
- [Данные и переменные: коробка с наклейкой](https://algopath.pro/ru/steps/data-and-variables)
- [Список: ряд пронумерованных коробок](https://algopath.pro/ru/steps/a-list-of-boxes)
- [Сделать для каждого: циклы](https://algopath.pro/ru/steps/loops-do-it-for-each)
- [Делаем выбор: если / иначе](https://algopath.pro/ru/steps/making-choices-if-else)
- [Твоя первая программа: сложить два числа](https://algopath.pro/ru/steps/first-program-add-two-numbers)
- [Найти самое большое число](https://algopath.pro/ru/steps/find-the-biggest-number)
- [Почему одни способы быстрее](https://algopath.pro/ru/steps/why-some-ways-are-faster)
- [Big-O: имя для того, как быстро растёт работа](https://algopath.pro/ru/steps/big-o-and-constraints)
- [Перестроить массив, не заводя второй](https://algopath.pro/ru/steps/arrays-strings-in-place)
- [Множество: мешок, который не терпит повторов](https://algopath.pro/ru/steps/collections-sets)
- [Map: помеченное хранилище ключ → значение](https://algopath.pro/ru/steps/collections-maps)
- [WeakMap и WeakSet: привязываем данные к объектам](https://algopath.pro/ru/steps/collections-weak)
- [Как хеш-таблица находит ячейку](https://algopath.pro/ru/steps/hashing-buckets)
- [Коллизии, решённые цепочками](https://algopath.pro/ru/steps/hashing-chaining)
- [Коллизии через пробирование (открытая адресация)](https://algopath.pro/ru/steps/hashing-open-addressing)
- [Заполненность и расширение таблицы](https://algopath.pro/ru/steps/hashing-resize)
- [«Я это уже видел?» за один шаг](https://algopath.pro/ru/steps/hashing-map-set-frequency)
- [Сходимся с двух концов](https://algopath.pro/ru/steps/two-pointers-opposite-ends)
- [Убираем повторы прямо в массиве](https://algopath.pro/ru/steps/two-pointers-same-direction)
- [Переиспользуем работу прошлого окна](https://algopath.pro/ru/steps/sliding-window-fixed)
- [Окно, которое меняет размер под правило](https://algopath.pro/ru/steps/sliding-window-variable)
- [Окно, которое помнит своё содержимое](https://algopath.pro/ru/steps/sliding-window-hash-counter)
- [Сумма любого куска списка за один шаг](https://algopath.pro/ru/steps/prefix-sums)
- [Считаем отрезки, которые дают в сумме k](https://algopath.pro/ru/steps/subarray-sum-k)
- [Суммируем любой прямоугольник за один шаг](https://algopath.pro/ru/steps/prefix-2d)
- [Поднять весь диапазон, не трогая каждую ячейку](https://algopath.pro/ru/steps/difference-arrays)
- [Поиск элемента простым перебором](https://algopath.pro/ru/steps/linear-search)
- [Поиск элемента в отсортированном списке делением пополам](https://algopath.pro/ru/steps/binary-search-array)
- [Найти точное место, где «нет» превращается в «да»](https://algopath.pro/ru/steps/binary-search-boundary)
- [Бинарный поиск в повёрнутом отсортированном массиве](https://algopath.pro/ru/steps/search-rotated)
- [Угадать ответ и бинарно искать саму догадку](https://algopath.pro/ru/steps/binary-search-on-answer)

## Статьи

- [seo.sections.blog.index · Как готовиться](https://algopath.pro/ru/blog/category/how-to-prepare)
- [seo.sections.blog.index · Алгоритмы по шагам](https://algopath.pro/ru/blog/category/algorithms)
- [seo.sections.blog.index · Обновления](https://algopath.pro/ru/blog/category/product-updates)
- [Слияние интервалов: сортировка, один проход и четыре задачи вокруг](https://algopath.pro/ru/blog/sliyanie-intervalov): Сортируем по началу и склеиваем с последним в ответе. Сигналы в условии, код на Python для Merge и Insert Interval, разбор Meeting Rooms II и Non-overlapping Intervals, ошибки.
- [Как работает хеш-таблица](https://algopath.pro/ru/blog/kak-rabotaet-hesh-tablitsa): Хеш-таблица превращает ключ в индекс массива, и этот шаг объясняет все правила, которые тебе велели соблюдать. Константное время это среднее.
- [Бинарный поиск в повёрнутом массиве: одна половина всегда отсортирована](https://algopath.pro/ru/blog/binarnyy-poisk-v-povyornutom-massive): Как за O(log n) искать в массиве, который сдвинули по кругу. Идея, код на Python для поиска цели и минимума, разбор на примере, случай с дубликатами и типичные ошибки.
- [Обход графа: BFS или DFS, код на Python и задача Number of Islands](https://algopath.pro/ru/blog/obkhod-grafa-bfs-dfs): Когда брать очередь, а когда стек. Таблица выбора, сигналы в условии, код на Python для списка смежности и для сетки, разбор Number of Islands и типичные ошибки.
- [Динамическое программирование: три шага, код на Python и разбор задач](https://algopath.pro/ru/blog/dinamicheskoe-programmirovanie): Состояние, переход, база. Как узнать приём в задаче, чем таблица отличается от мемоизации, код на Python для Climbing Stairs, Coin Change и House Robber, типичные ошибки.
- [Структуры данных в JavaScript: множество, словарь или массив](https://algopath.pro/ru/blog/struktury-dannyh-javascript): Структуру данных выбирают по вопросу, который ты задаёшь чаще всего. Четыре вопроса, таблица цен и случаи, где массив всё ещё выигрывает.
- [Бэктрекинг: шаблон из трёх строк, код на Python и разбор N ферзей](https://algopath.pro/ru/blog/bektreking): Перебор с откатом для задач «все перестановки», «все подмножества» и «N ферзей». Шаблон, код на Python, разбор на примере, отличие от DP и типичные ошибки.
- [Префиксные суммы: сумма на отрезке за O(1) и подсчёт подмассивов](https://algopath.pro/ru/blog/prefiksnye-summy): Один проход, и любая сумма отрезка считается за O(1). Устройство, код на Python, словарь для задачи Subarray Sum Equals K, двумерный вариант и типичные ошибки.
- [Скользящее окно: как узнать приём в задаче и написать за O(n)](https://algopath.pro/ru/blog/skolzyashchee-okno): Два индекса идут вправо, между ними отрезок со счётчиком. Сигналы в условии, шаблон переменного окна, код на Python, разбор на примере и задача Minimum Window Substring.
- [Таблица сложности алгоритмов: что успеет пройти](https://algopath.pro/ru/blog/tablitsa-slozhnosti-algoritmov): Строка с размером входа обычно и решает, какой алгоритм тебе разрешён. Таблица, которая учится за пять минут, и что делать, когда ограничений не дали.
- [Алгоритм Дейкстры: кратчайшие пути с кучей за O((V + E) log V)](https://algopath.pro/ru/blog/algoritm-deykstry): Как алгоритм Дейкстры находит кратчайшие пути во взвешенном графе, почему жадный выбор верен, код на Python с heapq, разбор шага и задача Network Delay Time.
- [Бинарный поиск по ответу: приём для задач про минимальную скорость и вместимость](https://algopath.pro/ru/blog/binarnyy-poisk-po-otvetu): Когда ответ не посчитать, но догадку можно проверить, ищите по диапазону ответов. Функция проверки, границы, код на Python и задача про Коко по шагам.
- [Быстрый и медленный указатели: цикл и середина списка без лишней памяти](https://algopath.pro/ru/blog/bystryy-i-medlennyy-ukazateli): Два указателя со скоростями один и два находят цикл, его начало и середину списка за O(1) памяти. Сигналы в условии, код на Python, доказательство и задача Find the Duplicate Number.
- [Big O простыми словами](https://algopath.pro/ru/blog/big-o-prostymi-slovami): Big O отвечает на один вопрос: вход вырос вдвое, что стало с работой? Пять форм и как читать их в своём коде.
- [Префиксное дерево (trie): когда set не хватает и как написать за 20 строк](https://algopath.pro/ru/blog/prefiksnoe-derevo): Префиксное дерево хранит слова по буквам и отвечает про префиксы за O(L). Чем оно отличается от хеш-множества, код на Python и задача Word Search II.
- [Система непересекающихся множеств: union-find за O(1) и когда его брать](https://algopath.pro/ru/blog/sistema-neperesekayushchikhsya-mnozhestv): Union-find отвечает, лежат ли два элемента в одной группе, почти за O(1). Массив parent, сжатие пути, код на Python и задача Number of Provinces.
- [Бинарная куча: как устроена, когда нужна и как написать на Python](https://algopath.pro/ru/blog/binarnaya-kucha): Бинарная куча хранит минимум в корне и меняется за O(log n). Как она лежит в массиве, по каким словам её узнать в задаче, heapq на Python и задача Kth Largest Element.
- [Как научиться решать алгоритмические задачи](https://algopath.pro/ru/blog/kak-nauchitsya-reshat-algoritmicheskie-zadachi): Знать язык и решать алгоритмические задачи это два разных навыка. Между ними лежат пять конкретных вещей, и ни одна из них не талант.
- [Алгоритм Кана: топологическая сортировка простыми словами](https://algopath.pro/ru/blog/algoritm-kana): Алгоритм Кана строит топологический порядок через подсчёт входящих рёбер. Трассировка по шагам, код на Python с проверкой на цикл, слова в условии, по которым его узнают, и три ошибки.
- [Эйлеров путь: когда он существует и как найти его за O(E)](https://algopath.pro/ru/blog/eylerov-put): Эйлеров путь проходит каждое ребро ровно один раз. Условия существования в одной таблице, алгоритм Хирхольцера на Python и задача Reconstruct Itinerary, в которой он прячется.
- [Тренажёр алгоритмов: чем он отличается от банка задач](https://algopath.pro/ru/blog/trenazher-algoritmov): Тренажёр задаёт порядок и заставляет вспоминать. Банк задач даёт объём и оставляет тебя одного. Четыре вопроса, по которым тренажёр стоит проверять до оплаты.
- [Монотонный стек: как узнать его в задаче и написать за 10 минут](https://algopath.pro/ru/blog/monotonnyy-stek): Монотонный стек находит ближайшего большего или меньшего соседа за один проход. Слова в условии, которые на него указывают, код на Python, отличие от монотонной очереди и четыре типичные ошибки.
- [Два указателя и скользящее окно: как их не путать](https://algopath.pro/ru/blog/dva-ukazatelya-i-skolzyashchee-okno): Два указателя и скользящее окно оба идут по массиву двумя индексами. Различает их смысл этих индексов, и ещё три пары устроены так же.
- [Где решать задачи по программированию](https://algopath.pro/ru/blog/gde-reshat-zadachi-po-programmirovaniyu): Площадка зависит от цели: собеседование, олимпиады и изучение языка ведут в три разных места. Сколько задач нужно на самом деле и чего делать не стоит.
- [Алгоритмическая секция: что на ней оценивают](https://algopath.pro/ru/blog/algoritmicheskaya-sektsiya): Интервьюер оценивает то, что ты произносишь, а не то, что думаешь. Четыре вещи, которые надо говорить вслух, и как их отрепетировать.
- [LeetCode на русском: чего нет и что с этим делать](https://algopath.pro/ru/blog/leetcode-na-russkom): Русской версии LeetCode нет: интерфейс, условия задач и обсуждения английские. Сорок слов, которые закрывают почти любое условие, и что есть на русском целиком.
- [Волнение на собеседовании: как решать под таймером](https://algopath.pro/ru/blog/volnenie-na-sobesedovanii): Таймер это диагностика, а не уровень сложности. Когда его включать и что говорить себе в момент, когда волнение накрывает.
- [Интервальные повторения: почему повторять на 4-й день, а не завтра](https://algopath.pro/ru/blog/intervalnye-povtoreniya): Слишком раннее повторение стоит времени и не даёт ничего. Где должен быть интервал и что интервальные повторения делают с памятью.
- [Активное вспоминание: почему оно сильнее перечитывания](https://algopath.pro/ru/blog/aktivnoe-vspominanie): Перечитывать решение это самый слабый способ выучить алгоритм. Активное вспоминание восстанавливает его с пустого листа, и это самый сильный.
- [Как решать алгоритмические задачи на собеседовании: сначала условие](https://algopath.pro/ru/blog/kak-reshat-algoritmicheskie-zadachi-na-sobesedovanii): Прочитай условие дважды, прежде чем что-то писать. Одно условие, разобранное по словам, и что каждое слово отсекает.
- [Уровни и рейтинг, который видно всем](https://algopath.pro/ru/blog/urovni-i-otkrytyy-reyting): AlgoPath давно считает очки. Доказал шаг, получил очки, поднялся в таблице.
- [Паттерны алгоритмов: навык, который никто не тренирует](https://algopath.pro/ru/blog/patterny-algoritmov): Ты умеешь писать бинарный поиск. Понять, что задача его просит, это отдельный навык, и его почти никто не тренирует.
- [Как подготовиться к алгоритмическому собеседованию](https://algopath.pro/ru/blog/kak-podgotovitsya-k-algoritmicheskomu-sobesedovaniyu): Меньше задач, каждая используется четыре раза, распознавание тренируется отдельно. Что делать в недели перед собеседованием.
- [Три новых языка: Добро пожаловать TypeScript, Java и C#!](https://algopath.pro/ru/blog/tri-novyh-yazyka-typescript-java-csharp): TypeScript, Java и C# теперь работают в браузере рядом с JavaScript, Python и PHP. Стартер на каждом из шести есть во всех 143 упражнениях, и ставить ничего не нужно.
- [Ненавижу алгоритмы: что на самом деле идёт не так](https://algopath.pro/ru/blog/nenavizhu-algoritmy): Тот, кто говорит «ненавижу алгоритмы», обычно упирается в одну из четырёх стен. У каждой стены есть имя и решение.
- [Зачем я сделал AlgoPath](https://algopath.pro/ru/blog/zachem-ya-sdelal-algopath): Я месяцами решал задачи и всё равно зависал на собеседованиях. Вот чего не хватало и что я сделал вместо этого.

## Страницы сайта

- [AlgoExpert или AlgoPath: стоит ли платить за AlgoExpert](https://algopath.pro/ru/algopath-vs-algoexpert): Коротко. AlgoExpert это отобранный список из 200 задач с собеседований, к каждой есть видеоразбор. AlgoPath заставляет написать сам алгоритм до того, как…
- [AlgoMonster или AlgoPath: стоит ли платить за AlgoMonster](https://algopath.pro/ru/algopath-vs-algomonster): Коротко. И AlgoMonster, и AlgoPath учат паттернам. AlgoMonster даёт блок-схему, которая ведёт от задачи к алгоритму, и шаблон кода к каждому. AlgoPath…
- [Structy или AlgoPath: стоит ли платить за Structy](https://algopath.pro/ru/algopath-vs-structy): Коротко. Structy учит каждую тему через цепочку задач, к каждой есть анимированное объяснение и разбор кода. AlgoPath заставляет собрать сам алгоритм, а…
- [Стоит ли покупать LeetCode Premium](https://algopath.pro/ru/is-leetcode-premium-worth-it): Коротко. LeetCode Premium стоит своих денег, если ты знаешь, в какую компанию идёшь, и паттерны у тебя уже уверенные. Он добавляет задачи с пометкой…
- [Datenschutz](https://algopath.pro/ru/datenschutz): Здесь описано, какие персональные данные обрабатывает AlgoPath, зачем и какие у вас права. Основание: Общий регламент ЕС по защите данных (GDPR)…
- [Условия](https://algopath.pro/ru/agb): Эти условия регулируют покупку и использование полного доступа к курсу AlgoPath. Они действуют и для частных лиц, и для компаний. 1. Оператор…
- [Widerrufsbelehrung](https://algopath.pro/ru/widerrufsbelehrung): Право потребителя на отзыв договора. Потребителем считается любое физическое лицо, заключающее договор в целях, не связанных преимущественно с его…
- [Аналоги LeetCode: десять площадок рядом](https://algopath.pro/ru/leetcode-alternatives): Коротко. Оставайся на LeetCode, если нужен объём и задачи по конкретным компаниям. Бери NeetCode, если нужен готовый список с видео на каждую задачу…
- [NeetCode: отзыв и чего в нём не хватает](https://algopath.pro/ru/algopath-vs-neetcode): Коротко. NeetCode показывает, как приходят к решению. AlgoPath заставляет написать алгоритм до того, как ты увидишь чужой. Хорошо учишься по видео? Начни…
- [Как правильно учить алгоритмы](https://algopath.pro/ru/best-way-to-practice-dsa): Коротко. Качай три вещи по отдельности. Писать каждый алгоритм по памяти. Называть паттерн незнакомой задачи. Делать и то и другое под таймер, вслух, за…