Data structures and algorithms glossary

Terms used in the lessons

Every term used across the lessons, in plain words. Search or skim.

A/B testing

a way to compare two versions of something (a web page, a feature) by showing version A to some users and version B to others, then measuring which one performs better.

Abseil flat_hash_map

a hash table from Google's Abseil C++ library that stores its entries in one flat block of memory for faster lookups.

Abuse detection

systems that spot bad behavior like spam, fraud, or bots by looking for suspicious patterns in activity.

Account merging

combining two user accounts that belong to the same person into one, keeping the data from both.

Ad slots

the reserved spaces on a page or app where advertisements are placed.

Adjacency lists

a way to store a graph where each item keeps a list of the other items it connects to.

Algorithm

a step-by-step recipe that turns something you have into the answer you want. Like a cooking recipe, but for data.

Analytics dashboards

a screen that gathers key numbers about a product or business into charts and tables so people can see how things are going at a glance.

Analytics grouping

collecting many data records into buckets by some shared value (by day, by country) so you can count or total each group.

Anomaly detection

automatically finding data points that look unusual compared to the normal pattern, often to catch errors or fraud.

API rate limiters

a control that caps how many requests a program or user can send to a service in a given time, so no one overloads it.

Array.indexOf

a JavaScript array method that returns the position of a value in an array, or -1 if it isn't there.

Aspect ratios

the width-to-height proportion of an image or screen, like 16:9, used to keep pictures from stretching.

ATM cash dispensing

the part of a cash machine that works out which bills to hand you for a requested amount, using as few notes as possible.

Autocomplete

the feature that suggests or finishes what you're typing based on the first few letters, in search boxes and editors.

Autocorrect

the feature that automatically fixes misspelled words as you type by matching them to known words.

Availability grids

a table showing which time slots are free or taken, used in booking and scheduling tools.

AVL indexes

database indexes built on AVL trees, a self-balancing tree that keeps lookups fast by staying evenly shaped as data is added.

AVL trees

a kind of search tree that rebalances itself after every insert or delete so it never gets lopsided, keeping searches fast.

Backtracking

trying a choice, and if it leads to a dead end, stepping back and trying another - like finding your way out of a maze.

Backup dedup

storing backups without keeping duplicate copies of identical data, so the same block is saved once and reused.

BFS (breadth-first search)

exploring outward one ring at a time using a queue, like ripples spreading on water. Finds the shortest path when every step counts equally.

Big-O

a quick way to say how much slower a method gets as the input grows. O(n) means "twice the data, twice the work." O(n²) means "twice the data, four times the work." O(log n) means "twice the data, just one extra step." It's about the shape of the growth, not seconds on a clock.

Binary search

finding something in a sorted list by cutting the search area in half each guess, like the "higher / lower" number game.

Binary search tree (BST)

a tree kept in order (smaller on the left, bigger on the right) so you can find things fast.

Bioinformatics

the field that uses computer methods to analyze biological data such as DNA and protein sequences.

Bipartite matching

pairing items from two separate groups (like workers and jobs) so each pair is compatible and as many as possible are matched.

Bitmask

using the on/off bits inside a single number as a compact row of yes/no switches.

Bloom filters

a compact structure that quickly tells you whether an item is probably in a set or definitely not, using little memory but allowing rare false positives.

Board-game scans

checking the squares of a game board (for wins, moves, or matches) by walking across the grid.

Boggle-style validators

code that checks whether a word can be formed by connecting adjacent letters on a grid, as in the game Boggle.

Booking systems

software that reserves things like seats, rooms, or appointments and prevents two people from taking the same slot.

Bounded log tails

keeping only the most recent lines of a log, so older entries drop off once a fixed limit is reached.

Browser history

the record of pages you've visited, letting you go back and forward through them.

Brute force

the obvious solution that just tries every possibility. It always works, but it's often slow.

Bucketed stats

grouping measurements into ranges (buckets) and counting how many fall in each, as in a histogram.

Budget allocation

deciding how to split a fixed amount of money across competing needs to get the most value.

Build systems

tools that turn source code into a finished program, running the needed steps in the right order.

Build tools

programs that automate compiling, packaging, and preparing software for release.

C qsort

the standard sorting function in the C language's library, which orders the elements of an array.

C++ make_heap

a C++ standard-library function that rearranges a range of items into a heap, a shape that keeps the largest (or smallest) item easy to reach.

Cache invalidation

removing or refreshing cached data once it's out of date, so users don't see stale results.

Cache sharding

splitting a cache across several servers so each holds part of the data and the load is spread out.

Caching ASTs

saving the parsed form of code (its abstract syntax tree) so a tool doesn't have to re-parse the same source again.

Calendar booking

reserving a time slot on a calendar while making sure it doesn't clash with an existing one.

Calendar free/busy

the view that shows which times a person is available or occupied without revealing event details.

