# Skilled.dev

> Coding interview guides, language preparation, worked algorithms, study plans, and interactive learning tools.

The resources listed below are public and readable without an account. Tool interactions require JavaScript; their explanations are included in the HTML.
Course lessons have their own access settings. The lesson walkthroughs listed here are public reading pages for existing exercises, with no separate course progress. An editor’s available programming languages depend on the exercise and configured runner. Language guides do not imply that every lesson runs in every language.

## Start here

- [Resource library](https://skilled.dev/learn): Browse all published learning resources.
- [Programming language paths](https://skilled.dev/interview-prep): Choose a preparation guide and deeper material for your language.
- [Course overview](https://skilled.dev/course): Browse the curriculum and companion language guides; individual lesson access varies.

## Programming-language lesson walkthroughs

- [Two Sum in JavaScript: return every matching index pair](https://skilled.dev/course/target-two-sum/javascript): Solve the all-pairs Two Sum exercise with a JavaScript Map. Trace complement lookups, handle index zero, preserve indexes, and test numeric assumptions.
- [Two Sum in Python: all index pairs with a dictionary](https://skilled.dev/course/target-two-sum/python): Use enumerate and a dictionary to return every matching pair of indexes. Follow the invariant, distinguish missing keys from index zero, and test the unique-integer contract.
- [Two Sum in Java: all index pairs with HashMap](https://skilled.dev/course/target-two-sum/java): Build a Java HashMap solution for every matching index pair. Handle Integer null checks, avoid complement overflow, and convert the result to int\[\]\[\] with tests.
- [Valid brackets in JavaScript: a stack that ignores ordinary text](https://skilled.dev/course/valid-brackets/javascript): Validate nested parentheses, brackets, and braces with a JavaScript array stack. Trace mismatched closers, ignore other characters, and test nesting and empty input.
- [Valid brackets in Python: matching delimiters with a list stack](https://skilled.dev/course/valid-brackets/python): Write a Python bracket validator using append, pop, and a closer-to-opener dictionary. Follow a nesting trace and test text, missing openers, and crossing brackets.
- [Valid brackets in Java: ArrayDeque and ordered matching](https://skilled.dev/course/valid-brackets/java): Use ArrayDeque as a stack to validate brackets in Java. Handle pop safely, choose character types, ignore ordinary text, and verify a complete set of edge cases.
- [Product of array except self in JavaScript without division](https://skilled.dev/course/product-array/javascript): Build the product array with prefix and suffix passes in JavaScript. Trace the output in place, handle zeros, avoid fill aliasing mistakes, and explain numeric limits.
- [Product of array except self in Python: two passes, no division](https://skilled.dev/course/product-array/python): Solve Product Array using Python lists and running prefix and suffix products. Explain the invariant, zeros, negative numbers, and the cost of large integer arithmetic.
- [Product of array except self in Java with long arrays](https://skilled.dev/course/product-array/java): Implement prefix and suffix products with long\[\] in Java. Initialize the output correctly, handle zeros without division, and state the overflow assumptions with tests.

## Programming language preparation

- [JavaScript coding interview preparation](https://skilled.dev/interview-prep/javascript): Practice the data structures, language behavior, asynchronous utilities, and testing habits that support clear JavaScript interview solutions.
- [TypeScript coding interview preparation](https://skilled.dev/interview-prep/typescript): Use precise types for maps, trees, unions, and asynchronous functions while keeping your interview implementation readable and testable.
- [Python coding interview preparation](https://skilled.dev/interview-prep/python): Choose lists, dictionaries, sets, deque, and heaps deliberately. Practice readable Python solutions with clear time and memory analysis.
- [Java coding interview preparation: collections, numbers, and traversal](https://skilled.dev/interview-prep/java): Prepare with HashMap, ArrayDeque, safe comparators, UTF-16 text, and tested Java implementations of Two Sum and graph traversal.
- [C++ coding interview preparation: STL, ownership, and boundaries](https://skilled.dev/interview-prep/cpp): Use vectors, hash maps, queues, and priority queues while handling iterator invalidation, integer overflow, and safe index boundaries.
- [Go coding interview preparation: slices, maps, and text](https://skilled.dev/interview-prep/go): Practice Go slice ownership, map presence checks, byte and rune boundaries, and queue-based graph traversal with worked code.
- [Rust coding interview preparation: borrowing and collections](https://skilled.dev/interview-prep/rust): Write interview algorithms with borrowed slices, explicit Option results, HashMap entries, VecDeque, and min-heap priority through Reverse.
- [C# coding interview preparation: collections, tuples, and traversal](https://skilled.dev/interview-prep/csharp): Practice C# dictionary presence, nullable tuple results, widened arithmetic, queue traversal, priority ordering, and UTF-16 text contracts.
- [Kotlin coding interview preparation: arrays, nullability, and JVM collections](https://skilled.dev/interview-prep/kotlin): Use primitive arrays, nullable results, map presence, JVM queues, safe comparisons, and explicit collection-sharing assumptions in Kotlin.
- [Swift coding interview preparation: value semantics, optionals, and text](https://skilled.dev/interview-prep/swift): Prepare Swift algorithms with optional results, checked arithmetic, collection value semantics, FIFO traversal, and Unicode-aware text choices.

## Worked guides

- [Debounce vs. throttle in JavaScript](https://skilled.dev/guides/debounce-vs-throttle): Build both functions, compare leading and trailing calls, and test timing behavior with an interactive event timeline.
- [Implement Promise.all in JavaScript](https://skilled.dev/guides/implement-promise-all): Write a Promise.all implementation that preserves input order, handles empty iterables, and rejects correctly.
- [The JavaScript event loop, explained with execution traces](https://skilled.dev/guides/javascript-event-loop): Trace synchronous code, promise microtasks, timers, and async functions. Work through examples before checking their output.
- [BFS vs. DFS: choosing a graph traversal](https://skilled.dev/guides/bfs-vs-dfs): Compare queues, stacks, shortest paths, visited sets, and memory costs with worked graph and grid examples.
- [Big O time and space complexity with worked examples](https://skilled.dev/guides/big-o-time-space-complexity): Analyze loops, nested work, recursion, and auxiliary memory. Learn to state assumptions and distinguish worst-case from amortized cost.
- [How to explain a coding interview solution](https://skilled.dev/guides/explain-your-interview-solution): A worked Two Sum interview: clarify the contract, develop a baseline, justify a hash map, test edge cases, and explain complexity.
- [Implement a JavaScript queue for BFS without repeated shift calls](https://skilled.dev/guides/javascript-queue): Build a FIFO queue with bounded compaction, distinguish empty results from undefined values, and use it in a cyclic graph traversal.
- [TypeScript collections: missing values, keys, and readonly contracts](https://skilled.dev/guides/typescript-collections): Model lookup presence explicitly, handle unchecked indexes, preserve zero and undefined, and write a typed frequency counter and graph BFS.
- [Count islands in Python with iterative flood fill](https://skilled.dev/guides/count-islands-python): Solve a four-neighbor binary-grid problem with an explicit stack, visited-set and in-place variants, complexity analysis, and boundary tests.
- [Java PriorityQueue: top-K values, comparators, and stable ties](https://skilled.dev/guides/java-priority-queue): Retain top-K stream values, process jobs with explicit tie order, and test Java heap ranking separately from iteration and sorted output.
- [C++ lower_bound and upper_bound: counts, neighbors, and record ranges](https://skilled.dev/guides/cpp-search-boundaries): Use C++ search boundaries for duplicate counts, strict predecessors and successors, and custom record keys without invalid iterator operations.
- [Longest unique substring in Go: bytes, runes, and Unicode](https://skilled.dev/guides/go-unicode-sliding-window): Implement rune and ASCII sliding windows, reject invalid input, preserve forward-only boundaries, and test Unicode length assumptions.
- [Rust BFS shortest paths with borrowed graph labels](https://skilled.dev/guides/rust-graph-traversal): Return a shortest unweighted route using borrowed string labels, a FIFO frontier, explicit parents, and a lifetime that matches the source graph.

## Algorithm patterns

- [Sliding window: fixed and variable windows](https://skilled.dev/patterns/sliding-window): Derive a window invariant, update state in constant time, and recognize when negative values or a different condition break the approach.
- [Two pointers: sorted pairs, partitions, and in-place work](https://skilled.dev/patterns/two-pointers): Understand why moving a pointer is safe. Work through sorted Two Sum, palindrome checks, and duplicate removal.
- [Dynamic programming: states, transitions, and evaluation order](https://skilled.dev/patterns/dynamic-programming): Build a recurrence from choices, define a complete state, and compare memoization with tabulation through a worked non-adjacent-sum problem.
- [Prefix sums: range queries and signed subarray counts](https://skilled.dev/patterns/prefix-sums): Build prefix arrays and frequency maps, count target-sum subarrays with negative values, and test boundary and numeric assumptions.
- [Binary search: lower bounds, upper bounds, and first true](https://skilled.dev/patterns/binary-search): Use a half-open boundary invariant to handle duplicates, missing answers, monotone predicates, and binary-search edge cases.
- [Backtracking: subsets, permutations, and pruning](https://skilled.dev/patterns/backtracking): Model a decision tree, restore shared state, copy independent results, and justify pruning with worked subset and permutation code.
- [Monotonic stacks: next greater values and stock spans](https://skilled.dev/patterns/monotonic-stack): Trace unresolved indexes, choose strict or non-strict comparisons, and prove linear total work with tested next-greater and span implementations.
- [Heaps and priority queues: keep the K largest stream values](https://skilled.dev/patterns/heaps-and-priority-queues): Implement a numeric min-heap, choose the right top-K orientation, and separate heap order, sorted output, and update costs.
- [Tries for prefix search: insert, count, and delete words](https://skilled.dev/patterns/tries): Build an iterative Unicode-aware trie with prefix counts, duplicate handling, safe deletion, explicit text contracts, and operation-cost analysis.
- [Union-find: weighted components, path halving, and connectivity](https://skilled.dev/patterns/union-find): Implement disjoint sets with weighted unions, trace component counts, explain amortized costs, and distinguish connectivity from paths and deletions.
- [Greedy algorithms: interval scheduling, exchange proofs, and counterexamples](https://skilled.dev/patterns/greedy-algorithms): Prove earliest-finish interval scheduling, implement a nonmutating selector, reject tempting rules with counterexamples, and test against exhaustive subsets.

## Topic learning paths

- [Arrays and matrix interview practice](https://skilled.dev/topics/arrays): Learn array invariants, in-place work, prefix/suffix products, and matrix traversal through a curated sequence of lessons and exercises.
- [Big O and algorithm analysis](https://skilled.dev/topics/essential-concepts): Practice reasoning about input size, loops, recursion, and auxiliary memory before comparing the efficiency of interview solutions.
- [Hash tables and frequency counting](https://skilled.dev/topics/hashtables): Use hash maps and sets to count frequencies, track previously seen values, and trade additional memory for faster lookups.
- [Strings and text interview problems](https://skilled.dev/topics/strings): Practice text traversal, character counts, palindromes, and anagrams while making the character model and input constraints explicit.
- [Recursion and recursive problem solving](https://skilled.dev/topics/recursion): Define base cases, trace recursive calls, and understand return values and shared state through progressively harder exercises.
- [Searching and sorting interview practice](https://skilled.dev/topics/searching-and-sorting): Learn binary-search invariants, sorted-input reasoning, and sorting tradeoffs with targeted interview problems.
- [Linked lists and pointer techniques](https://skilled.dev/topics/linked-lists): Trace pointer updates, preserve reachability, and practice reversing lists and joining chains without losing nodes.
- [Stacks and queues for coding interviews](https://skilled.dev/topics/stacks-and-queues): Choose last-in-first-out or first-in-first-out processing for bracket matching, traversal, and state tracking.
- [Trees and binary search trees](https://skilled.dev/topics/trees): Practice recursive contracts, traversal order, binary-search-tree bounds, and ancestor relationships with a structured learning path.
- [Graphs, traversal, and shortest paths](https://skilled.dev/topics/graphs): Represent relationships, track visited nodes, choose BFS or DFS, and solve graph and grid interview problems.
- [Dynamic programming interview practice](https://skilled.dev/topics/dynamic-programming): Connect subproblems, memoization, tabulation, and state design with worked interview exercises.
- [JavaScript interview utilities and concepts](https://skilled.dev/topics/javascript): Practice promises, closures, array methods, event emitters, debounce, and throttle with guides and coding lessons.

## Interactive tools

- [Debounce and throttle visualizer](https://skilled.dev/tools/debounce-throttle): Send events and compare immediate, debounced, and throttled callbacks. Adjust the wait and leading/trailing options and inspect exact timelines.
- [Big O complexity explorer](https://skilled.dev/tools/big-o): Compare growth functions across input sizes with a logarithmic chart, exact operation estimates where representable, and worked algorithm examples.
- [BFS and DFS graph traversal visualizer](https://skilled.dev/tools/graph-traversal): Edit an adjacency list and step through breadth-first or depth-first traversal. Inspect the frontier, visited nodes, parents, and reachable paths.
- [Binary tree traversal visualizer](https://skilled.dev/tools/tree-traversal): Build a binary tree from level-order values and step through preorder, inorder, postorder, and breadth-first traversal.
- [Coding interview study-plan builder](https://skilled.dev/tools/study-plan-builder): Build a time-budgeted learning schedule with course links, rotating review, local completion marks, and a downloadable Markdown checklist.
- [Coding interview pattern quiz with answer explanations](https://skilled.dev/tools/pattern-quiz): Practice choosing algorithms from constraints in 12 questions, compare alternatives, retry missed prompts, and study worked pattern guides.
- [JavaScript output quiz: 12 snippets with explained answers](https://skilled.dev/tools/javascript-output-quiz): Predict JavaScript output for closures, this, copies, Map keys, defaults, sorting, and promises. Compare explanations and retry missed snippets.

## Study plans

- [A seven-day coding interview review plan](https://skilled.dev/study-plans/7-day-coding-interview-review): A focused review for developers who already know the basics: daily objectives, selected exercises, timed rehearsals, and a final preparation checklist.
- [A 30-day coding interview study plan](https://skilled.dev/study-plans/30-day-coding-interview-plan): A day-by-day sequence through data structures, algorithms, language practice, review sessions, and mock interviews using the existing course.

## References

- [Data structure time complexity reference](https://skilled.dev/reference/data-structure-time-complexity): Compare arrays, hash maps, linked lists, stacks, queues, trees, and heaps with worst-case, expected, and amortized costs explained.
- [Python collections for interviews: dict, Counter, deque, and heapq](https://skilled.dev/reference/python-collections): Choose Python collections by operation, write counts and adjacency lists, and test queue, heap, missing-key, and copying behavior.