Learn by Novus · Open practice pack v1

Perceptual speed: rapid checking practice: open practice pack: worked explanations

100 untimed questions across 10 authored sections.

This is untimed educational practice for one cognitive skill. It is not a clinical, diagnostic, employment, or professionally recognized assessment, and it does not produce an IQ score or credential.

Worked explanations

perceptual-speed-s01-q01

Compare each pair position by position. Only LEMON / LEMON agrees at every letter; the other pairs each add, swap, or change one letter.

perceptual-speed-s01-q02

Word endings are a common place for copy errors, so check them first: OCEAN ends in N but its partner ends in M. The other pairs match at every position.

perceptual-speed-s01-q03

Scan for length first, HORSE / HOARSE differ by a whole extra letter, then check the vowels, where TIGAR and ZEBRE both slip. CAMEL / CAMEL is the only exact match.

perceptual-speed-s01-q04

NICKEL and NICKLE contain the same letters, but the final two are swapped. Transposed letters are easy to miss because the words look alike at a glance.

perceptual-speed-s01-q05

Checking the last letter of each pair settles this quickly: PLUN, FIJ, and DATA all break at the final position, while PEAR / PEAR agrees throughout.

perceptual-speed-s01-q06

MAPLE and MAPEL swap their last two letters. Reading each word slowly, position by position, catches transpositions that a quick glance smooths over.

perceptual-speed-s01-q07

Every wrong pair here is a transposition: STROM, CLUOD, and FORST each swap two adjacent letters. Only SLEET / SLEET keeps every letter in place.

perceptual-speed-s01-q08

Counting letters is a fast first filter: INDIGIO has seven letters where INDIGO has six, because an extra I has crept in before the final O.

perceptual-speed-s01-q09

SADLE drops a D, BRIDEL swaps its ending, and HATLER transposes two middle letters. STIRRUP / STIRRUP is the only pair that survives a letter-by-letter check.

perceptual-speed-s01-q10

WNITER swaps the I and N near the start of the word. Errors early in a word are easy to skim past because the eye jumps to the familiar ending.

perceptual-speed-s02-q01

Three of the pairs swap their last two digits: a classic transcription slip. Only 7365 / 7365 agrees at every position.

perceptual-speed-s02-q02

7513 and 7531 contain the same digits in a different order. When digits repeat across a pair, check positions rather than just the digits present.

perceptual-speed-s02-q03

Each wrong pair here transposes its final two digits. Reading numbers in small chunks, 57 / 09 / 3, makes position swaps stand out.

perceptual-speed-s02-q04

20486 ends 8-6 while its partner ends 6-8. Comparing the endings of each pair first often finds the error before you have read the whole number.

perceptual-speed-s02-q05

Split each number into pairs of digits, 54 / 26 / 18, and compare chunk by chunk. Only 542618 / 542618 matches in every chunk.

perceptual-speed-s02-q06

621598 and 621958 share a start of 621 and an end of 8, but the middle digits 59 have been reversed to 95, the middle of a long number deserves the closest look.

perceptual-speed-s02-q07

At seven digits, chunking is essential: read 720 / 39 / 41 against its partner. The other pairs each transpose two digits late in the number.

perceptual-speed-s02-q08

2947016 carries 01 where its partner carries 10. Zeroes and ones sit low and thin on the line, so swaps between them are especially easy to overlook.

perceptual-speed-s02-q09

Compare in chunks of four: 2635 / 0918 against 2635 / 0918 agrees in both halves. Each other pair reorders two digits inside one half.

perceptual-speed-s02-q10

81734062 reads 34 in its third and fourth places while its partner reads 43. Matching digits in step, place by place, is the only reliable defence against mid-string swaps.

perceptual-speed-s03-q01

Scan once from left to right, counting only the 8s: they sit in the first, third, sixth, and eighth positions, giving four in total.

perceptual-speed-s03-q02

There are three: one early, one in the middle, one near the end. Saying the running count silently as you scan keeps the tally from drifting.

perceptual-speed-s03-q03

Five stars appear, including two side by side in the middle of the row. Adjacent repeats are the most common source of undercounting.

perceptual-speed-s03-q04

Six of the ten characters are e, including a double e in the middle. When the target dominates the row, it can help to count the non-targets instead: only four other letters appear.

perceptual-speed-s03-q05

