Parallel-Seeded

A variant of Adjacency-Aware that begins by finding the best pair of words to place side-by-side. The pair is selected by scoring all word pairs at every alignment offset, counting how many valid bigram columns each alignment produces. The highest-scoring pair becomes the grid's initial structure.

The key difference from the base strategy is inline gap filling: after each parallel placement, the algorithm immediately scans for 2-letter fragments and fills them while the surrounding grid is still sparse. This produces a virtuous cycle where early fill words provide crossing points for subsequent user words, and the looser constraints at fill time allow more gaps to be resolved.

This approach produces the fewest 2-letter fragments of the adjacency strategies. On a 156-word list, inline filling reduces fragments by roughly 43% compared to deferred filling, while placing the same number of total fill words.

How It Works

1. 1

   Find the best parallel seed pair

   For every pair of words, try placing them side-by-side (row 0 and row 1) at every column offset where they overlap. Score each alignment by counting valid bigram columns. Select the pair and offset that maximizes valid bigrams.

2. 2

   Place remaining words with inline fill

   After placing the seed pair, continue with graph-guided ordering. For each word, evaluate both perpendicular and parallel placements. After each parallel placement, immediately scan for 2-letter fragments and fill them from the dictionary. This catches gaps early while surrounding constraints are minimal.

3. 3

   Final fill pass

   After all user words are placed, a final gap-filling pass catches any remaining 2-letter fragments from the last few placements. The total fill budget (75% of user word count) is shared across inline fills and this final pass.

Pseudocode

function findBestParallelSeed(words, bigrams):
    bestScore = 0
    for each pair (A, B) in words:
        for shift in range:
            validCols = count columns where A[i]+B[i+shift] in bigrams
            if validCols > bestScore:
                bestPair = (A, B, shift)

// Place seed pair, then for each subsequent word:
for word in graphGuidedOrder(remaining):
    best = maxScore(intersections ∪ parallelPlacements)
    place(word, best)
    if best.isParallel:
        // Inline fill: resolve gaps immediately
        gaps = findShortRuns(grid, placed)
        for gap in gaps:
            fill = dictionaryLookup(gap)
            if fill: place(fill, isFill=true)

Complexity

Seed selection: O(W² x L) for all pair/offset combinations. Placement: same as Adjacency-Aware plus O(G x D_L) inline fill per parallel placement. Total observed: 129ms for 9 words, 902ms for 40 words, 5.2s for 156 words.

★ 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 the densest possible grid with minimal 2-letter fragments
• •Your word list has at least two words that share common bigram patterns when placed side-by-side
• •You're willing to accept slightly longer generation time for better fragment resolution

Other Strategies