Search the collection

• A band as wide as the answer
• A cell that has to know where it is
• A cost that is not one
• The cost is the number of subproblems
• The same table, filled two ways
• The cells are not the cost
• The argmin that cannot go backwards
• The order that has a depth
• The cells that were never worth having
• The zero that moves the answer out of the corner
• A distance divided by a length is not a rate
• The edit that reaches back two rows
• The matrix a corpus wrote
• The parameter plane has few answers
• A triangle stored in a square
• The split scan cut into blocks
• The bound the search finds for itself
• The ties a rounded matrix makes
• The bound a block can and cannot have
• The lattice that decides the ties
• The columns the candidates share

• A bucket that becomes a tree
• A sketch that is allowed to be under
• A tree with nodes the size of a block
• Building a heap from the bottom
• Choosing a growth factor
• Every substring, in fewer states than substrings
• The bill a partition only divides
• The count that outlives its arrivals
• The counter that takes the smallest slot
• The fold that minimises the wrong thing
• The index that is the text
• The items that survive k counters
• The order nobody fixed
• The priority nobody supplied
• The probe nobody waits for
• The shape one structure will not fold
• The shape that moves the bill
• The summaries that add
• The tree that is a list
• What amortised means
• A rectangle over a permutation
• The shape a range question is about
• The runs a permutation does not leave
• One revision, one level
• The tree the operation insists on
• A document already in the answer
• The price of a boundary is what precedes it
• The last array in the apparatus
• The branches that find nothing
• A position split in two
• Bits and steps on one frame
• Every copy points right
• Two states per operator

• A column computed in machine words
• A search with no branch to miss
• Rank is the only thing it does
• Select is not rank backwards
• The branch the machine guesses
• The cliff where the data stops fitting
• The count is not the time
• Two searches, one comparison count
• Where an algorithm looks
• Where insertion sort actually wins
• A function with r pieces
• The table that fits inside a block
• The count that was already there
• A node costs two ranks
• Twenty bits apart
• What a character costs on four machines
• The order with the best depth
• Two probes are two misses
• The bucket that fits a line
• The table stored the way it is filled
• A lookup that stops caring how wide an entry is
• Eight cells at once

• A count read off the leading zeros
• A count that is never under
• A register that became a list
• An error measured against the answer
• A window that is a duration
• Counting past what the register holds
• The answer that is allowed to be wrong
• The bits that say when
• The correction that makes it work
• The counter with no window in it
• The error that is on the rank
• The estimate that squares the stream
• The floor a histogram already knows
• The partition the analysis did not mention
• The period that is not a promise
• The state a merge is standing in for
• The summary that has to forget
• The tuples a merge does not give back
• The window that is even in the wrong currency
• The error of a difference
• A decay measured from where it started

• A distance that is a path through a grid
• One pass for every pattern at once
• The comparison that is not one comparison
• The entropy that cannot see a copy
• The filter that feeds the table
• The model is the compressor
• The row that starts at zero
• The shift a set of patterns allows
• The shift the pattern already knows
• The text that answers without reading it
• The transform that emits nothing
• The phrases a text copies from itself
• The occurrences that cross a boundary
• The q-grams an error cannot destroy
• The shift somebody published
• A parse that will not follow a long chain
• The errors the rest of the pattern needs
• The table the links already knew
• The search that starts in the middle
• The parse in one pass of the text
• A corpus that was not generated
• A million characters of the same thing
• The shape of a real history's depth
• The cell nobody filled
• What repetition is worth once the logarithm is gone
• The array is the length distribution

• A distance that is not a distance
• A parameter that waits for another
• A promise about the rank is not a promise about the value
• A table wider than its input
• In place is a claim, and it is usually wrong about quicksort
• The words "on average" are not a number
• The adversary who knows the seed
• The block that is not a block
• The boundary that hides the burst
• The ceiling the shortest pattern sets
• The digest that promises nothing
• The filter that proposes everything
• The floor a merge does not settle at
• The formula everybody sizes filters with
• The guarantee that is one query wide
• The histogram that cannot see the order
• The invariant that was wrong for seven years
• The optimal code that is beaten
• The probe formula nobody checks
• The promise that does not survive the tree
• The warning that is silent for the right reason
• The window that is not full
• Two structures that are one
• What randomising the pivot buys
• When the stream takes it back
• The sampler that cannot alias
• A sampling that costs more than the array
• The measure that cannot see the alphabet
• The threshold that reaches zero
• Three savings in three currencies
• What the approximation gives up
• The operations a candidate count leaves out
• The cap that binds on one text and not another
• The pruning that loses an occurrence
• The ratio that was an implementation
• The occurrences a join invents
• A schedule nobody writes down
• The level where compression stops paying
• What a quadratic construction was setting
• The dial that has no setting
• The half of a fall that is the logarithm
• The deepest text is punctuation
• A sixth of what, exactly
• A boundary that costs nothing
• One copy per document is one occurrence per document
• A saving quoted without its collection
• One set, three orders
• A walk that does not prune
• Where the sparse representation loses
• A price with no structure under it
• Two factors that do not multiply
• A constant factor, not a term
• A cache below the reachable set
• The folklore is about a matcher

• A filter that is allowed to be wrong
• A hash is a family, not a function
• A match decided by a number
• A structure made of coin flips
• One pass, k slots, and two randomness budgets
• The estimate that is a median of means
• The height is a distribution, and the coin is a parameter
• The independence an estimator spends
• The second choice
• An insertion that can fail
• The evidence a filter cannot remove
• The intersection two filters cannot report
• More hashes or wider buckets
• The tie that breaks left
• A filter past its design size
• Choices that are not independent
• A filter that grows by moving a bit
• Two hash values and the keys they copy
• The bits given to the wrong keys
• Positions confined to one line
• Two blocks and the chances they add