Only two zeroes appear. Keep the target shape in mind while scanning so similar round digits such as 6, 8, and 9 do not get swept into the count.

perceptual-speed-s03-q06

There are five ms among visually similar ns and ws. Focus on a distinguishing feature, the m has three downstrokes where n has two, rather than overall shape.

perceptual-speed-s03-q07

Seven of the ten symbols are #, with runs of two and three together. Counting runs as groups (two, then three) is faster and safer than ticking one at a time.

perceptual-speed-s03-q08

Three sixes appear, spaced out across the row. The 9s are the trap here: a 9 is a 6 rotated, so confirm the opening of each loop before counting it.

perceptual-speed-s03-q09

Four ts sit among fs and ls, which share the same tall vertical stroke. The crossbar position is the distinguishing feature: the t is crossed lower than the f.

perceptual-speed-s03-q10

Spelling the word out letter by letter (A, U, T, O, M, A, T, I, O, N) gives vowels A, U, O, A, I, O: six in all. Counting a category is harder than counting one symbol, so slow down slightly.

perceptual-speed-s04-q01

Compare the number block across all four codes: three read 482 but one reads 842, with the first two digits transposed.

perceptual-speed-s04-q02

The odd code ends 17 where the others end 71. Scanning one character position at a time down the list exposes the difference immediately.

perceptual-speed-s04-q03

One code carries the letter Z where the others carry the digit 2. A classic look-alike substitution. Ask of each ambiguous character: letter or digit?

perceptual-speed-s04-q04

The month block is the difference: JNU transposes the letters of JUN. Familiar abbreviations are risky because the brain autocorrects them while reading.

perceptual-speed-s04-q05

The final letter pair is reversed in one code: rt instead of tr. Checking each block of a code separately (letters, digits, letters) narrows the search quickly.

perceptual-speed-s04-q06

One number starts 71 where the rest start 77. With repeated digits, count the run length, a double 7, before moving on to the rest of the string.

perceptual-speed-s04-q07

The last block reads 09 in one code and 90 in the others. Endings deserve a deliberate second glance because attention fades late in a string.

perceptual-speed-s04-q08

The letter block differs: mrn against mnr elsewhere. Low, rounded letters like m, n, and r blur together, so verify their order one letter at a time.

perceptual-speed-s04-q09

One code reads LK where the others read KL. Since the digit blocks agree everywhere, the letter block is the only place a difference could hide.

perceptual-speed-s04-q10

In the second block, one code carries QMN where the others carry QNM. In long codes, compare block by block rather than reading each code whole.

perceptual-speed-s05-q01

Check each candidate block against the master in turn: the wrong ones transpose the digits 48, the letters LX, or the letters VN. Only one agrees in all three blocks.

perceptual-speed-s05-q02

The letter block eliminates one candidate (DRK) and the digit block eliminates two more (3015 and 3501). Working block by block leaves a single exact match.

perceptual-speed-s05-q03

The traps are a 91-for-19 digit swap, an n-for-m substitution, and a w-for-v substitution. Comparing every character against the master, not just the overall shape, isolates the true match.

perceptual-speed-s05-q04

0405 and 0450 share the same digits, so position is everything; likewise TBG reorders TGB, and FE replaces one E. A per-character check confirms the single match.

perceptual-speed-s05-q05

Two candidates change only letter case (hN for Hn, and xr for xR), and one reorders 10 to 01. Case counts as part of the code, so treat capitals and lower case as different characters.

perceptual-speed-s05-q06

One candidate swaps 68 to 86, one reorders KLM, and one turns the letter Z into the digit 2. Only the first block-for-block match survives all three checks.

perceptual-speed-s05-q07

Check each code independently against the master: the first and third match, RTT doubles the wrong letter, and 950 reorders the digits. Two exact matches in total.

perceptual-speed-s05-q08

Only one code breaks: it opens 26 instead of 62. Verify every code even after finding an error. The question asks for a count, not the first mismatch.

perceptual-speed-s05-q09

The mismatch reads 3354 against the master's 3345: the repeated 3s make the swap of 45 to 54 easy to miss. Note the question asks for the code that fails, not the one that matches.

perceptual-speed-s05-q10

All four codes reproduce the master exactly. Expecting to find an error is itself a bias. Verify what is actually on the page rather than what you predict.

perceptual-speed-s06-q01

Substitute one letter at a time in order: C becomes 3, A becomes 1, B becomes 2. Keeping the original letter order is the whole task: resist reading the word as a unit.