Calendar overlaps

detecting when two calendar events cover the same time, so you can flag or prevent double-booking.

Call stacks

the running list of functions a program has entered but not yet finished, tracked so it knows where to return.

Canary deploys

releasing a new version to a small share of users first, watching for problems before rolling it out to everyone.

Capacity planning

working out how much hardware or resources you'll need to handle expected future demand.

Cargo loading

deciding how to pack items into a limited space (a truck, container, or ship) to fit the most or the most valuable load.

Case-insensitive login

accepting a username or email regardless of capital letters, so "Sam" and "sam" are treated as the same.

Cash registers

the till in a shop that totals a sale and calculates the change to give back.

Chip routing

laying out the wire connections between components on a computer chip so signals reach where they need to go.

CI test matrices

a grid of configurations (different versions, operating systems) that automated testing runs against, so code is checked on every combination.

Circular buffers

a fixed-size storage that reuses its space in a loop, overwriting the oldest data once it fills up.

Circular imports

when two code files each depend on the other, forming a loop that can break loading; tools detect it.

Cloud cost caps

limits set on cloud spending so a service automatically slows or stops before the bill goes over budget.

Clustering

grouping data points that are similar to each other, so natural categories emerge without labeling them by hand.

Cocktail sort

a sorting method that passes back and forth through a list, bubbling large items up and small items down each way.

Community detection

finding tightly connected groups within a network, like clusters of friends in a social graph.

Compilers

programs that translate source code written by people into machine code a computer can run.

Computer vision filters

operations applied to an image (blur, sharpen, edge-find) that transform each pixel based on its neighbors.

Config lists

lists of settings that tell a program how to behave.

Config stores

a central place that holds an application's settings so services can read them consistently.

Config-drift detection

noticing when a system's actual settings have wandered away from the intended configuration.

Consistent hashing

a way to spread data across servers so that adding or removing a server moves as little data as possible.

CPython dict

the dictionary type in CPython, the standard Python, which stores key-value pairs using a hash table for fast lookup.

Cryptography

the practice of encoding information so only the intended party can read it, used to keep data secret and verify identity.

Cryptography key-gen

generating the secret keys used to encrypt and decrypt data, usually from large random numbers.

Currency arbitrage

spotting a chain of currency exchanges that ends with more money than you started, exploiting price differences.

Cutting stock

working out how to cut standard-size material (paper rolls, metal sheets) into ordered pieces with the least waste.

Data sharding

splitting a large dataset across multiple databases or servers so each holds only a piece.

Data structure

a way of arranging things so you can get at them quickly. A shopping list, a phone book, and a stack of plates each arrange stuff for a different job.

Database B-trees

the balanced tree structure databases use for indexes, keeping data sorted so lookups and ranges stay fast even with huge tables.

Database compaction

merging and cleaning a database's storage files to reclaim space and remove deleted or outdated entries.

Database indexes

extra lookup structures a database keeps so it can find rows quickly without scanning the whole table.

Database sorts

the operation a database uses to put query results in order, for example by date or name.

Databases

systems that store, organize, and retrieve large amounts of data reliably.

Datacenter routing

directing network traffic along paths between the many machines in a datacenter.

DB migrations

scripted changes to a database's structure, applied in order so the schema evolves safely over time.

Deadlock detection

finding situations where processes are each waiting on the other and none can proceed, so the system can break the standoff.

Deduplication

removing duplicate copies of the same data so only one is kept.

Dependency graphs

a map of what depends on what (packages, tasks, files), used to work out a safe build or install order.

Dependency resolvers

tools that pick a compatible set of package versions so everything a project needs works together.

Deque

a line you can add to and take from at both ends.

DFS (depth-first search)

following one path as far as it goes before backing up to try another, using recursion or a stack.

Diffie-Hellman

a method that lets two parties agree on a shared secret key over an open connection without anyone listening in learning it.

Dijkstra

an algorithm that finds the shortest path from one point to all others in a network of weighted connections.

Disk-usage tools

programs that show what's taking up space on a drive by adding up the sizes of files and folders.

Distinct-count windows

counting how many unique items appeared within a recent time span, like unique visitors in the last hour.

DNA alignment

lining up two DNA sequences to find where they match and differ, used to compare genes.

DOM node bookkeeping

keeping track of the elements in a web page's structure as they're added, changed, or removed.

DOM serialization

turning a web page's in-memory element tree back into HTML text.

DOM traversal

walking through the elements of a web page's tree to find or process specific nodes.

DOM trees

the tree-shaped structure a browser builds from a web page, where each HTML element is a node with parents and children.

Double-booking checks

verifying that a new reservation doesn't overlap one already made for the same resource.

DP solvers

programs that solve problems with dynamic programming, breaking a big problem into smaller overlapping subproblems and reusing their answers.

du command

