Field Guide · For everyone

The night before: a one-page summary.

Field Guide, Exam prep, part 5 of 6. Your notes cut to one page for the night before, tested on free ChatGPT: it flagged the wrong line, then kept it.

13 Nov 2026 · 6 min read · sources read up to 12 Nov 2026

It's the night before the test. Your notes on your weakest topics run to 18 lines, and there's time to read one page, twice. Whatever is on that page is what you'll remember tomorrow, right or wrong. This is part 5 of the Field Guide series on exam prep with AI: one job, tested on a real screen, with the catch said plainly.

The job, and what to type

Part 4 turned a marked mock into 3 weak topics: Trees, Linked lists and Hashing. This part takes your own notes on those 3 topics and cuts them down to one page for tonight.

Use only notes you wrote yourself, in your own words. Not textbook pages, lecturer slides or handouts, question papers, a classmate's notes, or notes copied word for word. The notes below are a sample, made up for this demo: 18 numbered lines on Data Structures. Six are marked (!), the ones this made-up student keeps getting wrong. And one line, line 7, is wrong on purpose, to see if it gets caught. Type your own notes in their place, and number them, so a flag can point at a line.

My Data Structures test is tomorrow. These are my own notes on my 3 weakest topics. Turn them into a one-page summary I can read in 5 minutes tonight.

- Use only what's in my notes. Don't add anything new.
- Keep the summary under 250 words.
- Lines marked (!) are the ones I keep getting wrong. Put them first under each topic.
- If any line in my notes looks wrong, don't fix it quietly. List it at the end under "Check this", with the line number.

TREES
1. A tree is nodes joined by edges, with one root at the top and no loops.
2. A binary tree: each node has at most 2 children (left and right).
3. (!) Height = number of edges on the longest path from the root down to a leaf. A tree with just a root has height 0.
4. BST rule: everything in the left subtree is smaller than the node, everything in the right subtree is bigger.
5. (!) Inorder traversal (left, node, right) of a BST gives the values in sorted order.
6. Preorder = node, left, right. Postorder = left, right, node.
7. Searching a balanced BST takes O(n) time.

LINKED LISTS
8. Each node holds a value and a pointer to the next node. The last node points to null.
9. Inserting at the head is O(1): no shifting, unlike an array.
10. (!) Getting the item at position k is O(n): you have to walk from the head.
11. Doubly linked list: each node also points to the previous node, so you can go backwards.
12. (!) To delete a node, the node before it must point to the node after it.

HASHING
13. A hash function turns a key into a slot number in the table.
14. (!) Collision = two keys land in the same slot.
15. Chaining: each slot keeps a small list of every key that landed there.
16. Linear probing: if the slot is taken, try the next slot, then the next.
17. (!) Load factor = number of items / number of slots.
18. When the load factor gets high, lookups get slower.

Why these lines

"Use only what's in my notes" keeps the sheet to what you've already learned, so nothing new turns up the night before. "Under 250 words" is what makes it one page you can read twice. The (!) mark tells it which lines you keep getting wrong, so they go where your eyes land first. And the last line is the one that matters most: notes written in a hurry have mistakes in them, and a summary that quietly fixes a line, or quietly copies it, gives you no way to know. Asking for a "Check this" list with line numbers makes it show you.

How it was tested

One run on 12 November 2026, on free ChatGPT in a web browser, not signed in, in a new chat, so there was no account, memory or saved chat history to draw on. The page didn't show which model answered. OpenAI's own release notes fill the gap: their 29 October 2026 entry says its GPT-6 update in Chat "applies to Free and Go users, and people using ChatGPT without signing in" ^[2]. So by OpenAI's account the answer most likely came from GPT-6; the page itself never said so. The six checks, the sample notes and the prompt were written down and saved before the prompt was sent.

The wrong line: searching a balanced binary search tree (BST) takes O(log n) time, not O(n). Each step down the tree halves what's left to search, so a balanced tree of a million values takes about 20 steps (2 to the power 20 is just over a million), not a million. Every other line in the notes is right.

1. Short enough: the summary, everything before the "Check this" list, is under 250 words.
2. Only the notes: it covers Trees, Linked lists and Hashing only, and adds no fact, example or tip that isn't in the 18 lines.
3. The (!) lines come first: under each topic, lines 3 and 5, lines 10 and 12, and lines 14 and 17 come before that topic's other lines.
4. Nothing changed: the right lines keep their meaning (height counts edges and a lone root is 0; inorder gives sorted order; inserting at the head is O(1); position k is O(n); load factor is items divided by slots).
5. The wrong line is flagged: line 7 is listed under "Check this" with its number, and the sheet doesn't quietly print O(log n), or repeat O(n) as a fact.
6. No false flags: no right line is listed under "Check this".

