Algorithms

Java

Java is a general-purpose, object-oriented programming language designed to run on any device via the Java Virtual Machine (JVM), following the "write once, ru…

R

R is a programming language and environment purpose-built for statistical computing, data analysis, and graphical visualization, widely used in academia, resea…

Coding Interview

A coding interview is a technical assessment in which a candidate solves algorithmic or data-structure problems, usually under time pressure and while explaini…

Algorithms

An algorithm is a finite, well-defined sequence of steps used to solve a problem or perform a computation, forming the logical foundation of all software.

Data Structures

Data structures are specific ways of organizing, storing, and accessing data in memory — such as arrays, linked lists, trees, and hash tables — chosen to optim…

Compiler

A compiler is a program that translates source code written in a high-level programming language into a lower-level form, such as machine code or bytecode, tha…

C++

C++ is a general-purpose, compiled programming language that extends C with object-oriented programming, templates, and higher-level abstractions while retaini…

MATLAB

MATLAB is a proprietary numerical computing language and environment developed by MathWorks, widely used in engineering, scientific research, and academia for…

LeetCode

LeetCode is an online platform offering coding problems focused on algorithms and data structures, widely used to prepare for technical coding interviews at so…

Filtering, Sorting, and Paging

Building efficient, parameterized queries with Where, OrderBy, and Skip/Take, plus the tradeoffs of offset versus keyset pagination.

The Shuffle and Sort Phase

The often-invisible middle stage of MapReduce that transfers, merges, and sorts intermediate data from every mapper to the right reducer.

Sorting and Grouping

Learn to order pipeline output with Sort-Object and cluster it into buckets with Group-Object, including combining both with Measure-Object for reports.

Recursion in Pascal

Learn how Pascal functions and procedures can call themselves, and how to design correct base cases and recursive cases.

Recursion in LISP

Understand how recursion works in LISP, including base cases, recursive list processing, and tail-call optimization.

Prolog and AI Search Algorithms

See how classic AI search strategies, depth-first, breadth-first, and best-first, map onto Prolog's own backtracking engine and how to implement them explicitl…

Recursion and loop/recur

Learn how Clojure handles recursion without mutable loop variables, and how the recur special form enables safe, stack-efficient tail recursion via loop and fu…

Recursion and Tail Calls

Understand how F# uses recursion instead of mutable loops, and how tail-call optimization lets recursive functions run in constant stack space.

Recursion in Erlang

Why recursion replaces loops in Erlang, and how to write correct, tail-recursive functions that run in constant stack space.

Recursion and Enum

Explore how Elixir uses recursion for iteration and how the Enum and Stream modules provide higher-level functions built on that foundation.

Recursion in Haskell

Understand why recursion is the primary looping mechanism in Haskell, how base cases and recursive cases work, and how tail recursion and laziness affect perfo…

SORT and MERGE in COBOL

Learn how COBOL's built-in SORT and MERGE verbs reorder and combine files using the language's native sort work file mechanism.

Recursion in Assembly

See how recursive functions are implemented at the machine level using the call stack, and why stack depth and register preservation matter.

Load Balancing Algorithms

Understand nginx's round robin, weighted round robin, least_conn, and ip_hash load-balancing algorithms and when to use each.

Join Algorithms in PostgreSQL

Understand the three physical join strategies PostgreSQL can choose — nested loop, hash join, and merge join — and when each one wins.

What Are Design Patterns?

An introduction to what design patterns actually are, how they differ from algorithms and libraries, and when applying one genuinely helps versus adds needless…

Recursion in C++

Understand how recursive functions call themselves, why a base case is required, and the risk of stack overflow without one.

Bubble Sort in C

Master bubble sort in C: syntax, algorithm explanation, optimized code with early-exit flag, sample output, and O(n^2) complexity.

Merge Sort in C

Understand merge sort in C: divide-and-conquer recursion, syntax, a worked merge-step trace, full code, output, and O(n log n) complexity.

Quick Sort in C

Learn quick sort in C: partition logic, pivot selection, divide-and-conquer recursion, complete code, output, and O(n log n) average complexity.

Recursion in C

Master recursion in C: base case, recursive case, call-stack tracing, factorial example, and avoiding stack overflow.

Searching Algorithms in C

Understand linear search and binary search in C with time complexity analysis and complete, compilable example code.

Sorting Algorithms in C

Learn bubble sort in C step by step, with an overview of selection and insertion sort and correct time complexity analysis.

Time Complexity in C

Understand Big-O notation in C with C code examples for O(1), O(log n), O(n), O(n log n), O(n^2), and O(2^n) growth rates.

Erlang Cheat Sheet

Core Erlang syntax covering modules, pattern matching, recursion, and the actor-model process/message-passing primitives.

Scheme Cheat Sheet

Foundational Scheme syntax including define, let forms, list operations, and recursion for this minimalist Lisp dialect.

Java Collections Framework Cheat Sheet

Covers List, Set, and Map basics, choosing between implementations, sorting with Comparator, and immutable collection factories.

C++ STL Cheat Sheet

References the C++ Standard Template Library covering vectors, maps, sets, iterators, algorithms, and container time complexity trade-offs.

Algorithms & Big-O Cheat Sheet

Covers common Big-O complexity classes with code examples, plus rules of thumb for analyzing worst-case and amortized runtime.

Recursion Cheat Sheet

Explains recursive function structure, base and recursive cases, the call stack, memoization, and recursion versus iteration tradeoffs.

Sorting Algorithms Cheat Sheet

Compares common sorting algorithms by time and space complexity and stability, with runnable merge sort and quicksort implementations.