a Unix command that reports how much disk space files and folders use.

Dynamic programming (DP)

solving a big problem by solving its small overlapping pieces once, writing each answer down, and reusing it instead of redoing the work.

Edge case

a weird input that trips up sloppy code: nothing at all, just one item, everything the same, or no valid answer.

Editor bracket matching

the editor feature that highlights the opening bracket paired with the one at your cursor, so you can see if they're balanced.

Editor find

the search feature in a text editor that locates where a word or phrase appears in the file.

Editors

programs for writing and changing text or code.

Embedded sorting

sorting done inside small hardware devices like sensors or appliances, where memory and processing power are tight so the sort has to be lean.

Embedded systems

small computers built into a device (a car, a washing machine, a thermostat) to control it, rather than a general-purpose PC.

Error detection

checking whether data got corrupted while stored or sent, so a system can catch mistakes instead of trusting bad data.

Error-correcting codes

extra bits added to data that let a system not only spot corruption but repair it without asking for the data again.

Exam timetabling

scheduling exams into time slots and rooms so no student has two exams at once and no room is double-booked.

External merge sort

a way to sort more data than fits in memory by sorting it in chunks on disk and then merging those sorted chunks together.

External sort

sorting data that is too big to fit in memory, so it lives on disk and is processed in pieces.

Feature flags

on/off switches in software that turn features on or off without shipping new code, used to roll features out gradually or hide unfinished ones.

Feature-flag combos

the different combinations of feature flags that can be on at the same time, which have to be tested because features can interact.

Feed trimming

cutting an activity feed or timeline down to a fixed number of recent items so it doesn't grow forever.

File explorers

the program that shows your folders and files and lets you open, move, and delete them (like Finder on Mac or File Explorer on Windows).

Filesystem walkers

code that visits every folder and file under a starting directory, one after another, to process or list them all.

Firewall IP ranges

blocks of network addresses a firewall allows or blocks, used to decide which computers may connect.

Fixed-width ids

identifiers that always use the same number of characters, padded if needed, so they sort and line up neatly.

Flight itineraries

the full plan of a trip's flights: which planes, in what order, with connections and times.

Flood fill

the technique that fills a connected area with one color by spreading out from a starting point, like the paint-bucket tool in image editors.

Fraction math

arithmetic with fractions (like 1/3 + 1/4) done exactly, keeping numerator and denominator instead of rounding to a decimal.

Fraud dedup

removing duplicate fraud alerts or records so the same suspicious event isn't counted or investigated twice.

Free-list allocators

a memory manager that keeps a list of freed-up memory blocks so it can hand them out again for new requests.

Fuzzy search

search that still finds matches when the query has typos or isn't spelled exactly the same as the target.

Game leaderboards

the ranked score table in a game showing who's on top, updated as players earn points.

Game move generation

working out all the legal moves a player can make from the current position, used by game logic and AI opponents.

Game pathfinding

working out how a character should move from one spot to another around obstacles in a game world.

Game reachability

working out which places or states in a game can actually be gotten to from a given point.

git bisect

a Git command that finds which commit introduced a bug by repeatedly checking a commit halfway through the suspect range.

git diff

a Git command that shows the exact changes between versions of your files.

git merge base

the most recent commit that two branches share, which Git uses as the starting point when merging them.

git merge-base

the Git command that finds the most recent common ancestor commit of two branches.

Go maps

the built-in key-value lookup structure in the Go programming language, used to store and find data by a key.

Graph

dots joined by lines, where the lines can form loops. Roads between cities, friends on social media, and task dependencies are all graphs.

Graph diameter

the longest of all the shortest paths in a network, showing how far apart the two most distant points are.

Greedy

grabbing the best-looking option at each step and hoping the whole result comes out best. Only trustworthy when you can prove it.

grep

a Unix command that searches text or files for lines matching a pattern.

Grid path finders

code that finds a route between two cells on a grid of squares, going around blocked cells.

Grid pathfinding

finding a route from one cell to another across a grid, avoiding blocked squares.

gzip

a common tool and format for compressing files to make them smaller for storage or transfer.

Hash table / hash map

a lookup that finds a value by its key almost instantly, like a dictionary where you flip straight to the word. Each language has one: `Map` in JavaScript and TypeScript, `dict` in Python, an array in PHP, `HashMap` in Java.

Hash tables

a structure that stores data by key so you can look up a value almost instantly instead of scanning everything.

Hashtag splitting

breaking a run-together hashtag like #ThrowbackThursday into separate words.

Heap / priority queue

a pile that always hands you the smallest (or biggest) item next, without sorting everything. Good for "top 5" lists and live streams of data.

heapq.heapify

a Python function that rearranges a list into a heap so you can repeatedly pull out the smallest item efficiently.

Heatmap rendering

drawing a colored map where color shows intensity, so hot spots (more activity, higher values) stand out.