What came back

The sheet itself is good. 206 words, title to the end of Hashing: comfortably one page. Under each topic, the (!) lines come first, in bold, under an orange "Priority — Often wrong" label: Height and Inorder traversal for Trees, getting the item at position k and Deletion for Linked lists, Collision and Load factor for Hashing. Every right line kept its meaning. A couple were shortened, "unlike an array" and "so you can go backwards" dropped off, but nothing was changed.

And it caught the planted mistake. At the end, under "Check this": "Line 7: Balanced BST searching takes O(n)." With its number, as asked, and a line saying "These are flagged for checking, not silently corrected."

Three of the six checks passed.

The catch

The flag is at the bottom. The line is still at the top. The last bullet under Trees reads "Balanced BST search: O(n)." as a plain bullet, no mark on it, in the middle of the page you're going to read twice tonight. The flag only helps if you get to the end and connect "Line 7" back to that bullet.

Two smaller misses. It also put "Line 12: Deletion rule may be incomplete." under "Check this", without saying what's missing. Line 12 is right for the singly linked list of line 8: the node before must point to the node after. (In a doubly linked list, line 11, the node after must also point back, which may be what it meant, but it didn't say so.) That's a flag on one of the lines you keep getting wrong, the one place you don't need new doubt. And it ended with a tip of its own, "Read the bold priority points twice, then try recalling all three topics without looking", after being told to add nothing new. Harmless advice, but not from the notes.

The fix is yours, and it takes a minute. Before you read the sheet, go to "Check this", find each line it names, and cross it out on the sheet itself. Then look each one up in your textbook or ask your teacher, and only then write it back in.

The stamp

Half works · 12 Nov 2026 · free ChatGPT, not signed in · 3 of 6 checks passed. It's good at cutting your notes down to one page, keeping them right and putting your weak lines first, and it can spot a wrong line when you ask it to. But it flagged the wrong line and printed it anyway, flagged a right line without a reason, and added a tip. Cross out the "Check this" lines before you read. One run is one run: try it with your own notes and see what yours does.

Before you use it

For revising only. Never in an exam, and for marked work, follow your school's or college's AI rules. ChatGPT is for ages 13 and over, or the minimum age in your country, and under 18 needs a parent's or guardian's permission ^[1].

The raw answer, word for word

Taken word for word from the page text. Its bullets are written as "- "; its orange labels are in square brackets; the words it set in bold are marked like this, as on the screen. Nothing else changed.

Data Structures — 5-Minute Revision Sheet

EXAM NIGHT QUICK REVISION · 3 TOPICS · UNDER 250 WORDS

1. TREES
[Priority — Often wrong]

- **Height:** Number of edges on the longest root-to-leaf path. Single-root tree = height 0.
- **Inorder traversal:** Left → Node → Right gives sorted values in a BST.
- Tree: Nodes joined by edges, one root, no loops.
- Binary tree: At most 2 children (left and right).
- BST: Left subtree smaller; right subtree bigger.
- Preorder: Node → Left → Right.
- Postorder: Left → Right → Node.
- Balanced BST search: O(n).

2. LINKED LISTS
[Priority — Often wrong]

- **Getting item at position k:** O(n), walk from the head.
- **Deletion:** Node before the deleted node must point to the node after it.
- Each node holds a value and next pointer. Last node points to null.
- Head insertion: O(1), no shifting.
- Doubly linked list: Each node also points to the previous node.

3. HASHING
[Priority — Often wrong]

- **Collision:** Two keys land in the same slot.
- **Load factor:** Number of items / number of slots.
- Hash function: Converts a key into a table slot number.
- Chaining: Each slot keeps a small list of keys.
- Linear probing: If occupied, try the next slot.
- High load factor → slower lookups.

Check this

- **Line 7:** Balanced BST searching takes O(n).
- **Line 12:** Deletion rule may be incomplete.

These are flagged for checking, not silently corrected.

**Tonight's tip:** Read the bold priority points twice, then try recalling all three topics without looking. Good luck on your test tomorrow!

Next in the series, part 6: "Which AI makes the best practice paper".