Card Trick

This program implements the classic “21-card trick” in which a participant mentally selects one of 21 cards dealt face-up in three rows of seven. The deck is stored as a packed string in A$, with each card encoded in exactly three characters (rank plus suit), allowing random selection by indexing into B$ in steps of three. After the user mentally picks a card and identifies its row three times, the program shuffles the columns using a fixed interleave permutation (picking every 7th element starting from positions 1, 8, 15, then 2, 9, 16, etc.) to guarantee the chosen card ends up in the middle of the identified column. Card display uses block-graphic characters to draw playing-card outlines on screen, and the final reveal spells out the full rank and suit name.

---

Program Analysis

Program Structure

The program is organised into a main flow with five subroutines and a save stub at line 9998. The main flow handles initialisation, three rounds of dealing/shuffling, and the final reveal. The subroutines are:

• 1000–1500: Deal a random card from B$ into C$, draw its frame, and print its value.
• 2000–2050: Prompt the user to pick a row (1, 2, or 3) using INKEY$.
• 3000–3100: Redisplay cards from D$ during the second shuffle display.
• 4000–4100: Redisplay cards from E$ during the third shuffle display.
• 5000–5160: Compact C$ by removing blank entries, shifting non-blank entries to the front.

Deck Encoding

The 52-card deck is stored in A$ as a flat string of 156 characters (52 × 3). Each card occupies exactly three characters: two for rank (e.g. "10", " 2", " A") and one for suit (D, H, C, S). A dealt card is marked as used by overwriting its three-character slot in B$ with " " (three spaces). Random selection at line 1030 generates a slot index and retries if that slot is already blank, implementing selection without replacement.

The 21-Card Trick Algorithm

The mathematical core relies on a column-interleave shuffle repeated three times. After the user identifies which of three rows (columns of 7) contains their card, that group of 7 is placed in the middle column of 21 cards by applying a fixed permutation. The permutation used at lines 180–201, 500–521 maps positions as follows:

Output index	Source index (first shuffle)
1	C$(1)
2	C$(8)
3	C$(15)
4	C$(2)
5	C$(9)
6	C$(16)
…	…

This is a column-major to row-major reordering of a 7×3 matrix, which is the standard mechanism of the trick. After three repetitions with the user’s row placed in the middle each time, the target card is guaranteed to land at position 11 of 21 (the mathematical centre).

Row Selection and Filtering

Subroutine 2000 waits for a keypress with character code 29, 30, or 31 (the ZX Spectrum digit keys “1”, “2”, “3” respectively as returned by INKEY$) and converts the result to an integer G via VAL G$. After each round, the non-selected rows are blanked: the loop at lines 220–240 (and equivalents at 530–540, 710–720) sets entries outside the range G*7-6 to G*7 to " ".

Card Frame Drawing

Each card is drawn using block-graphic escape sequences to form a bordered rectangle five lines tall. Subroutine 1000 at line 1020 prints the frame at screen position (X, Y); the rank (up to two characters) is printed at row X+1, Y+1 and the suit character at row X+3, Y+2. The final reveal at lines 950–960 draws a larger single card frame in the centre of the screen using the same technique.

Card Grid Layout

The 21 cards are laid out in a 3×7 grid using nested FOR loops. The outer loop steps X from 2 to 14 in steps of 6 (three rows), and the inner loop steps Y from 3 to 27 in steps of 4 (seven columns). This gives a compact grid that fits the 32-column display.

Rank and Suit Name Lookup

Lines 921–937 perform a sequential IF-chain to convert the stored rank character(s) to a word (e.g. "A" → "ACE") and suit letter to a word (e.g. "H" → "HEARTS"). The ten is handled specially at line 930 by comparing the first two characters: G$( TO 2)="10". The suit character is always read from position 3: G$(3).

Notable Techniques

• The B$ string acts as a “used card” bitfield by zeroing dealt slots, avoiding a separate Boolean array.
• Subroutine 5000 is a compaction routine that left-packs non-blank entries in C$, avoiding the need to track sparse indices.
• Lines 541–558 apply the same compaction logic inline for D$ between the second and third rounds.
• Lines 560–610 cross-reference C$ against D$ to retain only cards that appear in both, further narrowing the candidate set.
• Lines 740–810 and 820–860 similarly cross-reference E$ against C$ to identify the final card.
• SAVE "CARDTRIC%K" at line 9998 uses the ZX text escape %K to store the filename with an inverse-video K, a cosmetic flourish in the save name.

Bugs and Anomalies

• The row-input subroutine at line 2000 checks CODE G$<29 OR CODE G$>31, but on the ZX Spectrum the digit keys “1”, “2”, “3” return character codes 49, 50, 51. Codes 29–31 correspond to keyword tokens, not digit characters. This means the INKEY$ comparison as written will never match and the subroutine will loop forever unless the machine this runs on maps numeric keys differently than standard.
• Lines 820–860 use FOR N=1 TO 3 nested over FOR I=1 TO 7 to find the card in E$, but there is no NEXT N statement—control falls through from line 860 to line 900 regardless of whether a match was found, which means N retains its last value (3) if no match occurs, potentially printing the wrong card.
• The shuffle permutation is deterministic (not random), so the “shuffle” displayed on screen is cosmetic only; the mathematical interleave is hardcoded across lines 180–201 etc.