Held-Karp TSP

an exact method for the traveling-salesman problem that finds the shortest route visiting every stop once, using stored partial results to avoid redoing work.

Histograms

a chart that groups numbers into buckets and shows how many fall in each, revealing the shape of the data.

IDE completion

the code editor feature that suggests and finishes what you're typing (variable names, functions) as you write.

Idempotency keys

a unique tag on a request so that if it's sent twice by mistake, the server does the action only once (like avoiding a double charge).

Image labeling

marking the separate objects or regions in an image, for example finding each distinct blob and giving it a number.

Image processing

changing or analyzing pictures with code: resizing, sharpening, detecting edges, and so on.

Image rotation

turning a picture by an angle, for example 90 degrees, while keeping it correct.

In place

changing the original data directly instead of making a copy, to save memory.

Index validation

checking that a position or lookup key is within the allowed range before using it, so code doesn't read past the end.

Integral images

a precomputed table over an image that lets you add up the pixels in any rectangle instantly, used to speed up image analysis.

Introsort

a sorting method that starts fast with quicksort and switches to a safer method if things go badly, so it stays quick without worst-case slowdowns.

introsort fallback

the safety switch in introsort that swaps to heapsort when quicksort is going too slow, guaranteeing good worst-case speed.

Intrusion detection

watching a system or network for signs of an attack or break-in and raising an alert.

Invariant

something you keep true at every step of a loop; it's the reason the loop actually works.

Inventory holds

temporarily reserving stock (for an order in progress) so two customers can't buy the last item at once.

Inversion counts

counting how many pairs in a list are out of order, a measure of how unsorted the list is.

Invoice reconciliation

matching invoices against payments or records to make sure the amounts agree and nothing is missing.

IP routing

deciding which path a piece of network data should take across the internet to reach its destination address.

Java HashMap

Java's built-in key-value store, used to save and look up values by a key quickly.

JavaScript Map

JavaScript's built-in key-value store that remembers insertion order and lets you look up values by any key.

JavaScript Set

JavaScript's built-in collection that holds only unique values, used to remove duplicates or test membership fast.

Job assignment

matching workers or machines to tasks in the best way, for example the lowest total cost or time.

Job pipelines

a chain of processing steps where each job passes through stages in order, one feeding the next.

Job scheduling

deciding when and in what order tasks run, given deadlines, priorities, and limited resources.

JPEG

a common file format for photos that shrinks them by dropping detail the eye barely notices, trading some quality for much smaller files.

JPEG image compression

the method behind JPEG files that makes photos smaller by discarding fine detail people are unlikely to see.

JSON/XML parsers

code that reads JSON or XML text and turns it into structured data a program can work with.

k-way merge

combining k already-sorted lists into one sorted list by repeatedly taking the smallest front item across them.

Kafka partitions

the separate ordered streams a Kafka topic is split into, letting many consumers read data in parallel. (Kafka is a system for moving streams of events between programs.)

Kafka streams

continuous flows of event data handled by Kafka, read and processed as they arrive rather than in one batch.

Kruskal MST

an algorithm that connects all points in a network with the least total cabling by adding the cheapest links first and skipping any that would form a loop.

LCA

lowest common ancestor: in a tree of items, the deepest single node that sits above two given nodes, used to find their nearest shared parent.

Leaderboards

a ranked list showing who or what scores highest, updated as new results come in.

Ledger reconciliation

checking two sets of financial records against each other to confirm every entry matches and the balances agree.

Linux kernel

the core of the Linux operating system that manages memory, files, and hardware and lets programs run.

Linux rb_tree

the red-black tree used inside the Linux kernel, a self-balancing sorted structure that keeps lookups and inserts fast.

Live feeds

streams of content that update in real time, like a news or social feed adding new items as they happen.

Load balancing

spreading incoming requests across several servers so no single one gets overwhelmed.

Log aggregation

collecting log messages from many machines and services into one place so you can search and analyze them together.

Log dedup

removing repeated log lines so the same message isn't stored or shown many times.

Log merging

combining log entries from several sources into one stream, usually kept in time order.

Log pipelines

the chain of steps that collects, filters, and stores log data as it flows from apps to a searchable store.

Log redaction

hiding or blanking out sensitive details (passwords, card numbers) in logs before they're stored or shared.

Log scanning

reading through log files to find specific entries, patterns, or problems.

Log viewers

a tool for browsing, searching, and filtering log messages.

lower_bound/upper_bound

C++ search functions on sorted data that find the first position at or above a value and the first position strictly above it.

LRU caches

a cache that, when it runs out of room, throws out the item you used least recently to make space, keeping the things you touch often.

LSM compaction

the background cleanup in log-structured storage that merges many small sorted files into fewer bigger ones and drops stale data, keeping reads fast.

Machine scheduling

