Algorithm Notes to Visual Walkthrough Prompts

Practical reference-photo editing prompts generated for editorial review.

Conceptual illustration of layered paper stairs with two colored ribbons meeting at an upper landing.

ChatGPT

Dynamic Programming Table from Staircase Notes

Convert a recurrence photo into a bottom-up table with base cases and dependencies.

Transform the uploaded photo of handwritten algorithm notes into a clean, readable visual walkthrough. Treat the photo as the source of truth: preserve its algorithm, legible input values and stated conventions; remove glare, skew and paper clutter while retaining a small source-note inset. Do not invent unreadable values or silently repair contradictory logic; ask one focused question if an essential detail cannot be read. Use the optional example below only when the source has no worked example and label it "Illustrative example". Explain the count of distinct ordered ways to climb n steps taking one or two steps at a time. Preserve the source convention or explicitly state ways(0)=1 and ways(1)=1, with ways(n)=ways(n-1)+ways(n-2) for n>=2. Optional labeled example n=5: indices 0,1,2,3,4,5 have counts 1,1,2,3,5,8. Show each new cell combining the previous two, avoiding a misleading minimum-cost interpretation. Use only nonnegative integer n and flag other inputs. State O(n) time and O(n) table space under the usual unit-cost arithmetic model; mention O(1) stored counts only as a separate optimization. Layout: Use a six-cell table across the bottom and a stair silhouette above; provide labeled dependency arrows from the previous two cells for one magnified update. Use an off-white canvas, dark high-contrast sans-serif labels and spacious cells. Include the algorithm title, input, numbered steps, final result and the stated complexity note. Pair colors with labels or outlines so meaning does not depend on color alone. Keep all values and state changes consistent across panels. If space is tight, simplify decoration rather than omitting essential steps. Output one polished educational image; treat it as a visual explanation, not executable code. Before finalizing, check the trace and all visible labels against the source.

View Details

Conceptual illustration of paired paper arches around stacked blocks, with one unmatched arch aside.

ChatGPT

Balanced Parentheses Stack from Parsing Notes

Turn bracket-checking notes into push, match, pop and failure states.