• A floor on the bits
• A floor one pass cannot get under
• A floor that holds if something else does
• A floor under a run count
• A floor with two variables in it
• How close anything gets to the floor
• The adversary who hides the edge
• The bits a coder emits
• The floor charged at every level
• The floor moves when the question does
• The floor under a summary
• The floor under a window
• The floor under every comparison sort
• The floor under moving data
• The floor when the values repeat
• The pass that runs the other way
• Work that falls as the answer grows
• Proportional to the answer, not the alphabet
• From the right, two of sixteen
• What a reordering costs to undo
• Every pair must be asked
• The floor a merge cannot reach
• The order inside a tie

• A limit is not a prediction
• Expected is not average
• The constant the notation drops
• The depth limit that almost never fires
• The model a bound was quoted in
• The pass that was never a parameter
• What a fold charges per level
• What derandomising costs
• What O-notation does not say
• The branches an error opens
• The table that walks every pair
• The case a failure link does not cover
• The cost that is the size of the answer
• The branch that cannot reach an answer
• Where a crossing moved to
• The cap an automaton cannot see
• A factor of fourteen, for four per cent
• A code word is at least one bit
• Two at binary, five at twenty-six
• The flat bottom of a shallow curve
• Flat in the budget, and not
• The exponential is in the expression

• A list and a block of memory
• Counting on a graph
• The bound with a precondition
• The constant that is practically constant
• Two parameters, one bound, no order
• The queue decides the class, and the pseudocode does not name it
• The precondition that removes the queue
• Two passes or one, and what the second one costs
• The precondition on a function the caller writes
• Two parameters are not enough either
• An estimate borrowed from an easier problem
• A graph is as hard as its largest cycle
• An estimate is a reweighting
• Where two searches should stop
• A bound right for the wrong reason
• Two estimates that must agree
• One Bellman–Ford buys every Dijkstra
• Where the landmarks stand
• What the queries know that the map does not
• A stop that is correct and never sooner
• How long a reweighting stays true
• A potential mended where it broke

• A run is a property of the input
• Sized for a rate that does not hold still
• The dictionary that builds itself
• The fading nobody computes
• The pattern that defeats the pattern
• The sort the library ships
• The threshold somebody chose
• When galloping pays
• The rule that pays on a long enough text
• Where the exact rules pay now
• The number that would choose a cap
• What the generated collection was right about
• The crossing that never arrives
• The cap that would ship
• The saving, spent
• The apparatus that is smaller than its index
• A collection is a construction
• The smaller tree hands it back unsorted
• A looser budget wastes a larger share
• The floor was the marks
• The saving that is a loss
• The scan the order does not touch
• Where the table starts paying

• A search that runs backwards
• An index larger than what it indexes
• The index that is smaller than the text
• The index that stores the runs
• The sampling that goes the other way
• The sampling that follows the runs
• The occurrence carried through the search
• An index with z in its size
• The search that spends a budget
• The collection decides which index is small
• The candidates a filter cannot avoid
• What a ceiling costs in phrases
• A list of documents is not a list of occurrences
• An interval that grows at both ends
• A block, a class and an offset
• Documents that are not the same length
• Two thousand documents of two hundred characters
• The half that is never asked where
• Every child at once
• The array the walk never reads
• The index that does not notice
• The tree answers the question
• Asking about symbols that are not there
• What the locating apparatus becomes
• Three savings on one structure
• The same occurrences, less bookkeeping

• Counting instead of timing
• Counting the coin flips
• Fitting a class to measurements
• One run, four counts, four answers
• The count somebody chose
• Two pivots and what they cost
• The exchange rate nobody wrote down
• The count that came from somewhere else
• A distribution computed rather than sampled
• A count over every input
• The worst case found by climbing
• A worst case ten positions wide
• The sort whose count has no distribution
• The count of the part that was read
• The order equal keys keep
• The sort that makes none of them
• Two floors that can be added
• The questions a sort asks twice
• The price of remembering an answer
• The comparisons that name the answer

• Measuring what an algorithm keeps
• The alignment that fits in one line
• The cheap tail and the expensive merge
• The clock that cannot see the burst
• The frontier between time and space
• The space the model does not see
• The stack nobody counts
• The table nobody has to keep
• The text that does not have to be kept
• The tuples a summary does not report
• What a second pass buys
• What a window costs in bits
• What is still proportional to n
• Every occurrence at the same price
• The character that costs a chain
• The structure paid for before the first query
• The term that came back
• A bound that has to be paid for
• One separator, or one for each
• Two bits a value, and what undoes them
• The structure that was supposed to halve
• A bit for every bit
• An index that cannot locate
• What the chain cost
• Two currencies for one separator
• The apparatus, three times smaller again
• The array that says where is twice the samples
• The ladder, and the rung that spends
• Half an index is three permutations

• One access, eight kilobytes
• Sorting what will not fit
• The layout that is told nothing
• The writes nobody counted
• One dial between two structures
• Permuting is the harder problem here
• The index that is not worth reading
• Two ways to join, and the ratio that decides
• The estimate a plan rests on
• The permutation that moves almost nothing
• The join order is a guess
• The filter each run carries
• The skew a few counters cannot repair
• What insurance against an estimate costs
• Runs twice as long as memory
• The keys that arrive late
• What a planner pays to find out what to pay
• The sibling a full leaf asks first
• A summary's silence is a bound, not a count
• The read a filter has no key for
• A key passed along the row