deciding which machine does which job and when, to finish work as fast or as cheaply as possible.

Making change

working out which coins or notes add up to a given amount, usually with the fewest pieces.

Map navigation

finding and following a route between two places on a map, with turn-by-turn directions.

Matrix chain

the problem of choosing the order to multiply a series of matrices so the total work is smallest.

Matrix display

showing a grid of values on screen, often as a table or an image.

Matrix serialization

turning a grid of values into a flat sequence of bytes or text so it can be saved or sent, and read back later.

Maze generation

creating a maze automatically with a guaranteed path through it, used in games and puzzles.

Median filters

an image or signal cleanup that replaces each value with the middle value of its neighbors, good at removing speckle noise.

Meeting rooms

scheduling meetings into rooms so no two overlapping meetings land in the same room.

Memoization

remembering answers you already worked out, so asking the same question again is instant. It's the first step from recursion toward dynamic programming.

Memory allocators

the part of a system that hands out and reclaims chunks of memory as programs ask for and release them.

Merge sort

a sorting method that splits the list in half, sorts each half, then merges the two sorted halves back together.

Message brokers

middleman software that takes messages from senders and delivers them to the right receivers, so programs can talk without connecting directly.

Metric baselines

the normal expected level of a measurement, used to judge whether a new reading is unusually high or low.

Metrics dashboards

a screen of charts and numbers showing how a system is performing at a glance.

Metrics monitoring

continuously tracking measurements from a system and alerting when something looks wrong.

Metrics peaks

the highest points in a stream of measurements, useful for spotting spikes in load or usage.

Metrics rollups

the periodic squashing of many raw data points into summary numbers (like per-minute averages) so charts and reports stay small and fast.

Modular arithmetic

counting that wraps around, like a clock rolling from 12 back to 1. Used to keep giant numbers from getting out of hand.

Module bundlers

tools that take all the separate code files a web app is made of and combine them into a few optimized files a browser can load quickly.

Monotonic stack/queue

a stack or queue you keep in order as you add to it, so you can instantly find the next bigger (or smaller) item.

Moving averages

an average recalculated over the most recent stretch of values as new ones arrive, used to smooth out noisy data and show the trend.

n

how big the input is: the number of items you're working with.

Navigation engines

the software behind turn-by-turn directions that figures out the best route from where you are to where you want to go.

Near-sorted leaderboards

score rankings that are already almost in order, so only a few entries need to shift when a new score comes in.

Negative case

a test where the right answer is "nothing found" or "not possible," to check the code handles the empty or failure case, not just the happy one.

Network buffers

small holding areas in memory where incoming or outgoing network data waits its turn to be processed or sent.

Network cabling

the physical wires connecting computers and equipment so they can pass data to each other.

Network diameter

the longest shortest-path between any two points in a network, telling you the worst-case number of hops a message might take.

Observability dashboards

screens that show live charts and numbers about how a running system is behaving, so operators can spot problems.

OLAP cubes

pre-computed tables of business numbers grouped by several dimensions at once (time, region, product) so analytical reports come back instantly.

One-stroke drawing

tracing a shape without lifting the pen or repeating any line, a puzzle that maps to finding a path through every edge of a graph once.

Order books

the live list of all buy and sell offers for a stock or other asset, sorted by price, that a market uses to match trades.

Org charts

a diagram of who reports to whom in a company, shaped as a tree from the top down.

OS schedulers

the part of an operating system that decides which program gets to use the CPU next and for how long.

OSPF routing

a method routers use to learn the network layout and pick the shortest path for sending data across a large network.

Overbooking detection

checking whether more reservations have been accepted than there is capacity for, such as too many bookings for the seats available.

p50 monitoring

tracking the median (50th percentile) of a measurement, so half the values fall below it, used to watch typical response times.

Paint bucket

the drawing-tool feature that fills a connected area of the same color with a new color when you click inside it.

Pairwise testing

a way to cut down test cases by checking every pair of input combinations at least once instead of all possible combinations.

Palindrome checks

testing whether a word or sequence reads the same forwards and backwards, like "level".

Payment matching

lining up incoming payments with the invoices or orders they are meant to settle.

Payment terminals

the card-reader devices in shops that take a customer's card and process the payment.

Peak-load detection

spotting the moments when demand on a system is highest, so you can size capacity or trigger alerts.

Percentile queries

questions like "what value is greater than 95% of the data", used to summarize things like response times.

Percolation

a model of whether connected paths span across a grid, used to study when scattered links suddenly join into one large network.

Permission trees

access rights arranged in a hierarchy where a folder or group's settings carry down to everything nested inside it.

Plagiarism detection

comparing a document against others to find copied or closely matching passages.

PNG

a common image file format that stores pictures without losing quality, often used for graphics and screenshots.

Pointer / index

a marker for a spot in a list, like a finger pointing at one item. "Move the pointer" means point at a different spot.

