brain

The conditions mean that $KA \perp AB$, $KC \perp CD$, $HB \perp AB$, and $HD \perp CD$.

The quantity $T_k(n)$ is the $k$-th elementary symmetric polynomial in the numbers $1,2,\dots,n$:

Let the $n$th triple be $(a_n,b_n,c_n)$, with

Consider a rectangular parallelepiped with edges of length $a$, $b$, and $c$.

The graph described by Fig.

The problem asks for the maximal number of rooks or queens on an $8 \times 8$ chessboard such that each piece is attacked by at most one other piece.

Label the $n$ equal elementary arcs by the colors of the segments

Consider a simple case of a triangle circumscribed around a circle, where the inscribed circle is tangent to its sides at points $A', B', C'$.

The inequality can be written as

Consider first a simple case: a triangle circumscribed around a circle, with the incircle touching the sides at points $A'$, $B'$, and $C'$, forming the inscribed triangle.

Consider small cases of numbers of the form $0.

Consider a regular octagon with side length $a$ placed on a plane.

Represent friendship by a graph $G$ whose vertices are the knights, with an edge joining two friends.

Consider a cube $ABCDA'B'C'D'$ with an inscribed sphere, whose center coincides with the cube's center and whose radius is half the cube's edge length.

A $6 \times 6$ square contains $36$ unit squares.

Consider the task of placing $N$ points in the plane such that the distance between any two points $M_i$ and $M_j$ is a given number $r_{ij}$.

The desired inequality can be rewritten as

Denote the sides opposite $A_1,A_2,A_3$ by

Let points $A$ and $B$ be fixed on the plane, and let $C$ lie on the perpendicular bisector of segment $AB$, since it must satisfy $|AC| = |BC|$.

Let

For the first part, the numbers involved are all two-digit numbers, so each number can be represented as an ordered pair $(a,b)$ with $a,b \in {1,2,\dots,9,0}$, $a\neq 0$.

Consider a lion moving along a polygonal path inside a circular arena of radius $R = 10$ meters.

Consider a small case to understand the process.

Consider the equation $n^x + n^y = n^z$ in natural numbers.

Let the side length of the equilateral pentagon be $1$, and let its consecutive vertices be $A_1,A_2,A_3,A_4,A_5$.

Consider small values of $n$ first.

Place the square in the coordinate plane with vertices

Consider a die with faces numbered so that opposite faces sum to $7$.

Perfect numbers are rare and highly structured.

Consider an arbitrary compact planar blot.

The problem concerns a king moving on an $8\times 8$ chessboard, visiting every square exactly once, and returning to the starting square.

We are asked to compare the square of a sum of five positive numbers with four times a sum of specific pairwise products taken cyclically.

Consider first a triangle, the simplest convex polygon.

Consider a small patch of the grid with just one black cell at $(0,0)$.

Let the circle have center $I$.

We are asked whether an expert can convince the court, using only three weighings on a balance scale, that exactly seven out of fourteen coins are counterfeit.

The operation does not act on individual digits.

Let

Consider the problem geometrically by placing triangle $A_1 A_2 A_3$ in the plane and attempting to construct a triangle $M_1 M_2 M_3$ similar to a given triangle $B_1 B_2 B_3$ with the given side-ver…

Consider the matrix of size $24 \times 25$ with entries $0$ and $1$, where $1$ indicates that a student solved a problem.

Consider the total number of $n$-digit numbers, which is $9 \cdot 10^{n-1}$.

Let the arithmetic progression be

For part (a), the six points are the intersection points of four lines in general position.

We begin by examining the first sum for small values of $n$.

Consider first the smallest nontrivial case, a $2\times 2$ table with entries $a,b$ in the first row and $c,d$ in the second row.

Let

Consider a convex pentagon $ABCDE$ with vertices labeled consecutively.

Consider small analogues first.

Many search problems ask for more than membership.

A range query asks for information about a contiguous region of ordered data.

Many range-query structures support updates.

The most useful form of binary search is not exact lookup.

Binary search does not fundamentally require sorted data.

Most balanced tree structures maintain balance through carefully designed invariants.

Tree rotations are the primitive operation behind many balanced binary search trees.

AVL trees were the first self-balancing binary search trees.

Arrays are excellent when data rarely changes.

Binary search trees work well in memory, where following a pointer from one node to another is relatively cheap.

Segment trees are among the most versatile range-query data structures in algorithm design.

Most binary search examples begin with a sorted array.

Standard binary search assumes the entire array is sorted.

Binary search is often associated with sorted data, but some of its most elegant applications work on arrays that are not sorted at all.

A binary search tree provides an elegant framework for maintaining ordered data.

Lower bound finds the first position whose value is greater than or equal to a target.

A Fenwick tree, also called a binary indexed tree, is a compact data structure for prefix sums and point updates.

Before studying specific balancing algorithms such as AVL trees and red-black trees, it is worth understanding the structure they are trying to preserve.

Most discussions of search algorithms focus on in-memory collections.

Many search problems involve ranges rather than individual values.

Balanced trees provide logarithmic performance through carefully maintained structure.

Parametric search is a technique for solving optimization problems by repeatedly answering decision questions.

Binary search is a boundary-finding algorithm.

Red-black trees are self-balancing binary search trees with a relatively loose balance condition.

The examples in previous sections searched integer domains.

Design a small workflow for checking an algorithm's correctness argument against its implementation.

Design a plagiarism detector that compares documents and reports suspicious similarity.

Design a geometry query engine that stores spatial objects and answers geometric questions efficiently.

You have learned dozens of algorithms and data structures.

Design a spell checker that detects misspelled words and suggests likely corrections.

Design a recommendation system that suggests items to users based on past behavior.

Design a small constraint solver that assigns values to variables while satisfying a set of rules.

Design an autocomplete engine that provides search suggestions while a user types.

Design a sorting tool that can sort data larger than available memory.

Design a cache that stores recently used values and evicts entries when capacity is full.

Design an event scheduler that stores tasks, orders them by time, executes ready tasks, and handles updates such as cancellation or rescheduling.

Design a static analyzer that scans source code and reports likely defects without running the program.

Design a crawler frontier that decides which URLs a web crawler should visit next.

Design a rate limiter that controls how often a client can perform an operation.

Design a matchmaking system that pairs users, players, tasks, or entities according to compatibility rules.

Design a batch job that analyzes a large graph and computes useful metrics such as degree counts, connected components, PageRank-style importance scores, and community structure.

Design a search ranking pipeline that receives a user query, retrieves candidate documents, scores them, and returns a ranked result list.

Design a system that consumes events continuously and computes live metrics such as counts, rates, unique users, moving averages, and top items.

Design a system that receives a stream of log events and removes duplicates before storage or analysis.

Design a compression tool that reduces the size of textual data while preserving the original information.

Design a small database index that supports fast lookup by key and efficient range scans.

Design a planner that receives a set of tasks and dependencies, then returns a valid execution order.

Design a simulation that routes packets through a network of routers and links.

Design a text diff tool that compares two versions of a document and reports what changed.

Design a service that answers shortest path queries over a graph.

A Count-Min Sketch estimates item frequencies in a stream using fixed memory.

Many approximation algorithms are built around a simple principle: make the best local decision available at each step.