Searching Algorithms Cheat Sheet

Covers linear and binary search, graph traversal with BFS and DFS, and guidance on choosing the right search strategy.

Graph Algorithms Cheat Sheet

Core graph traversal and shortest-path algorithms — BFS, DFS, Dijkstra — with adjacency list representations and complexity comparisons.

Reinforcement Learning Basics Cheat Sheet

A quick reference to core RL concepts, algorithms like Q-learning and policy gradients, and how to implement a simple agent with OpenAI Gym/Gymnasium.

Hyperparameter Tuning Cheat Sheet

Strategies and code patterns for searching hyperparameter space, including grid search, random search, and Bayesian optimization with scikit-learn and Optuna.

Anomaly Detection Cheat Sheet

Explains point, contextual, and collective anomalies, key detection algorithms like One-Class SVM and autoencoders, and how to evaluate results on imbalanced d…

Association Rule Mining Cheat Sheet

Explains support, confidence, and lift metrics along with the Apriori and FP-Growth algorithms for discovering frequent itemsets and association rules.

Elasticsearch Cheat Sheet

Elasticsearch REST API essentials for indexing, searching, filtering, and aggregating documents with mappings and analyzers.

Load Balancing Strategies Cheat Sheet

Covers core load balancing algorithms, Layer 4 vs Layer 7 balancing, health checks, and configuration examples using NGINX and AWS ELB.

HAProxy Cheat Sheet

Configuration syntax for HAProxy frontends, backends, load-balancing algorithms, and health checks in high-availability setups.

Cryptography Basics Cheat Sheet

Introduces symmetric and asymmetric encryption, hashing, and digital signatures with practical examples of correct algorithm usage.

C++ Ranges Library Cheat Sheet

Views, adaptors, and pipe-composed algorithms from std::ranges (C++20/23) for lazy, composable iteration without manual iterator pairs.

What is Big O Notation?

Big O notation describes how an algorithm’s running time or memory usage grows as the input size grows, focusing on the dominant term and ignoring constant fac…

Difference Between Array and Linked List

An array stores elements in contiguous memory with fixed-size, index-based access in O(1), while a linked list stores elements as nodes scattered in memory, ea…

What is a Hash Table?

A hash table is a data structure that maps keys to values using a hash function to compute an index into an array of buckets, giving average O(1) insertion, lo…

What is Recursion?

Recursion is a technique where a function solves a problem by calling itself on a smaller instance of the same problem, until it reaches a base case that stops…

Difference Between Stack and Queue

A stack is a LIFO (Last In, First Out) structure where the last element added is the first removed, while a queue is a FIFO (First In, First Out) structure whe…

What is a Binary Search Tree (BST)?

A binary search tree is a binary tree where every node’s left subtree holds smaller keys and its right subtree holds larger keys, enabling search, insertion, a…

What is Dynamic Programming?

Dynamic programming is a technique for solving problems by breaking them into overlapping subproblems and storing each subproblem’s result so it is computed on…

What is a Heap?

A heap is a complete binary tree stored in an array that satisfies the heap property — in a min-heap every parent is smaller than or equal to its children, giv…

What is a Trie?

A trie, or prefix tree, is a tree-based data structure that stores strings character by character along shared paths, letting you search, insert, and check pre…

Merge Sort vs Quick Sort: What is the Difference?

Merge sort splits an array in half, recursively sorts both halves, then merges them, guaranteeing O(n log n) time and stability at the cost of O(n) extra space…

What is a Graph?

A graph is a data structure made of nodes (vertices) connected by edges, used to model relationships and connections such as networks, maps, or dependencies, a…

What is a Doubly Linked List?

A doubly linked list is a sequence of nodes where each node stores a value plus pointers to both the next and the previous node, allowing traversal in either d…

What is Binary Search?

Binary search is an algorithm that finds a target value in a sorted collection by repeatedly halving the search range, comparing the target to the middle eleme…

What is a Priority Queue?

A priority queue is an abstract data type where each element has a priority, and the element with the highest (or lowest) priority is always removed first, typ…

What is the Difference Between Time and Space Complexity?

Time complexity measures how the number of operations an algorithm performs grows with input size, while space complexity measures how the memory it needs grow…

What is a Balanced Tree?

A balanced tree is a binary tree structured so the height difference between subtrees at every node stays bounded (typically by a constant like 1), keeping the…

What is the Two Pointer Technique?

The two pointer technique uses two index variables that move through a data structure — typically a sorted array or a linked list — to solve problems in O(n) t…

What is the Sliding Window Technique?

The sliding window technique maintains a contiguous subrange of an array or string, expanding and contracting its boundaries as it scans, to solve subarray or…

What is Memoization?

Memoization is an optimization technique that caches the results of expensive function calls keyed by their arguments, so repeated calls with the same inputs r…

What is a Circular Queue?

A circular queue is a fixed-size queue implemented on an array where the last position wraps around to connect back to the first, allowing enqueue and dequeue…

What is Topological Sort?

Topological sort produces a linear ordering of the nodes in a directed acyclic graph such that for every directed edge from node A to node B, A appears before…

What is Dijkstra’s Algorithm?

Dijkstra’s algorithm finds the shortest path from a single source vertex to every other vertex in a weighted graph with non-negative edge weights, using a gree…

What is a Red-Black Tree?

A red-black tree is a self-balancing binary search tree that colors each node red or black and enforces balancing rules so the longest root-to-leaf path is nev…

Greedy vs Dynamic Programming: What is the Difference?

Greedy algorithms make the locally optimal choice at each step and never reconsider it, while dynamic programming explores overlapping subproblems and combines…