Prefix sum

a running total written down at each spot, so the sum of any stretch is one subtraction of two totals. Like a bank balance: the change over a period is the end balance minus the start balance.

Price feeds

a continuous stream of the latest prices for stocks, currencies, or goods, delivered to trading and pricing systems.

Print spoolers

the system that queues up print jobs and sends them to the printer one at a time in order.

Private class fields

variables inside a code object that only that object's own methods can read or change, hidden from outside code.

Producer batching

grouping many small produced items together and sending them as one batch to cut per-item overhead.

Puzzle solvers

programs that search through possible moves to find a solution to a puzzle like a maze or Sudoku.

Python dict

Python's built-in structure for storing key-to-value pairs, letting you look up a value fast by its key.

Python heapq

a Python library that keeps a list arranged so the smallest item is always quick to grab, used for priority queues.

Query builders

code tools that assemble database queries piece by piece instead of writing the query text by hand.

Query planners

the database component that works out the fastest way to run a query before actually running it.

Queue

a line where the first to arrive is the first served, like a queue at a shop.

quickselect

a method that finds the k-th smallest item in a list without fully sorting it, by repeatedly partitioning around a pivot.

Quorum selection

requiring that a minimum number of servers in a group agree before an action counts, so the system stays consistent.

Race-condition testing

deliberately checking what happens when two parts of a program touch the same data at the same time, to catch timing bugs.

Radix-sort phase

one pass of radix sort, a sorting method that orders numbers by looking at one digit at a time.

Range indexes

a database structure that quickly finds all records whose value falls between two bounds.

Range-min queries

questions asking for the smallest value within a given slice of a list, answered fast with the right preparation.

Rate tables

lookup tables of prices or charges, such as shipping or currency rates, used to compute a cost for given inputs.

Rate-limit budgets

the allowance of how many requests a user or client may make in a time window before being throttled.

Rate-limit tuning

adjusting those request allowances to balance protecting a system against letting legitimate traffic through.

React reconciler

the part of the React web framework that compares the new interface to the old one and updates only what changed on screen.

React useMemo

a React feature that remembers the result of a costly calculation and reuses it instead of redoing it on every render.

Record clustering

grouping database records that are similar to each other, for example customers with alike behavior.

Record deduplication

finding and merging duplicate entries that refer to the same real thing, like the same person listed twice.

Recursion

a function that solves a big problem by calling itself on a smaller piece, until the piece is tiny enough to answer directly.

Red-black trees

a self-balancing sorted tree that rearranges itself as you add or remove items so lookups stay fast no matter the order they arrive.

Reduce phase

the stage in a MapReduce data job that combines many partial results into the final totals.

Register allocation

the compiler's job of deciding which of a CPU's few fast storage slots (registers) each value should live in while a program runs.

Replay detection

spotting when someone resends a captured request or message to catch attempts to reuse it fraudulently.

Resource planning

working out how to assign limited resources like people, machines, or time across the work that needs them.

Response caches

stored copies of previous replies so a repeat request can be answered instantly without redoing the work.

Retry budgets

a cap on how many times failed operations may be retried, to stop a struggling system from being flooded with retries.

Ring buffers

a fixed-size buffer that wraps around and overwrites its oldest data when full, used for steady streams like audio or logs.

Ring indexes

position numbers that wrap back to the start after the end, used to walk in circles around a fixed-size buffer.

RIP routing

an older, simple method routers use to share which networks they can reach and pick paths by fewest hops.

RNA folding

predicting how an RNA molecule bends and pairs up with itself, a biology problem solved by matching-up algorithms.

Road networks

the map data of roads and intersections that routing software searches to plan a drive.

Robot navigation

a robot working out how to move through its surroundings from one point to another without hitting obstacles.

Robotics pathing

computing the actual path a robot should follow to reach a goal while avoiding obstacles.

Role inheritance

an access-control setup where one role automatically gains all the permissions of the roles beneath it.

Rolling hashes

a way to keep a running fingerprint of a sliding stretch of text, updated cheaply as you move one step, so you can compare substrings fast.

Rotated logs

log files that are closed and rolled over to a fresh file on a schedule or size limit, so old ones can be archived or deleted.

Route generation

producing the set of possible paths or turn steps for getting from one place to another.

Route planning

choosing the best path from a start to a destination given distances, traffic, or other costs.

Router tables

the lookup list inside a router that says which direction to send data for each destination network.

Routing tables

the stored map of destinations and the next hop to reach each one, used to forward network traffic.

RSA

a widely used encryption method that secures data using a public key to lock and a matching private key to unlock.

rsync

a Unix tool that copies and syncs files between locations, transferring only the parts that changed to save time.

Saved game state

the stored snapshot of a game's progress so a player can quit and later pick up where they left off.

Scaffold