Transform the uploaded photo of handwritten algorithm notes into a clean, readable visual walkthrough. Treat the photo as the source of truth: preserve its algorithm, legible input values and stated conventions; remove glare, skew and paper clutter while retaining a small source-note inset. Do not invent unreadable values or silently repair contradictory logic; ask one focused question if an essential detail cannot be read. Use the optional example below only when the source has no worked example and label it "Illustrative example". Specify supported bracket types () [] {}. Read left to right; push opening brackets, and for a closing bracket require a nonempty stack with a matching top before popping. Accept only if no mismatch occurred and the stack is empty at the end. State how non-bracket characters are handled; default to ignoring them. Optional labeled success example: ([{}]); stack states after each character are (, ([, ([{, ([, (, empty. Include a separate failure inset for ([)] at the third character, where ) mismatches top [. State O(n) time and O(n) worst-case auxiliary space. Layout: Use a character strip above six vertical stack snapshots; make the top of stack explicit and isolate the mismatch inset from the successful trace. Use an off-white canvas, dark high-contrast sans-serif labels and spacious cells. Include the algorithm title, input, numbered steps, final result and the stated complexity note. Pair colors with labels or outlines so meaning does not depend on color alone. Keep all values and state changes consistent across panels. If space is tight, simplify decoration rather than omitting essential steps. Output one polished educational image; treat it as a visual explanation, not executable code. Before finalizing, check the trace and all visible labels against the source.

View Details

Conceptual illustration of a teal viewing window passing over a strip of textured tiles.

ChatGPT

Sliding Window Running Sum from Sequence Notes

Transform fixed-window notes into overlapping ranges with outgoing and incoming updates.

Transform the uploaded photo of handwritten algorithm notes into a clean, readable visual walkthrough. Treat the photo as the source of truth: preserve its algorithm, legible input values and stated conventions; remove glare, skew and paper clutter while retaining a small source-note inset. Do not invent unreadable values or silently repair contradictory logic; ask one focused question if an essential detail cannot be read. Use the optional example below only when the source has no worked example and label it "Illustrative example". Use a fixed window size k with 1<=k<=n. Show the first sum in full, then update by subtracting the outgoing value and adding the incoming value; keep window sum distinct from best sum. Optional labeled example: [2, 1, 5, 1, 3, 2], k=3; window sums 8, 7, 9, 6; maximum 9 for zero-based indices 2..4. Initialize the best sum to the first valid window, so all-negative arrays work. State O(n) time and O(1) auxiliary space. Do not turn this into a variable-length window algorithm. Layout: Use four aligned rows with a constant-width window frame; an outgoing coral marker and incoming teal marker clarify each update. Use an off-white canvas, dark high-contrast sans-serif labels and spacious cells. Include the algorithm title, input, numbered steps, final result and the stated complexity note. Pair colors with labels or outlines so meaning does not depend on color alone. Keep all values and state changes consistent across panels. If space is tight, simplify decoration rather than omitting essential steps. Output one polished educational image; treat it as a visual explanation, not executable code. Before finalizing, check the trace and all visible labels against the source.

View Details

Conceptual illustration of opposing spotlights highlighting a pair of tiles on notebook paper.

ChatGPT

Two-Pointer Pair Search from Array Notes

Convert sorted-array notes into a pair-sum walkthrough with explicit pointer movement.

Transform the uploaded photo of handwritten algorithm notes into a clean, readable visual walkthrough. Treat the photo as the source of truth: preserve its algorithm, legible input values and stated conventions; remove glare, skew and paper clutter while retaining a small source-note inset. Do not invent unreadable values or silently repair contradictory logic; ask one focused question if an essential detail cannot be read. Use the optional example below only when the source has no worked example and label it "Illustrative example". Require a sorted ascending array and two distinct indices. At each panel show left, right, their sum and the comparison with target; move left rightward for a low sum or right leftward for a high sum. Optional labeled example: [1, 2, 4, 7, 11], target 9; pairs (1,11)=12, (1,7)=8, (2,7)=9; return indices 1 and 3 using zero-based indexing. Stop if left>=right. Preserve original input and flag unsorted input rather than silently sorting when original indices matter. State O(n) time and O(1) auxiliary space for already sorted input. Layout: Create three horizontal array panels with opposed labeled pointer markers; keep discarded ranges subdued and the successful pair outlined. Use an off-white canvas, dark high-contrast sans-serif labels and spacious cells. Include the algorithm title, input, numbered steps, final result and the stated complexity note. Pair colors with labels or outlines so meaning does not depend on color alone. Keep all values and state changes consistent across panels. If space is tight, simplify decoration rather than omitting essential steps. Output one polished educational image; treat it as a visual explanation, not executable code. Before finalizing, check the trace and all visible labels against the source.

View Details

Conceptual illustration of a golden route connecting paper islands among muted alternative ribbons.

ChatGPT

Dijkstra Relaxation Steps from Weighted Graph Notes

Turn weighted-graph notes into a shortest-path walkthrough with tentative distance updates.

Transform the uploaded photo of handwritten algorithm notes into a clean, readable visual walkthrough. Treat the photo as the source of truth: preserve its algorithm, legible input values and stated conventions; remove glare, skew and paper clutter while retaining a small source-note inset. Do not invent unreadable values or silently repair contradictory logic; ask one focused question if an essential detail cannot be read. Use the optional example below only when the source has no worked example and label it "Illustrative example". Verify nonnegative edge weights, preserve edge direction and distinguish tentative from finalized distances. Start at distance zero and use infinity for unknown distances. Repeatedly select the unsettled vertex with smallest tentative distance and relax its outgoing edges. Optional labeled directed example: A->B weight 4, A->C weight 1, C->B weight 2, B->D weight 1, C->D weight 5; settle A,C,B,D and obtain distances A=0,C=1,B=3,D=4. Show D improving from 6 to 4. Reject negative-weight inputs for this method. For adjacency lists and a binary heap state O((V+E) log V) time and O(V+E) overall storage. Layout: Place the weighted graph above a compact distance table; mark each changed table cell and selected vertex consistently across four panels. Use an off-white canvas, dark high-contrast sans-serif labels and spacious cells. Include the algorithm title, input, numbered steps, final result and the stated complexity note. Pair colors with labels or outlines so meaning does not depend on color alone. Keep all values and state changes consistent across panels. If space is tight, simplify decoration rather than omitting essential steps. Output one polished educational image; treat it as a visual explanation, not executable code. Before finalizing, check the trace and all visible labels against the source.

View Details

Conceptual illustration of a golden thread exploring folded paper corridors beside stacked tabs.

ChatGPT

Depth-First Search Backtracking from Graph Sketches

Transform a graph photo into a recursive exploration with visible call-stack unwinding.

Transform the uploaded photo of handwritten algorithm notes into a clean, readable visual walkthrough. Treat the photo as the source of truth: preserve its algorithm, legible input values and stated conventions; remove glare, skew and paper clutter while retaining a small source-note inset. Do not invent unreadable values or silently repair contradictory logic; ask one focused question if an essential detail cannot be read. Use the optional example below only when the source has no worked example and label it "Illustrative example". Preserve every edge and state the start and neighbor order. Mark a vertex visited on entry, skip visited neighbors and show backtracking only after eligible neighbors finish. Optional labeled undirected graph: edges A-B, A-C, B-D, D-C; start A, alphabetical neighbors; discovery order A, B, D, C; recursive stack grows [A], [A,B], [A,B,D], [A,B,D,C] and then unwinds. Distinguish discovery from completion. State O(V+E) time with adjacency lists and O(V) auxiliary space. Do not present DFS as a shortest-path guarantee. Layout: Use a highlighted graph route alongside stacked call frames, with separate entry and return panels and a persistent visited legend. Use an off-white canvas, dark high-contrast sans-serif labels and spacious cells. Include the algorithm title, input, numbered steps, final result and the stated complexity note. Pair colors with labels or outlines so meaning does not depend on color alone. Keep all values and state changes consistent across panels. If space is tight, simplify decoration rather than omitting essential steps. Output one polished educational image; treat it as a visual explanation, not executable code. Before finalizing, check the trace and all visible labels against the source.

View Details

Conceptual illustration of expanding pebble groups and an orderly waiting tray beside a notebook.

ChatGPT

Breadth-First Search Queue Trace from Graph Notes

Convert a graph sketch into a level-by-level traversal with synchronized queue states.

Transform the uploaded photo of handwritten algorithm notes into a clean, readable visual walkthrough. Treat the photo as the source of truth: preserve its algorithm, legible input values and stated conventions; remove glare, skew and paper clutter while retaining a small source-note inset. Do not invent unreadable values or silently repair contradictory logic; ask one focused question if an essential detail cannot be read. Use the optional example below only when the source has no worked example and label it "Illustrative example". Preserve the graph vertices, edges and edge direction. State the start vertex and neighbor order. Mark vertices discovered when enqueued so a vertex enters the queue at most once. Pair each processed vertex with the queue after its neighbors are examined. Optional labeled undirected example: edges A-B, A-C, B-D, C-E; start A and alphabetical neighbor order; dequeue order A, B, C, D, E; queues after processing are [B,C], [C,D], [D,E], [E], []. Explain that BFS finds shortest edge-count paths in an unweighted graph. State O(V+E) time with adjacency lists and O(V) auxiliary space. Layout: Place the graph on the left and a vertical queue timeline on the right; use rings for distance layers and both labels and colors for state. Use an off-white canvas, dark high-contrast sans-serif labels and spacious cells. Include the algorithm title, input, numbered steps, final result and the stated complexity note. Pair colors with labels or outlines so meaning does not depend on color alone. Keep all values and state changes consistent across panels. If space is tight, simplify decoration rather than omitting essential steps. Output one polished educational image; treat it as a visual explanation, not executable code. Before finalizing, check the trace and all visible labels against the source.

View Details

Conceptual paper sculpture of strands separating and recombining above an open notebook.

ChatGPT

Merge Sort Split and Combine from Recursion Notes

Turn divide-and-conquer notes into a split tree and a separate ordered merge sequence.

Transform the uploaded photo of handwritten algorithm notes into a clean, readable visual walkthrough. Treat the photo as the source of truth: preserve its algorithm, legible input values and stated conventions; remove glare, skew and paper clutter while retaining a small source-note inset. Do not invent unreadable values or silently repair contradictory logic; ask one focused question if an essential detail cannot be read. Use the optional example below only when the source has no worked example and label it "Illustrative example". Separate recursive splitting from merging; splitting does not sort a subarray. Preserve left-to-right input order in the leaves and compare the heads of two sorted runs during each merge. Optional labeled example: [7, 2, 6, 3] splits into [7, 2] and [6, 3], then singleton leaves; merge pairs to [2, 7] and [3, 6], then [2, 3, 6, 7]. Choose the left value on ties for stability. State O(n log n) time and O(n) auxiliary array space for this conventional array implementation. Layout: Use an upper split section and lower merge section with clear direction labels; distinguish the two phases with blue and teal. Use an off-white canvas, dark high-contrast sans-serif labels and spacious cells. Include the algorithm title, input, numbered steps, final result and the stated complexity note. Pair colors with labels or outlines so meaning does not depend on color alone. Keep all values and state changes consistent across panels. If space is tight, simplify decoration rather than omitting essential steps. Output one polished educational image; treat it as a visual explanation, not executable code. Before finalizing, check the trace and all visible labels against the source.

View Details

Conceptual illustration of an amber tile being inserted into an ordered line of teal and ivory tiles.

ChatGPT

Insertion Sort Prefix Growth from Sorting Notes

Transform sorting notes into a visual trace of key selection, shifting and insertion.

Transform the uploaded photo of handwritten algorithm notes into a clean, readable visual walkthrough. Treat the photo as the source of truth: preserve its algorithm, legible input values and stated conventions; remove glare, skew and paper clutter while retaining a small source-note inset. Do not invent unreadable values or silently repair contradictory logic; ask one focused question if an essential detail cannot be read. Use the optional example below only when the source has no worked example and label it "Illustrative example". Show the sorted prefix, selected key held separately, each rightward shift and the final insertion. Preserve the full multiset of values. Optional labeled example: [5, 2, 4, 1]; outer-pass results are [2, 5, 4, 1], [2, 4, 5, 1] and [1, 2, 4, 5]. Show intermediate shifts for the insertion of 4. Use the stable variant that shifts only elements strictly greater than the key. State worst-case O(n^2) time and O(1) auxiliary space. Layout: Use three outer-pass bands and a magnified middle-pass inset; teal marks the sorted prefix and an amber floating tile marks the held key. Use an off-white canvas, dark high-contrast sans-serif labels and spacious cells. Include the algorithm title, input, numbered steps, final result and the stated complexity note. Pair colors with labels or outlines so meaning does not depend on color alone. Keep all values and state changes consistent across panels. If space is tight, simplify decoration rather than omitting essential steps. Output one polished educational image; treat it as a visual explanation, not executable code. Before finalizing, check the trace and all visible labels against the source.

View Details

Conceptual illustration of nested blue frames focusing on a golden tile in an ordered row.

ChatGPT

Binary Search Interval Narrowing from Notebook Photos

Convert sorted-array notes into a walkthrough of shrinking search bounds.

Transform the uploaded photo of handwritten algorithm notes into a clean, readable visual walkthrough. Treat the photo as the source of truth: preserve its algorithm, legible input values and stated conventions; remove glare, skew and paper clutter while retaining a small source-note inset. Do not invent unreadable values or silently repair contradictory logic; ask one focused question if an essential detail cannot be read. Use the optional example below only when the source has no worked example and label it "Illustrative example". Check that the input is sorted and preserve its values. Show inclusive low and high bounds and mid=floor((low+high)/2) for each iteration. A failed comparison excludes mid by setting low=mid+1 or high=mid-1. For an unsorted input, flag the precondition and ask for a sorted example rather than silently altering the notes. Optional labeled example: [2, 5, 8, 12, 16, 23, 38], target 23; mid index 3 holds 12, then mid index 5 holds 23. State iterative worst-case time O(log n), auxiliary space O(1). Layout: Stack interval panels vertically; use a dark bracket for the active interval, amber for mid and faded cells for excluded regions. Use an off-white canvas, dark high-contrast sans-serif labels and spacious cells. Include the algorithm title, input, numbered steps, final result and the stated complexity note. Pair colors with labels or outlines so meaning does not depend on color alone. Keep all values and state changes consistent across panels. If space is tight, simplify decoration rather than omitting essential steps. Output one polished educational image; treat it as a visual explanation, not executable code. Before finalizing, check the trace and all visible labels against the source.

View Details

Editorial illustration of a magnifying lens scanning clay tiles beside an open notebook.

ChatGPT

Linear Search Scan from Handwritten Notes

Turn a photographed linear-search example into an indexed scan with an explicit stopping point.

Transform the uploaded photo of handwritten algorithm notes into a clean, readable visual walkthrough. Treat the photo as the source of truth: preserve its algorithm, legible input values and stated conventions; remove glare, skew and paper clutter while retaining a small source-note inset. Do not invent unreadable values or silently repair contradictory logic; ask one focused question if an essential detail cannot be read. Use the optional example below only when the source has no worked example and label it "Illustrative example". Preserve the input order. Show the current index, target comparison and visited prefix in each panel; stop on the first match, or show exhaustion for a missing target. Use zero-based indexing unless the notes say otherwise. If no example is supplied, visibly mark this as an illustrative example: [8, 3, 6, 2], target 6; comparisons occur at indices 0, 1 and 2, returning 2. Never imply that the whole array was sorted. State worst-case time O(n) and auxiliary space O(1). Layout: A left-to-right strip of four roomy panels, with amber for the active cell, pale gray for checked cells and teal for the match. Use an off-white canvas, dark high-contrast sans-serif labels and spacious cells. Include the algorithm title, input, numbered steps, final result and the stated complexity note. Pair colors with labels or outlines so meaning does not depend on color alone. Keep all values and state changes consistent across panels. If space is tight, simplify decoration rather than omitting essential steps. Output one polished educational image; treat it as a visual explanation, not executable code. Before finalizing, check the trace and all visible labels against the source.

View Details