perceptual-speed-s06-q02

B, E, A, D map to 2, 5, 1, 4 in that order. The wrong strings each contain the right digits but shuffle two of them. Check positions, not just membership.

perceptual-speed-s06-q03

Working letter by letter, P is 4, R is 2, O is 9, and M is 7. Reciting the mapping aloud for each letter prevents the middle letters swapping in memory.

perceptual-speed-s06-q04

Decode each number in sequence: 3 is S, 6 is T, 9 is A, 1 is R. All four options use the same letters, so only strict left-to-right decoding separates them.

perceptual-speed-s06-q05

2, 5, 8, 4 decode to F, L, O, W in that order. Anagram distractors punish anyone who decodes the letters and then rearranges them into the most familiar word.

perceptual-speed-s06-q06

S, L, I, D, E become 1, 6, 8, 4, 3. The last two letters are the trap: D is 4 and E is 3, and one distractor quietly reverses them.

perceptual-speed-s06-q07

Decoding strictly in order gives B, R, A, K, E. BREAK and BAKER use identical letters in a different sequence, so verify each position against the key before choosing.

perceptual-speed-s06-q08

G, R, O, W, N map to 3, 7, 1, 9, 5. The distractors transpose neighbouring digits, so confirm each substitution before moving to the next letter.

perceptual-speed-s06-q09

Taking the letters in order, C, H, A, I, R, S become 6, 2, 8, 4, 3, 9. With six substitutions, a rhythm of look-up-then-write for every letter keeps errors out.

perceptual-speed-s06-q10

P, L, A, N, E, T become 1, 4, 7, 2, 8, 5. The final pair is where most slips happen: E is 8 and T is 5, and reversing them produces one of the traps.

perceptual-speed-s07-q01

Compare first letters: a before b before c. Only the list running apricot, banana, cherry keeps every neighbouring pair in ascending alphabetical order.

perceptual-speed-s07-q02

Check each adjacent pair for an increase: 10 to 14 to 17 to 22 rises throughout. Every other list contains at least one step that falls.

perceptual-speed-s07-q03

Sorting gives aspen, birch, cedar, maple, so birch takes second place. Do the full sort mentally before answering: jumping straight to a position invites errors.

perceptual-speed-s07-q04

Sorted ascending the list reads 32, 41, 47, 58, so 47 sits third. Finding the smallest and largest first brackets the middle values quickly.

perceptual-speed-s07-q05

All four words share st, so order is decided deeper in: stack (a) precedes stone and store (o), stone precedes store because n comes before r, and store precedes straw because o comes before r.

perceptual-speed-s07-q06

Track the sequence pair by pair: it rises until 126, then drops to 121 before rising again. The entry 121 is the only one below its immediate predecessor.

perceptual-speed-s07-q07

All four begin An, so compare the next letters: d comes before s, which splits the group, and within the d pair Anders beats Andrews because e comes before r.

perceptual-speed-s07-q08

A descending list must fall at every step: 96 to 85 to 79 to 62 does. Each other list hides one pair that rises, so check every adjacent pair, not just the ends.

perceptual-speed-s07-q09

All share qua, so the fourth letter decides: i, r, r, v. The v of quaver comes latest, so quaver sorts after quartz and quarry without needing deeper comparison.

perceptual-speed-s07-q10

Strip the shared F- prefix and compare 096, 102, 110, 124 as plain numbers: only one list rises at every step. Leading zeroes change nothing about the value.

perceptual-speed-s08-q01

Check names first, then numbers: in the final row the house number 62 was copied as 26, with the digits reversed. Every other row reproduces its original exactly.

perceptual-speed-s08-q02

Invoice 30775 became 30757: the final digits 75 turned into 57. Numbers with repeated digits reward a slow, place-by-place comparison.

perceptual-speed-s08-q03

This question reverses the usual task: three rows contain errors (0129 for 0192, the digit 8 for the letter B, and 8814 for 8841), and only the first row survives unchanged.

perceptual-speed-s08-q04

Reference 66031 was typed as 66013, transposing the final two digits. Comparing references in two-digit chunks (66, 03, 1) makes the slip visible.

perceptual-speed-s08-q05

The errors are Whitfeild for Whitfield, 280 for 208, and the letters SS for the digits 55. The harbour address is the only row that matches its original character for character.