the ready-to-run practice setup you get for each step (starter code + tests) so you can jump straight to solving instead of building the setup.

Scheduling

deciding when and in what order tasks, jobs, or appointments should run given their timing and constraints.

Screen buffers

the block of memory holding the current picture to be shown on screen, which the display reads from.

Seam carving

a way to resize an image by removing the least noticeable connected lines of pixels so important content keeps its shape.

Search indexes

a prepared structure that lets a search engine find matching documents fast instead of scanning everything.

Search normalization

cleaning up search text (lowercasing, trimming accents, unifying spellings) so different forms of a word still match.

Search queries

the words and filters a user types to find what they are looking for.

Search ranking

ordering search results so the most relevant ones appear at the top.

Search suggestions

the guesses a search box offers as you type, completing or proposing likely queries.

Session stores

where a web server keeps the temporary data about each logged-in user's current visit, like their cart or login state.

Set

a bag of items with no duplicates, where "is this in it?" is instant. Each language has one: `Set` in JavaScript and TypeScript, `set` in Python, an array used as a lookup in PHP, `HashSet` in Java.

Shell tab-completion

the command-line feature that finishes a file name or command for you when you press Tab.

Signal analysis

examining a measured signal, such as sound or sensor data, to pull out patterns, frequencies, or events.

Signal processing

transforming and cleaning up signals like audio, images, or sensor readings to filter noise or extract useful information.

Skip lists

a sorted list with extra express layers of shortcuts over it, so you can jump ahead and find items quickly.

SLA tracking

measuring whether a service is meeting its promised targets, like uptime or response speed, agreed with customers.

Sliding window

a stretch of a list, `[left, right]`, that you slide along: add one item on the right, drop one on the left, instead of re-counting the whole stretch each time.

Sliding-window min

keeping track of the smallest value within a window that slides along a sequence, updated as the window moves.

Small config lookups

quick reads of a handful of settings values that a program needs to adjust its behavior.

Small leaderboards

short ranked score lists with few enough entries that keeping them ordered is cheap.

Social circles

groups of people connected by friendship or contact, modeled as a network to find clusters or mutual links.

Social graphs

a way of storing who is connected to whom on a network, used by sites like Facebook or LinkedIn to find friends, mutual connections, and suggestions.

Sorted lookup tables

a list kept in sorted order so you can find any entry quickly by jumping to the middle instead of scanning every row.

Space complexity

how much extra memory the method needs as the input gets bigger.

Spell-check

a feature that compares each word you type against a dictionary and flags the ones it doesn't recognize.

Spellcheckers

the tools inside word processors and browsers that catch misspelled words and suggest corrections.

Spreadsheet cleanup

the work of fixing a spreadsheet's data, like removing duplicate rows, trimming stray spaces, and correcting formats.

Spreadsheet search

finding a specific value or row inside a spreadsheet, often much faster when the column is sorted.

Spreadsheets

grid-based apps like Excel or Google Sheets for storing numbers and text in rows and columns and running calculations on them.

SQL GROUP BY

a database command that collapses rows sharing the same value into groups so you can total or count each group.

Stable sort

a sorting method that keeps items with equal keys in their original relative order, so a second sort doesn't scramble the first.

Stack

a pile where you always take from the top. Think of a stack of plates: the last one on is the first one off.

std::map

a C++ container that stores key-value pairs sorted by key, letting you look up, insert, and traverse them in key order.

std::map erase

the C++ operation that removes an entry from a std::map by its key.

std::priority_queue

a C++ container that always gives you the highest-priority item next, used when you repeatedly need the current maximum (or minimum).

std::sort

the C++ standard function that sorts a range of items quickly, in place.

Stock span

a calculation of how many days in a row a stock's price stayed at or below today's price, used in trading charts.

Stream processing

handling data as it arrives in a continuous flow, instead of waiting to collect it all and process it in one batch.

Stream sampling

picking a small representative subset from an endless flow of data when you can't store or examine every item.

Stream windows

grouping a continuous flow of data into time or count chunks (like "the last 5 minutes") so you can summarize each chunk.

Streaming leaderboards

scoreboards that update live as new results come in, keeping the top players ranked in real time.

Sudoku solvers

programs that fill in a Sudoku puzzle by trying numbers and backtracking whenever a choice breaks the rules.

Suffix arrays

a sorted list of all the endings of a piece of text, used to search large texts and match patterns quickly.

Symbol tables

a lookup structure a compiler or interpreter uses to remember every name in a program (variables, functions) and what each refers to.

Table column sort

reordering the rows of a table by clicking a column header to sort by that column's values.

Task assignment

deciding which worker, machine, or server should handle each job, often to balance load or minimize cost.

Task queues

a waiting line of jobs to be done, so work can be handed out to workers one at a time in order.

Task schedulers

systems that decide when and in what order pending jobs run, based on priority, timing, or available resources.

