Skip to content
Lizely

Speed Sorting Game

Sort five original queues by explicit numeric rank using drag, touch exchanges, or keyboard swaps, then clear the fixed 1,000-point route.

Privacy: your files never leave your device. All processing happens locally in your browser.

How to use

  1. 1.Read every printed rank, then identify the lowest card and the ascending sequence that should run from left to right.
  2. 2.Drag a card onto another, tap two cards to exchange them, or select a card with Enter or Space and move it with an Arrow key.
  3. 3.Choose Check ascending order after the full rail is sorted. Clear five fixed manifests for exactly 1,000 points.

About Speed Sorting Game

Speed Sorting Game is a five-round ordering puzzle built around printed numeric ranks rather than color matching or hidden visual interpolation. Each round places five to seven original cards on a dispatch rail. Every card shows a short manifest label and its exact signed, decimal, or integer rank. Your job is direct: rearrange the entire line from the lowest rank on the left to the highest rank on the right, then check the manifest.

The five fixed rounds introduce different readable formats without changing the core rule. Parcel Queue begins with compact positive parcel codes. Signed Intake mixes negative and positive values, so a more negative number belongs farther left. Decimal Dispatch uses explicit decimal ranks. Rack Ledger and Final Freight use padded abstract labels while also printing their underlying numbers. Labels are identifiers only; numeric rank always controls the order. No card depends on hue, brightness, color perception, an image, or an unstated category.

This makes the game materially different from Color Gradient Puzzle. That puzzle reconstructs a sequence along a color arc. Speed Sorting Game never interpolates colors and never asks a player to infer an invisible step. It presents exact text and numbers that remain readable with monochrome display settings, reduced color vision, browser zoom, and assistive technology. The only target is strict numeric ascending order, and every round has unique ranks, so each fixture has exactly one valid final sequence.

Pointer users can drag one card onto another to exchange their positions. Touch users do not need browser drag support: tap one card, then tap a destination card to perform the same exchange. Keyboard users Tab into the rail, move focus with the Arrow keys, press Enter or Space to select a card, and then use an Arrow key to swap it with the neighboring slot. All three input paths use the same pure swap reducer, preventing one control method from silently applying different ordering rules.

The selected card is visibly lifted and exposes its selected state through a native pressed attribute. Every card button has a minimum target height above 44 pixels, a visible focus ring, a printed slot number, an exact rank, and an accessible label containing its current position. Roving focus follows the logical cursor after a keyboard swap. When a correct manifest opens the next round, focus moves to the first new card. Completion or deadlock moves focus to the readable status message. Initial page load does not move focus.

Checking a correct line awards exactly 200 points and loads the next fixed manifest. Five correct rounds produce the fixed maximum score of 1,000. The score is not affected by moves, device speed, animation timing, or input method. The game is intentionally untimed so automated checks and real players are not punished by a slow browser, background scheduling, assistive navigation, or a temporary interruption. The word speed describes a self-directed sorting challenge, not a measured reaction time.

An incorrect check remains repairable. The game records a failure signature made from the current round and exact displayed card order. Checking the same unchanged wrong order again does not create a second error. After rearranging the cards, a different wrong order creates a second distinct failure and closes the run. This makes retry behavior deterministic: a duplicated action cannot consume another miss, while a genuinely different failed arrangement can. Correct completion, deadlock, and invalid actions freeze all scoring and ordering transitions until Restart.

The production fixtures store literal card IDs, labels, ranks, and unsorted opening permutations, but no answer field or stored correct order. At check time, the engine makes a fresh copy of the round cards, sorts by rank, derives the target IDs, and compares that target with the displayed order. Unique-rank invariants guarantee one ascending target. The UI never adds a pre-submit correct marker, answer class, hidden solution label, or answer-bearing data attribute.

Independent tests own a second literal list of all five rank sets and starting permutations. The oracle sorts those independent pairs numerically and verifies each derived production target, unique ranks, and a deliberately unsorted opening. It then solves all five rounds using the same public swap reducer used by drag, touch, and keyboard controls, proving exact 200-point progression to 1,000. Separate checks cover invalid IDs and destinations, cursor boundaries, repeated wrong-order deduplication, a second distinct error, Restart equality, and frozen terminal states.

Everything runs locally in the browser with React and ordinary buttons. No card data is uploaded, no account is required, no API is called, and no new dependency is loaded. The shared GameShell supplies local best-score storage, Restart, and the double-Escape Boss Key. If local storage is unavailable, only the optional best score disappears; the five manifests and their deterministic results are unchanged.

Speed Sorting Game is recreational entertainment. It is not a reaction-time test, cognitive assessment, intelligence score, educational placement tool, workplace performance measure, medical screen, or accessibility diagnosis. Its ranks, labels, permutations, scoring, and failure rules are authored game fixtures without population norms or external benchmark meaning.

Methodology & sources

Use five original fixed manifests containing unique, explicit numeric ranks and deliberately unsorted opening permutations. Derive each sole target at runtime by copying the cards, sorting strictly by numeric rank, and comparing the resulting card IDs with the displayed line; store no answer or correct-order field. Route native pointer drag, touch two-card exchange, and keyboard selected-card movement through one pure swap reducer. Award exactly 200 points per correct manifest for a fixed maximum of 1,000. Build wrong signatures from round plus exact order so an unchanged retry deduplicates, while a second distinct wrong order deadlocks. Freeze every reducer after completion or deadlock and make Restart equal the initial state. Keep the game untimed, local, text-readable, dependency-free, and explicitly non-diagnostic. Independent literal oracle fixtures verify all five unique ascending targets, shared input reducers, invalid-action atomicity, wrong-order repair and deduplication, terminal freezing, and the exact full-score path.

Frequently asked questions

Is this the same as the Color Gradient Puzzle?
No. This game uses explicit text and numeric ranks with one strict ascending order. It never uses hue, brightness, color interpolation, or a hidden visual step.
How do touch and keyboard controls work?
On touch, select one card and then a destination card to exchange them. With a keyboard, select a focused card using Enter or Space, then use an Arrow key to swap it with a neighboring slot.
Does the score measure reaction speed or cognitive ability?
No. The game is untimed recreational entertainment with fixed authored ranks. It is not a reaction, cognitive, educational, workplace, medical, or diagnostic assessment.

Related tools

Mini Games guides

View all