Pangolins

This program implements a classic animal-guessing game using a binary decision tree stored in parallel arrays. The tree is represented by a string array `q$` holding questions and animal names, and a two-dimensional integer array `a` mapping each question node to its yes/no child indices. When the program fails to guess the player’s animal, it learns by prompting for the new animal’s name and a distinguishing question, then dynamically inserts both into the arrays and updates the branching pointers. The initial tree is seeded from DATA statements covering four animals (whale, blancmange, pangolin, ant) and three questions, with the tree pre-wired so nodes 1–3 are questions and nodes 4–7 are animals. A subroutine at line 910 trims trailing spaces before printing fixed-length strings from the DIM’d array.

---

Program Analysis

Program Structure

The program is organized into clearly delineated functional blocks, each introduced by a REM comment:

1. Lines 5–70: Initialization — dimensions arrays, loads question/answer tree from DATA statements.
2. Lines 100–210: Main game loop — traverses the decision tree from root node c=1 until a leaf (animal) node is reached.
3. Lines 300–380: Animal guessing — presents the guessed animal name and reads a yes/no response.
4. Lines 400–410: Success path — congratulates itself and jumps to the replay prompt.
5. Lines 500–730: Learning path — expands the tree with a new animal and distinguishing question.
6. Lines 800–840: Replay prompt — asks for another game or halts.
7. Lines 900–940: Print subroutine — strips trailing spaces from fixed-length strings.
8. Lines 1000–1020: Input subroutine — reads a reply and truncates to the first character.
9. Lines 2000–2040: DATA — seeds the initial four-animal, three-question tree.

Data Structures

The decision tree is encoded in two parallel structures:

• q$(nq,50) — a 100×50 character string array holding both question text (internal nodes) and animal names (leaf nodes).
• a(nq,2) — a 100×2 numeric array where a(c,1) is the child index for a “yes” answer and a(c,2) is the child index for a “no” answer. A value of 0 in both slots signals a leaf node.

The variable qf (next free slot) starts at 8. Questions occupy indices 1–3 initially, animals occupy indices 4–7. New animals are appended in pairs (old animal moved to qf, new animal at qf+1), and qf advances by 2 after each learning event.

Tree Traversal

Traversal begins at line 130 with c=1. At each step, the program checks a(c,1)=0 (line 140) to detect a leaf node. For internal nodes, the player’s yes/no response sets in to 1 or 2 respectively, and line 210 follows the branch: LET c=a(c,in). This is a clean, minimal binary tree walk entirely in BASIC.

Learning Mechanism

When the program guesses incorrectly (lines 500–720), it performs the following steps:

1. Moves the previously guessed animal’s name string from slot c to slot qf.
2. Reads the new animal’s name into slot qf+1.
3. Reads a distinguishing question into slot c, replacing the old animal name and turning the leaf into an internal node.
4. Sets a(c,in) to point to the new animal and a(c,io) to point to the old animal, based on the player’s answer.
5. Increments qf by 2.

The old animal at index c still has its a(c,1) and a(c,2) both zero (from the initial DIM), so the newly added leaf nodes are automatically recognized as leaves without needing explicit initialization.

Input Handling

The subroutine at line 1000 uses INPUT r$ and, if the string is non-empty, truncates it to its first character via r$=r$(1). This single-character capture is then compared case-insensitively by testing both "y"/"Y" and "n"/"N" at each decision point. The POKE 23658,8 at line 7 enables caps-lock mode, making lowercase input less likely, though the code still guards against it.

Print Subroutine

Because DIM q$(nq,50) pads all strings to exactly 50 characters with spaces, the subroutine at line 910 scans backwards from position 50 to find the last non-space character (n) and then prints p$(TO n). Line 905 prefixes a leading space before this trimmed output, while the entry point at line 910 skips the leading space — the two entry points (GO SUB 900 and GO SUB 910) are used in different contexts throughout the program.

Notable Techniques and Idioms

• The DATA loader at lines 30–70 uses two separate FOR loops: the first (lines 30–50) reads question strings with their two child indices; the second (lines 60–70) reads the initial animal name strings, which have no associated a() data since their child slots default to zero from DIM.
• qf/2-1 at line 30 computes the count of initial questions (3) from the initial free pointer (8), keeping the data count implicit rather than hardcoded separately.
• Line 580 strips a trailing ? from the player-entered distinguishing question before storing it, since the game appends its own ? on display.
• The replay check at line 830 uses a double conditional idiom: IF r$="Y" THEN CLS : IF r$="Y" THEN GO TO 100 — the condition is tested twice to allow CLS to execute only on the affirmative path before the GO TO.

Bugs and Anomalies

• Line 540 contains a spelling error: "DISTINGUEISHES" should be "DISTINGUISHES".
• Line 630 initializes in=1 (yes → new animal) and io=2 (no → old animal) before reading the response, but lines 650–680 only handle "Y" and "N" (uppercase). If the player types lowercase "y" or "n", neither branch is taken, and line 690 fires with “THAT’S NO GOOD.” — inconsistent with the rest of the program which accepts both cases.
• Line 830’s replay check only tests for uppercase "Y"; a lowercase "y" will fall through to STOP.
• The SAVE "pangolins" LINE 0 at line 3000 targets line 0, which does not exist; the conventional auto-run target would be line 5 or 7. This may prevent auto-run on load, though the save itself will succeed.