Taxonomy rollups

adding up values along a category tree so a parent category shows the combined totals of everything beneath it.

TCP flags

small on/off bits in network packets that signal the state of a connection, like starting, acknowledging, or closing it.

Template engines

tools that fill placeholders in a page or document with real data to produce the final text, used to build web pages from data.

Test matrices

a grid of all the combinations (browsers, versions, settings) that software is tested against to catch problems in each case.

Text cleanup

removing unwanted characters, extra spaces, or bad formatting from text so it's consistent and ready to use.

Text diff

a comparison that shows exactly which lines or words were added, removed, or changed between two versions of text.

Text editors

programs for writing and editing plain text or code, like Notepad, VS Code, or Vim.

The DOM

the browser's live, tree-shaped model of a web page that code can read and change to update what you see.

Tier

how much of the hard part is on you for a step: write the core yourself (1), fix a planted bug (2), or review working code (3).

Time complexity

how fast the amount of work grows as the input gets bigger.

Time-series alerting

watching a stream of measurements over time and raising an alarm when a value crosses a set threshold.

Time-series rollups

summarizing measurements collected over time into coarser buckets (like per-minute into per-hour) to save space and speed up charts.

Time-series stores

databases built to hold measurements stamped with times, like server metrics or sensor readings, and query them by time range.

Timer wheels

a data structure that groups many pending timers into slots on a rotating wheel, so a system with thousands of timeouts can fire them efficiently.

Timsort

a fast sorting method that combines merge sort and insertion sort, used as the default sort in Python and Java.

Tokenizers

tools that split text into meaningful pieces (words, symbols, or subwords) so a program or language model can process it.

Top-k queries

requests that return only the highest (or lowest) k items, like the 10 best-selling products, without ranking everything else.

Topological sort

putting tasks in an order where nothing starts before the tasks it depends on. Like getting dressed: socks before shoes.

Trading analytics

the calculations and charts traders use to study prices, volumes, and trends and decide when to buy or sell.

Trading dashboards

live screens that show a trader current prices, positions, and key metrics all in one view.

Trading SMAs

simple moving averages of a stock's price over a recent window of days, used to smooth out noise and spot trends.

Transitive closure

working out every point reachable from every other point in a network, following the connections step by step.

Tree

items linked in a branching shape, each with one parent and some children, and no loops. Your computer's folders are a tree.

TreeMap

a Java collection that keeps its keys in sorted order, so you can look up entries and also ask for ranges or the next-larger key.

Trending topics

the subjects being mentioned most often right now on a platform, computed by counting recent activity.

Trie (prefix tree)

a tree built from the letters of words, so you can look up everything starting with "ca…" fast. It's what powers autocomplete.

Two pointers

two markers moving through a list (from both ends, or at different speeds) so you make one pass instead of checking every pair.

Two-shift scheduling

assigning workers to two work periods (like day and night) while respecting who is available and the rules for each shift.

Undo/redo

the feature that steps your changes backward and forward, letting you take back a mistake or reapply it.

Union-find (disjoint set)

keeps track of which items belong to the same group, and merges two groups or checks "same group?" almost instantly.

uniq command

a Unix command that collapses or filters repeated adjacent lines in text, usually after sorting.

Unique visitor counts

the number of distinct people who visited a site, counting each person once no matter how many times they came.

Unix permissions

the settings on Unix and Linux files that control who can read, write, or run each file.

Uptime monitoring

regularly checking that a website or service is still responding, and alerting someone when it goes down.

User dictionaries

a personal word list a spellchecker learns from you, so your own names and terms stop being flagged as errors.

V8 engine

Google's software that runs JavaScript, used inside the Chrome browser and Node.js to execute web and server code fast.

Vending machines

the coin-and-button machines that dispense snacks or drinks and calculate the change to return.

Version lookup

finding which version of a file, package, or record applies at a given point, often among many stored versions.

Version merge

combining two edited versions of the same file into one, keeping both sets of changes where they don't conflict.

Video editing

assembling and trimming video clips, adding effects and audio, and exporting the finished video.

Virtual-DOM diffing

comparing a lightweight copy of a web page's structure before and after a change to update only the parts that actually differ.

WeakMap caches

a JavaScript store that ties cached data to objects and lets it be discarded automatically when those objects are no longer used, so the cache doesn't leak memory.

Web crawlers

programs that follow links from page to page across the web to collect content, used by search engines to build their index.

Wire formats

the agreed byte layouts for packaging data so it can be sent between programs or over a network and read back correctly.

Word puzzle games

games like crosswords or word searches that involve finding, forming, or arranging words.

XOR checksums

a small check value made by combining all the bytes with XOR, used to catch accidental corruption in stored or transmitted data.

Zip codes

the postal codes that identify a delivery area, used to sort and route mail and to look up locations.