perceptual-speed-s08-q06

Seat 14C became 41C in the final row: a two-digit reversal that leaves the letter untouched. Short fields still deserve a full check of every character.

perceptual-speed-s08-q07

Three copies transpose a final pair: HP became PH, £1,206 became £1,260, and 0348 became 0384. Only the CT2 9QD row reproduces its original without change.

perceptual-speed-s08-q08

Extension 2291 was retyped as 2921: the middle digits changed order while the outer digits stayed put, which is why edge-only checking misses it.

perceptual-speed-s08-q09

Batch 7705-D became 7750-D: the 05 ending flipped to 50. The repeated 7s at the start lull the eye, so the check must continue through to the final digit.

perceptual-speed-s08-q10

The traps sit in different fields each time: Lindqvist lost its v, Orchard became Orchid, and 500218 became 502018. Only the first row matches in both name and number.

perceptual-speed-s09-q01

Scan for doubles: the row opens with a double s, and double e and double f follow, three adjacent pairs. The remaining letters all differ from their neighbours.

perceptual-speed-s09-q02

Test each code once: 371 and 749 each contain a 7, and 177 contains two, but the rule counts codes, not sevens, so 177 still counts once. Three codes qualify.

perceptual-speed-s09-q03

Check each word for a repeated adjacent letter: ballot has ll, meddle has dd, spoon has oo, and arrow has rr, four words in all. Gender and faith have none.

perceptual-speed-s09-q04

Only the final digit decides evenness: 68, 92, 30, and 86 end in an even digit, giving four. Ignore the leading digits entirely. They carry no information for this rule.

perceptual-speed-s09-q05

Compare only the first and last characters of each code: 4TR4, S22S, and M40M wrap with a matching character, while 9KL8 and 7GH2 do not, three codes qualify.

perceptual-speed-s09-q06

Look for the ordered pair 1-then-2: it occurs three times. The 2 followed by 1 near the end does not count. The rule is directional, so order matters.

perceptual-speed-s09-q07

Apply both halves of the rule to every string: K84, M2, and XL5 mix letters with digits, while RTV is all letters and 209 and 771 are all digits, three strings qualify.

perceptual-speed-s09-q08

Count the letters of each word rather than judging length by eye: crate, plume, shard, gleam, and frost all have exactly five, while mist has four and tin has three.

perceptual-speed-s09-q09

Add each pair and compare with 10: 4 + 6, 5 + 5, and 1 + 9 hit the target, while the other three pairs give 9, 11, and 11, three qualifying pairs.

perceptual-speed-s09-q10

Tally each character: T, 4, K, and 9 all appear twice, and only M appears once: four characters repeat. The rule asks for distinct repeating characters, not total repeats.

perceptual-speed-s10-q01

Align the strings and step through them together: they agree everywhere except the middle block, where 99 in one string reads 98 in the other, one differing position.

perceptual-speed-s10-q02

Two transpositions each change two positions: KD becomes DK, and 12 becomes 21. A swap never counts as one difference in a position-by-position comparison. It counts as two.

perceptual-speed-s10-q03

The strings are identical at every position. Zero is always a live possibility in comparison work. Do not manufacture a difference just because one is expected.

perceptual-speed-s10-q04

The case swap at the start changes two positions (K to k and k to K), the mm-to-nn change adds two more, and the final 4-to-7 change makes five in total.

perceptual-speed-s10-q05

Check one field across all copies before moving to the next: the surname trap is Jenson, the ID trap is 40727, and the extension trap is 351. One copy passes every field.

perceptual-speed-s10-q06

Score each copy field by field against the original: one copy is perfect, one changes only the reference, one changes all three details, and one changes exactly two, the order number and the street number.

perceptual-speed-s10-q07

Work block by block: W differs from M, the second B has become an 8, and the 05-to-50 swap changes two positions, four differences altogether.

perceptual-speed-s10-q08

Each wrong pair hides one transposition: 806 against 860, MNQ against NMQ, and kt against tk. Only the first pair agrees at every position across all four blocks.

perceptual-speed-s10-q09

Pair the lists entry by entry: only AL-204 survives intact, while the other three codes each transpose their final two digits. One correct copy in total.

perceptual-speed-s10-q10

Take it block by block: 0447 against 0474 differs in two positions, mm against mn in one, and 93 against 39 in two more, five differences in all. Keeping a running tally per block prevents both misses and double counting.