Adjacency-Aware

Standard freeform crossword placement treats the problem as one of finding shared letters between words: two words can cross if they share a letter at compatible positions. The greedy algorithm picks the best crossing it finds and moves on. This produces grids where words intersect but rarely touch side-by-side, since parallel adjacency creates 2-letter perpendicular fragments that cannot be validated as complete words in a single pass.

The Adjacency-Aware strategy addresses this with a two-phase approach. In Phase 1, words are placed using both perpendicular intersections and parallel adjacencies. Parallel placements create 2-letter column pairs that are provisionally accepted if the pair is an attested bigram (consecutive letter pair appearing in at least 0.1% of dictionary words). Phase 2 then scans for those 2-letter fragments and attempts to extend each into a real dictionary word of length 3 to 7.

This two-phase design resolves a chicken-and-egg problem inherent to parallel placement. Two words placed side-by-side always create perpendicular columns of exactly 2 letters, which are too short to validate as real words during placement. Rather than rejecting all such placements (which eliminates parallel adjacency entirely) or accepting them unchecked (which produces gibberish), the algorithm defers final validation to Phase 2, where dictionary words can bridge the gaps.

The resulting grids contain both the user's original words and a set of dictionary fill words. The fill count is capped at 75% of user word count to prevent dictionary-dominated layouts. Because the grid contains more total words than other strategies, its raw intersection count is higher, though some portion of that increase is attributable to the additional fill words rather than more efficient placement of the original words alone.

Walk through a placement

Step through the algorithm's most distinctive move: fitting two words side-by-side when they share no letters.

How It Works

1. 1

   Build validation sets

   Combine the user's word list with the built-in crossword dictionary (approximately 42K entries, filtered to words of 3 to 8 letters with a quality score of at least 60). Build two data structures: a valid-word set for verifying that 3+ letter perpendicular runs are real words, and a frequency-filtered bigram set for provisionally accepting 2-letter perpendicular pairs during Phase 1. The bigram frequency threshold is max(3, 0.1% of combined word count).

2. 2

   Phase 1: Place user words with parallel adjacency

   Order words by graph connectivity (same ordering as Densest Crossings). For each word, enumerate both intersection placements (perpendicular to existing words at shared-letter positions) and parallel placements (same direction as an existing word, offset by one row or column). Validate each candidate: 2-letter perpendicular runs must appear in the bigram set; 3+ letter runs must be complete words in the valid-word set. Score candidates by intersections (weight 10), valid 3+ letter perpendicular words formed (weight 8), fillable 2-letter gaps (weight 2), and open anchor cells (weight 1). Place the highest-scoring valid candidate.

3. 3

   Phase 2: Fill perpendicular gaps from dictionary

   Scan the grid for all maximal contiguous letter runs of exactly 2 letters that are not already covered by a placed word in that direction. For each gap, search the dictionary for a word of length 3 to 7 that passes through those existing letters at some alignment offset. The candidate must satisfy the same perpendicular validation as Phase 1. Place the first valid match found. This pass runs once with no cascading (newly placed fill words do not trigger additional gap scans). Total fill words are capped at max(3, 75% of user word count).

4. 4

   Score and rank results

   Across multiple randomized attempts (default 16), collect distinct layouts (deduplicated by word-position signatures) and rank by total intersections, then total words placed, then compactness (grid area divided by placed words). The top layouts are returned.

Pseudocode

// === Phase 1: Place user words ===
validWords = buildSet(userWords ∪ dictionary)
bigrams = buildFrequentBigrams(userWords ∪ dictionary)
// threshold = max(3, floor(|combined| × 0.001))

function isValid(word, row, col, dir, cells):
    for each empty cell with perpendicular neighbors:
        run = walkFullPerpendicularRun(cell)
        if len(run) == 2 and run not in bigrams: return false
        if len(run) >= 3 and run not in validWords: return false
    return true

function score(word, row, col, dir, cells, dict):
    for each 2-letter perp run:
        if canExtendToWord(run, dict): fillableGaps++
        else: unfillableGaps++
    return intersections × 10 + validPerpWords × 8
         + fillableGaps × gw - unfillableGaps × gw × 2
         + openAnchors × 1

for word in graphGuidedOrder(words):
    candidates = intersectionPlacements ∪ parallelPlacements
    best = candidates.filter(isValid).maxBy(score)
    if best: place(word, best)

// === Phase 2: Fill gaps with dictionary ===
gaps = findShortRuns(grid, placed)  // 2-letter fragments only
maxFill = max(3, floor(|placed| × 0.75))
for gap in gaps (until maxFill reached):
    for wordLen in 3..7:
        for alignment of gap within word:
            match = dictionaryLookup(constraints)
            if match and isValid(match):
                place(match, isFill=true); break

Complexity

Phase 1: O(W² · L³ · D) for candidate enumeration, where D is the dictionary lookup cost per candidate cell. Each cell in a parallel placement candidate checks whether its 2-letter perpendicular run can be extended into a real dictionary word (length 3 to 7), requiring a scan of the relevant dictionary bucket. Inline fill adds O(G · 5 · D_L) per parallel placement, where G is the gap count, 5 is the word-length range tried, and D_L is the average bucket size (~7K words). Total observed: 126ms for 9 words, 782ms for 40 words, 5.1s for 156 words (measured in single-threaded JS, no Web Workers).

★ Best across all four strategies on this scenario. Reproducible via scripts/benchmark-strategies.ts.

Metric Definitions

Each benchmark run executes 16 randomized attempts of the strategy and returns up to 4 distinct layouts, sorted by quality. This process is repeated 3 times to reduce variance. The metrics below describe how each column is derived from those runs.

Best ×

The highest intersection count from the top-ranked layout across 3 independent runs. An intersection is a grid cell shared by two words (one across, one down). Higher is better.

Avg ×

The mean intersection count across all returned layouts (up to 4 per run), averaged over 3 runs. This includes second- through fourth-best layouts, so it reflects consistency rather than peak performance.

Placed

The most words placed on the grid in any top-ranked layout. For Adjacency-Aware, this includes dictionary fill words from Phase 2, so it can exceed the input word count. Shown as placed/input.

Compactness

Grid bounding-box area (rows times columns) divided by the number of placed words. Lower values indicate denser packing. Note that this measures the full bounding box, which includes empty cells between words. Adjacency-Aware's denominator is inflated by fill words.

2-Letter Frags

The number of 2-letter contiguous letter runs in the best grid that are not covered by any placed word in that direction. These are perpendicular fragments left behind by parallel placements that Phase 2 could not extend into complete dictionary words. Only applicable to adjacency strategies; always 0 for other strategies since they never place words in parallel.

Fill Words

The number of dictionary words added in Phase 2 to extend 2-letter gaps into complete words. These are not from the user's word list. Capped at max(3, 75% of user word count). Only applicable to adjacency strategies.

Time

Wall-clock time for one run (16 randomized attempts), averaged across 3 runs. Measured in single-threaded JavaScript without Web Workers. Includes ordering, candidate enumeration, validation, and (for Adjacency-Aware) Phase 2 gap filling.

When to Use This

• •You want a dense, interlocking grid and are willing to accept dictionary fill words alongside your own word list
• •You prefer the newspaper-style crossword aesthetic where words touch side-by-side, not just at perpendicular crossings
• •Your word list has enough common letters that parallel placements can form plausible bigrams for Phase 2 to resolve

Other Strategies