coding-decoding-s01-q01
Count forward from the start of the alphabet: A, B, C, D, E, F, G. G is the seventh letter, so its code is 7.
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.
Count forward from the start of the alphabet: A, B, C, D, E, F, G. G is the seventh letter, so its code is 7.
Decoding means counting places rather than letters. The twelfth letter of the alphabet is L, so 12 decodes to L.
Take the letters in the order they appear and swap each for its position: B is 2, A is 1, and D is 4. Keeping the original order is what stops a code turning into an anagram.
C is the third letter, O the fifteenth, and W the twenty-third. Letters near the end of the alphabet are the easiest to miscount, so check them against a nearby landmark such as T at 20.
Convert each number back to a letter: 19 is S, 21 is U, and 14 is N. Decoding is simply the same lookup carried out in the opposite direction.
Counting on from the landmark you were given is quicker than starting at A: 13 is M, so 14 is N, 15 is O, and stepping on to 20 lands on T.
Convert first, then add: C is 3, A is 1, and B is 2, giving a total of 6. A summing code loses the order of the letters, so several different words can share one number.
Decode each number separately: 2 is B, 4 is D, and 6 is F. Noticing that the numbers rise in twos also tells you the letters must skip one place each time.
Turn the letter into a number, do the arithmetic, then turn it back: D is 4, double 4 is 8, and the eighth letter is H.
Only the last number has changed, so only the last letter changes: 1 is A, giving TEA. Words made of the same letters in a different order produce the same numbers in a different order.
Step each letter on by one: C becomes D, A becomes B, and T becomes U. Every letter must move: leaving one unchanged is the most common slip.
Moving each letter forward once gives E from D, P from O, and H from G. Moving backwards instead would give the wrong direction entirely.
Count two places on for each letter: B to C to D, A to B to C, and T to U to V. Say the skipped letter aloud so you do not stop a place short.
Step each letter back by one: S becomes R, U becomes T, and N becomes M. Reading the alphabet backwards for a moment makes this far less error-prone.
Counting back two places gives D from F, M from O, and E from G. Check each letter separately rather than assuming the pattern of the first one repeats.
Compare the example letter by letter to find the rule: each letter has moved one place forward. Applying that same single step to CUP gives DVQ.
The example shows every letter moving one place back. Stepping back from A wraps round to the end of the alphabet, so A becomes Z and the word becomes CZX.
Z has no later letter, so the loop carries it round to A, while each O steps on to P. Treating the alphabet as a circle is what keeps a shift code working at both ends.
Counting on three places gives F from C, D from A, and E from B. With larger shifts it helps to count on your fingers rather than eyeballing the jump.
To decode a shift, run it the other way: move each coded letter four places back, giving C from G, A from E, and T from X.
Read the word from its last letter to its first: K, S, E, D. Writing the word out and reading it right to left is more reliable than trying to flip it in your head.
Reversing means the last letter comes first and the first letter comes last, giving E, L, P, P, A. Repeated letters are easy to lose, so count that the code has as many letters as the original.
Treat each word as its own small puzzle and leave the word order alone: OPEN reversed is NEPO and DOOR reversed is ROOD.
Here the reversal runs across the whole phrase, so the last word arrives first and each word is itself reversed. Comparing the example's first coded word with the phrase's last word is what reveals this.
Pair the alphabet from both ends inwards: the third letter from the start matches the third letter from the end, which is X. A quick check is that the two positions always add up to 27.
Mirror each letter in turn while keeping the order: C pairs with X, A with Z, and B with Y. The order of the letters is untouched, only their identities change.
Z sits at the far end, so it mirrors to A, and O at position fifteen mirrors to the twelfth letter, L. Using the rule that paired positions total 27 saves counting the whole alphabet.
A mirror code undoes itself, so apply the same pairing to the code: T pairs with G, L with O, and W with D. Codes that are their own reverse are quicker to break than shifts.
Split the word into pairs and turn each pair around on the spot: CA becomes AC and RD becomes DR. This is a local swap, not a full reversal, so the pairs themselves stay in place.
Reversing is its own undoing, so read the code backwards to recover the word: C, R, A, F, T. If the result is not a real word, you have probably mis-sequenced a middle letter.
Both pairs must be swapped, not just the first: FI becomes IF and SH becomes HS. Checking the example's second pair is what confirms the rule applies throughout.
Only the two outer letters move, so the middle of the word is copied across untouched: E arrives at the front and T goes to the end.
Lift the first letter off, shuffle everything else one place left, then add the lifted letter at the back. The remaining letters keep their relative order.
This is the mirror image of moving the first letter to the end: the final letter jumps to the front and everything else shifts one place right.
The block of the last two letters travels as a unit and keeps its internal order, so RD arrives first, followed by CA. Reversing inside the block would be a different rule altogether.
Number the letters first, then read them off in the order the rule gives: A, L, P, M. Writing the position numbers above the letters makes rules like this almost mechanical.
Split the word in half and swap the halves without disturbing the letters inside them, so SK comes first and DE follows.
Sort the letters from earliest to latest in the alphabet: A, C, H, I, R. This code throws away the original order, so many words can share a single code.
In a five-letter word the middle letter is the third one, so it leaves its place and leads the code while the remaining four follow in their original sequence.
Cut the word down the middle into two blocks of three and exchange them, keeping each block's letters in order: DEN then GAR. Swapping halves is not the same as reversing the whole word.
Line the example up letter by letter: every letter has advanced one place. Applying a single forward step to each letter of the new word gives TUBS.
The example shows a one-place forward shift, so decoding means stepping one place back: C becomes B, M becomes L, P becomes O, and X becomes W.
Checking two or three letters of the example is enough to identify a one-place forward shift, and longer words simply repeat it. Verify the middle letters too, since that is where a mis-stepped letter usually hides.
The example matches each letter to its alphabet position, so the same lookup gives 20 for T, 1 for A, and 16 for P.
The example letters are not shifted by a fixed amount; each one is paired with the letter the same distance from the opposite end of the alphabet. Mirroring CAP the same way gives XZK.
Both examples map each letter to its alphabet position, and the shared letter O confirms it by appearing as 15 in each. S is 19, I is 9, and X is 24.
Test the obvious idea first: the positions 18, 5, and 4 add up to 27, matching the example. Adding 2, 5, and 4 for the new word gives 11.
The shift is not constant: the first letter moves one place, the second two, and the third three. Applying the same growing shift means the last letter runs past the end of the alphabet and loops round to B.
Each letter moves backwards by its own position number: one place, then two, then three, then four. The last step loops past the start of the alphabet and lands on A.
The example is a plain alphabet-position code, so convert the numbers back: 4 is D, 9 is I, 19 is S, and 8 is H. Checking every number rules out the near-misses that differ by a single letter.
One code word appears in both phrases and one meaning appears in both translations, so they must belong together. That single overlap is the foothold every coded-language puzzle rests on.
The word shared by both phrases must mean the shared idea of night, which leaves only one meaning for the other word in the first phrase.
Pin down the words you can: one appears again with mango and another with juice. The word left over in the first phrase must carry the only meaning still unclaimed.
Chain the overlaps: the first two phrases share field and the last two share mouse, which leaves one word each for green and trap. Coding a new phrase is just looking those two up.
Two of the three words in the long phrase reappear elsewhere and can be identified from those pairings, so the remaining word takes the remaining meaning by elimination.
When the dictionary is handed to you, coding is a straight substitution word by word, with the order preserved exactly as the question states.
Each of the two short phrases shares one word with the long phrase, fixing the meanings of south and fly. Only one word of the long phrase is left unaccounted for.
Work through the overlaps in turn: one word recurs with bread and another with fresh, so the third word of the opening phrase must be the verb.
Every word appears in exactly two phrases, so match each word to the meaning those same two phrases share. The word common to the two phrases that both mention sky is the one you want.
Three of the four words in the long phrase are each pinned down by a short phrase, leaving exactly one word and one meaning unmatched. Elimination is usually faster here than trying to translate every phrase in full.
Do the lookup first and the arithmetic second: the positions 3, 1, and 2 each gain one to become 4, 2, and 3.
Convert each letter to its position, then double it: 2 becomes 4, 1 becomes 2, and 4 becomes 8. Doubling a number is not the same as stepping two letters on, so always convert before calculating.
Convert each letter and add: 2 for B, 1 for A, and 7 for G make 10. Adding the letters as you convert them is safer than converting all three and then adding.
Replace the digits one at a time from left to right so the order of the number is preserved: 3, 5, 1, and 4 become R, T, P, and S.
Read the key backwards to decode: T stands for 5, Q for 2, P for 1, and R for 3, keeping the same left-to-right order.
Apply the two steps in the order given: the position 4 doubles to 8 and then loses 1 to give 7, while the position 1 doubles to 2 and loses 1 to give 1. Repeated letters must produce repeated numbers, which is a quick way to sanity-check the answer.
Only the listed vowels are swapped, and each keeps its own place in the word, so the second letter becomes a star and the third a hash. Consonants are copied across unchanged.
Move one letter along before you look up the number: C leads to D at 4, A leads to B at 2, and T leads to U at 21. This is the same as adding one to each position, but stepping through the letter makes the wrap at the end of the alphabet obvious.
Total each word in turn and compare: 12, 9, and 4 add up to 25, while the others come to 24, 26, and 11. Summing codes lose so much information that different words often collide.
Counting backwards means subtracting the ordinary position from 27, so 2 becomes 25, 1 becomes 26, and 4 becomes 23. That subtraction is quicker than counting down from Z each time.
Mark the vowels before you start, then step only those forward: the second letter becomes B and the last becomes F, while the consonants are copied straight across.
Both vowels must be treated, not just the first: one steps on to V and the other to J. Missing a later vowel is the usual error in conditional codes.
This time the vowels are the ones that stay still, so only the first and third letters move back a place, becoming E and B.
Count the letters before deciding what to do: the four-letter word meets the condition and is reversed, while the three-letter word does not and is copied as it stands.
Two letters occur twice in this word, and the rule blanks out every copy of them, leaving only the two letters that appear once. Check every position, since a repeat can sit at either end.
Only the vowels change form, and each keeps its own place, so the second letter becomes 5 and the third becomes 1. The consonants must remain letters, which rules out coding the whole word numerically.
Carry out the steps strictly in the order given: reverse the letters first, and only then attach the extra letter to the end of what you have written.
Number the positions before coding, then alternate the direction of each step: forward, back, forward, back. Writing the numbers above the letters keeps the alternation from drifting.
Test each word against the condition separately: the first begins with a vowel so the whole word turns round, and the second begins with a consonant so only its outer letters trade places.
Number the eight letters and strike out the third and the sixth, then read what is left in order. Counting in threes across the whole word, rather than restarting after each deletion, is what keeps the positions right.
Write down the intermediate result rather than trying to hold it in your head: reversing gives T, A, C, and stepping each on gives U, B, D.
Shift first, which gives C, N, F, and only then reverse the order. Stopping after the first step is the commonest mistake with two-step codes.
Mirroring the letters gives X, Z, Y, and reversing that order gives Y, Z, X. Doing the two steps the other way round would produce a different answer, so the stated order matters.
Shifting each letter two places gives N, C, O, R, and the swap then exchanges the outer two letters of that result. Note that the swap acts on the shifted letters, not the original ones.
Treat the vowels first, giving R, B, J, N, then reverse that whole string. The consonants never move in the alphabet, but they do change position.
Reverse the letters to get D, A, B, then convert each to 4, 1, and 2. Converting before reversing would give the same three numbers in the wrong order.
The shift gives E, R, and A, since the last letter runs off the end of the alphabet and loops round. Reversing that string produces the final code.
Rearranging first gives S, K, D, E, and stepping each letter back then gives R, J, C, D. Keep the intermediate word visible so the second step is applied to the right order.
Substituting the vowels gives F, 1, C, 5, and reversing that sequence puts the number from the end at the front. Numbers reverse along with letters because they occupy positions in the string.
Undo the steps in the opposite order to the one used for coding: read the code backwards to get O, C, R, then move each letter two places back.
Line the two alphabets up in a row before coding: the second, first, and fourth entries of the keyword alphabet are U, M, and I. Writing the first ten entries out is usually enough for a short word.
Decoding means asking where each coded letter sits in the keyword alphabet: the third, first, and second entries correspond to the third, first, and second letters of the ordinary alphabet.
Find each letter's row first and its column second, then write the pair in that order. All three letters sit in the top row, so only the second digit changes.
Read each pair as a row then a column and look the letter up: the fifth entry of the fourth row, the fifth of the first, the first of the first, and the third of the third. Words made of the same letters produce the same pairs in a different order, so decode every pair before choosing.
Measure the gap on a letter that does not wrap around, such as the second one, then confirm it on another. The first letter looping from the end of the alphabet back to the start fits the same gap.
Once the size of a shift is known, decoding is mechanical: move every coded letter four places back. Decoding just the first two letters narrows the field, but check the rest before settling.
Reverse the arithmetic before the lookup: take two off each number to get 3, 1, and 20, then convert those positions into letters.
The positions 6, 9, and 7 total 22, and multiplying by the three letters gives 66. Forgetting the second step and answering 22 is the trap this rule is built around.
Two examples are better than one: both show every letter advancing two places, which rules out a rule that treats vowels differently. Applying that steady two-place step to each letter gives the code.
Undo the last step first by reading the code backwards to get X, Z, B, then move each letter three places forward, allowing the count to loop past the end of the alphabet.