Neural Automata Task Visualizer

Batch Size: 5 • Length: ~32 • Random Seed: Fresh

2026-02-23 13:21:45

Regular

(4 tasks)

1. Cycle Navigation

L=32

Navigate a circular ring of states using a sequence of forward and backward instructions. Starting at state 0 on a cycle of num_states positions, each instruction moves the pointer one step clockwise or counter-clockwise. The output is the final state index. This tests whether a model can learn modular counting.

Input
<- -> <- <- <- -> -> <- -> -> -> <- -> -> -> -> -> <- -> <- <- <- -> <- <- -> -> -> -> <- <- ->
Output
state 4
Input
-> <- <- <- <- -> -> -> -> -> -> <- <- -> <- <- -> <- -> -> <- <- <- <- -> <- <- <- <- <- <- <-
Output
state 2
Input
-> -> -> -> -> <- -> -> -> <- -> -> -> <- -> -> <- -> -> <- <- -> <- -> -> <- -> -> -> <- -> ->
Output
state 4
Input
<- <- <- -> -> <- <- -> <- -> <- <- -> <- -> <- -> <- -> -> -> <- -> -> -> <- <- -> <- -> <- ->
Output
state 0
Input
-> -> <- <- -> <- <- -> -> -> <- <- <- <- -> -> -> <- <- -> <- <- <- -> <- -> <- <- -> <- -> <-
Output
state 1

2. Even Pairs

L=32

Given a sequence of symbols, determine whether the entire sequence consists of identical adjacent pairs. For example, a a b b a a is “yes” because every consecutive pair matches, while a b a a is “no”. Odd-length sequences are always “no”. A classification task outputting a single binary label.

Input
a b b b a b b b b b b b a a a b a b a b a a a b b a b b a b a a
Output
no
Input
a a b b b b a a a b a b b b a b a a b a a a b b a a b b b a b a
Output
no
Input
a a a a a a b b b b a a b b b b b a b a a b a b a a b b a a b b
Output
no
Input
b b b b a b a b a a a a b a b a a b a b a b a a b b a a b a b a
Output
no
Input
a a a a a b a b a a b a b b a a b b a b a a a b b b b b a a a b
Output
no

3. Modular Arithmetic

L=31

Evaluate flat arithmetic expressions (no parentheses) under a modulus. The input is an alternating sequence of operands and operators (+, -, *) evaluated strictly left-to-right, and the output is the result mod n. Because the state space is bounded by the modulus, a finite automaton suffices.

Input
(4 + 0 - 0 - 0 - 2 * 4 * 4 - 4 + 3 * 0 - 1 - 1 - 3 - 1 * 3 + 3) mod 5
Output
0
Input
(3 + 4 - 3 + 1 * 0 + 3 - 4 + 3 - 3 + 4 + 0 - 3 - 3 * 0 * 3 + 2) mod 5
Output
2
Input
(1 - 0 + 4 - 2 * 3 - 1 + 1 + 1 * 4 - 4 * 1 + 1 * 0 - 1 - 1 * 0) mod 5
Output
0
Input
(2 * 0 * 2 + 4 + 1 + 1 - 3 + 3 - 4 + 2 * 0 + 0 * 2 - 2 + 4 * 0) mod 5
Output
0
Input
(0 + 2 * 0 + 0 * 4 + 3 - 1 - 0 + 3 - 0 * 0 + 2 + 4 - 4 * 0 + 1) mod 5
Output
1

4. Parity Check

L=32

Count how many times a specific target symbol appears in the input sequence and output whether that count is even or odd. The model must track the running parity of occurrences — a task that maps directly to a two-state finite automaton.

Input
b b a a a a b a a b b b a a a a b b a a b a a b a a a a a b b a
Output
even (count(a)=20)
Input
b b b b a a a b b b a a a a b a b b a a b b b a a b b a a a a b
Output
even (count(a)=16)
Input
a b b b a a a b a b b b a a b a a b a b a b b b a b a a b a a a
Output
odd (count(a)=17)
Input
b b a a b a b a a b a b b b a a a a a a a b a b b a a b b b b a
Output
odd (count(a)=17)
Input
a a a b a a b b b b a b b b a b b a b b b b b b b b b a a b b a
Output
odd (count(a)=11)

Context Free

(5 tasks)

5. Dyck N (n=4)

L=32

Determine whether a sequence of brackets is properly balanced, using n distinct bracket types. A valid Dyck word requires every opening bracket to be matched with the correct closing bracket in proper nesting order. This is the prototypical context-free language — recognizing it requires a stack to track which bracket types are open.

Input
((())<{{}}[]{}<>>)[]{}<>()<>[][]
Output
balanced
Input
)}((}}({[{}{<>>[[{{{)>>}<](]<}[]
Output
unbalanced
Input
[<(())>]<>(<><(){}>)<()>[()<[]>]
Output
balanced
Input
[][([])<[]>]<><>{<()(<>{<>{}})>}
Output
balanced
Input
}<]{<{({<[)}{})]>(({(<<<)<)<[}])
Output
unbalanced

6. Nested Modular Arithmetic

L=32

Like Modular Arithmetic, but expressions now include nested parentheses up to a configurable depth. The model must evaluate inner sub-expressions first and carry intermediate results back to outer expressions, requiring a stack to track nesting structure and pending computations.

Input
(4+(3+(2*4))) mod 5
Output
0
Input
(((3*4)-(0-3))*((3*1)+(0-2))) mod 5
Output
0
Input
(((2-1)+(2+2))*0) mod 5
Output
0
Input
(2+((2*1)+(1+2))) mod 5
Output
2
Input
(1+((2*0)+(1*0))) mod 5
Output
1

7. Reverse String

L=32

Given an input sequence of tokens, produce the same tokens in reverse order. Reversing requires the model to buffer the entire input before emitting any output — a canonical stack operation. The input a b c d should produce d c b a.

Input
a f f a b h a g f h f c e f e f c c e a d a f c a g f h g f f b
Output
b f f g h f g a c f a d a e c c f e f e c f h f g a h b a f f a
Input
b g c f c c c e g h g d b e h b d f e h c f c c g g g e h h a a
Output
a a h h e g g g c c f c h e f d b h e b d g h g e c c c f c g b
Input
d f e g g b e b g d h d g g a c d h h c h b c f d h a c c c c f
Output
f c c c c a h d f c b h c h h d c a g g d h d g b e b g g e f d
Input
d g a h a d g b e h h c g g b b d g f d f a b h e a f h c f a b
Output
b a f c h f a e h b a f d f g d b b g g c h h e b g d a h a g d
Input
d f g e f d d b d h h g h b a b e g g d h a e g g c c b c e h h
Output
h h e c b c c g g e a h d g g e b a b h g h h d b d d f e g f d

8. Solve Equation

L=32

Find the value of x in a simple linear equation a * x + b = c, where all values are bounded integers. The model must implicitly invert the linear relationship — a form of symbolic reasoning over a constrained algebraic structure.

Input
4 * x + 3 = 5
Output
x = 3
Input
9 * x + 4 = 9
Output
x = 5
Input
4 * x + 6 = 8
Output
x = 8
Input
1 * x + 5 = 5
Output
x = 0
Input
2 * x + 6 = 8
Output
x = 1

9. Stack Manipulation

L=32

Execute a sequence of explicit push(x) and pop instructions on a stack, outputting the top-of-stack value after each step (0 if empty). This directly tests LIFO data structure semantics, since correct output at each timestep depends on the full history of pushes and pops.

Input
↓4 ↓4 ↓4 ↓4 ↓2 ↓3 ↓4 ↓3 ↓3 ↓1 ↓2 ↓1 ↑ ↓1 ↑ ↓3 ↓1 ↓4 ↑ ↑ ↑ ↓3 ↓1 ↓4 ↑ ↓1 ↓2 ↓1 ↓3 ↓1 ↓2 ↑
Output
top: [4 4 4 4 2 3 4 3 3 1 2 1 2 1 2 3 1 4 1 3 2 3 1 4 1 1 2 1 3 1 2 1]
Input
↑ ↓2 ↑ ↓3 ↓2 ↓2 ↓1 ↓2 ↓3 ↑ ↓3 ↓2 ↓1 ↓2 ↑ ↓3 ↓2 ↓4 ↑ ↑ ↓3 ↓4 ↓4 ↓1 ↓1 ↓1 ↓1 ↓3 ↓4 ↓1 ↓4 ↓3
Output
top: [_ 2 _ 3 2 2 1 2 3 2 3 2 1 2 1 3 2 4 2 3 3 4 4 1 1 1 1 3 4 1 4 3]
Input
↑ ↓4 ↓4 ↑ ↓1 ↓4 ↓2 ↓3 ↓4 ↓4 ↓1 ↓1 ↓4 ↓1 ↑ ↓1 ↓3 ↓4 ↓1 ↓4 ↓4 ↑ ↓2 ↓3 ↓3 ↓2 ↓1 ↓2 ↓3 ↓1 ↑ ↓2
Output
top: [_ 4 4 4 1 4 2 3 4 4 1 1 4 1 4 1 3 4 1 4 4 4 2 3 3 2 1 2 3 1 3 2]
Input
↓3 ↓2 ↓4 ↓4 ↓1 ↑ ↓4 ↓2 ↓2 ↓2 ↑ ↑ ↓1 ↓3 ↓3 ↓3 ↓4 ↓2 ↓2 ↑ ↓1 ↑ ↓4 ↓4 ↑ ↑ ↓4 ↓1 ↓2 ↓4 ↓3 ↓1
Output
top: [3 2 4 4 1 4 4 2 2 2 2 2 1 3 3 3 4 2 2 2 1 2 4 4 4 2 4 1 2 4 3 1]
Input
↓4 ↓4 ↓4 ↓4 ↓2 ↓4 ↓1 ↓2 ↓4 ↓2 ↓2 ↓4 ↓3 ↑ ↑ ↓2 ↑ ↓2 ↓4 ↓4 ↓2 ↓3 ↓1 ↓4 ↑ ↓4 ↓4 ↓1 ↓4 ↓2 ↓4 ↓4
Output
top: [4 4 4 4 2 4 1 2 4 2 2 4 3 4 2 2 2 2 4 4 2 3 1 4 1 4 4 1 4 2 4 4]

Context Sensitive

(9 tasks)

10. Associative Recall

L=12

Given key-value pairs followed by a query key, retrieve the associated value. This tests content-addressable memory: the model must store all pairs, then perform a lookup by matching the query key — the core operation of an associative memory or hash table.

Input
{h:d, d:e, a:a, g:a, f:h} ? a
Output
a
Input
{h:g, d:c, f:f, g:c, a:a} ? h
Output
g
Input
{f:c, e:f, b:g, d:e, a:f} ? d
Output
e
Input
{b:b, e:f, g:h, f:d, d:b} ? f
Output
d
Input
{d:h, f:c, h:d, a:c, e:g} ? a
Output
c

18. Count N

L=30

Validate that a sequence consists of n symbol types each appearing exactly k times in consecutive blocks: s1k s2k … snk. This is a classic context-sensitive language — recognizing it requires comparing counts across multiple symbol groups simultaneously.

Input
aaaabcacccabacbcbcbbcbcaabccba
Output
invalid
Input
aaaaaaaaaabbbbbbbbbbcccccccccc
Output
valid
Input
acbccabbccacaabbbcaacacbbbaabb
Output
invalid
Input
bbbabcacacacabbaabbacccccabcab
Output
invalid
Input
aaaaaaaaaabbbbbbbbbbcccccccccc
Output
valid

19. Deduplicate Inputs

L=32

Given a stream where each symbol is repeated k times consecutively, extract the unique sequence. The model must learn to skip redundant repetitions — a form of streaming compression that requires tracking position within each group.

Input
f f f c c c a a a c c c h h h b b b c c c f f f d d d h h h d d d h h h a a a d d d c c c a a a b b b h h h b b b f f f g g g c c c f f f c c c a a a c c c g g g d d d g g g b b b h h h a a a
Output
f c a c h b c f d h d h a d c a b h b f g c f c a c g d g b h a
Input
c c c e e e d d d b b b d d d a a a c c c e e e h h h d d d a a a f f f h h h d d d c c c b b b h h h f f f h h h d d d b b b c c c h h h d d d h h h g g g d d d c c c b b b c c c a a a g g g
Output
c e d b d a c e h d a f h d c b h f h d b c h d h g d c b c a g
Input
e e e a a a f f f c c c f f f d d d c c c g g g h h h c c c e e e c c c e e e g g g a a a d d d b b b f f f a a a h h h e e e h h h c c c b b b c c c h h h c c c d d d f f f g g g b b b e e e
Output
e a f c f d c g h c e c e g a d b f a h e h c b c h c d f g b e
Input
h h h c c c e e e b b b c c c g g g f f f h h h b b b g g g b b b f f f g g g e e e g g g b b b a a a h h h b b b g g g b b b f f f c c c d d d h h h c c c e e e f f f a a a c c c h h h b b b
Output
h c e b c g f h b g b f g e g b a h b g b f c d h c e f a c h b
Input
h h h a a a h h h d d d f f f g g g e e e b b b f f f d d d h h h b b b f f f c c c e e e b b b c c c h h h g g g f f f e e e g g g e e e b b b c c c f f f d d d b b b a a a e e e b b b a a a
Output
h a h d f g e b f d h b f c e b c h g f e g e b c f d b a e b a

20. Duplicate String

L=32

Given an input string w, produce ww — concatenation of the string with itself. This is context-sensitive because the model must copy the input verbatim while remembering where the first copy ends and the second begins, requiring more than a single stack.

Input
g b c f h e e e h e f b d d c b e e c a c b d f h g h c d a e h
Output
g b c f h e e e h e f b d d c b e e c a c b d f h g h c d a e h g b c f h e e e h e f b d d c b e e c a c b d f h g h c d a e h
Input
e d f a c a c d c f g f f f d d g d g d a a c g a g c f a e c b
Output
e d f a c a c d c f g f f f d d g d g d a a c g a g c f a e c b e d f a c a c d c f g f f f d d g d g d a a c g a g c f a e c b
Input
e f c c g c a a g g g h f c f f b a g h d h f d b h g f g g h c
Output
e f c c g c a a g g g h f c f f b a g h d h f d b h g f g g h c e f c c g c a a g g g h f c f f b a g h d h f d b h g f g g h c
Input
f b h d d b a a d a e a b a g b a c e c h h d h b f a d a e g b
Output
f b h d d b a a d a e a b a g b a c e c h h d h b f a d a e g b f b h d d b a a d a e a b a g b a c e c h h d h b f a d a e g b
Input
a h e e f b a h a c f d h a b g f c h b a e a b b e f d c g b h
Output
a h e e f b a h a c f d h a b g f c h b a e a b b e f d c g b h a h e e f b a h a c f d h a b g f c h b a e a b b e f d c g b h

21. Missing Duplicate

L=32

Given a sequence where every element appears exactly twice except one singleton, identify the unpaired element. The input is shuffled, so the model must maintain counts or use XOR-like cancellation across the entire input to isolate it.

Input
1 24 15 14 26 7 24 15 23 13 22 10 29 4 2 6 1 34 28 2 19 33 21 28 17 11 12 33 5 22 10 12 11 18 21 23 32 18 3 6 29 25 31 7 17 27 27 32 34 14 3 31 19 13 4 20 9 8 20 9 25 26 5
Output
missing: 8
Input
9 34 10 33 1 20 19 8 26 3 13 29 22 23 17 12 33 18 6 21 16 2 24 30 26 31 11 13 15 28 34 18 28 31 12 14 32 1 6 17 11 32 9 7 15 25 21 4 30 2 10 20 16 19 4 7 3 29 23 22 25 14 24
Output
missing: 8
Input
26 8 28 18 24 33 12 32 24 2 30 26 13 25 29 9 7 1 15 3 28 32 20 1 6 23 14 16 12 18 14 27 11 15 34 25 21 29 19 19 5 22 13 33 10 3 27 5 20 16 4 30 22 9 11 34 10 23 2 21 4 8 6
Output
missing: 7
Input
26 16 8 24 18 20 31 32 34 12 2 30 27 30 4 21 22 29 28 6 19 23 27 20 11 8 7 1 5 23 9 26 13 12 33 33 18 14 34 3 5 6 32 10 11 21 14 25 10 25 4 19 29 16 3 13 24 22 28 31 9 7 1
Output
missing: 2
Input
27 6 33 26 14 26 24 28 10 6 12 18 25 1 16 9 17 29 14 21 19 13 8 11 23 7 11 22 31 3 10 32 13 17 5 25 15 2 32 2 24 27 8 5 23 34 1 20 22 3 20 7 29 34 19 28 18 21 31 12 15 33 9
Output
missing: 16

22. N Back

L=32

Given a sequence of symbols followed by a # separator and a look-back distance n, recall the single symbol that appeared n positions before the last element. For example, c a b d c d e c d e c a # 4 → c (the symbol at index 7, which is 4 steps back from the end). When n is not fixed it is sampled randomly per example, so the model must learn variable-distance temporal recall. Inspired by the n-back working memory paradigm from cognitive psychology.

Input
g b g a h c b h a c h g f g f b h h a e f g d b c a e h f g d h # 21
Output
h
Input
f b a f b d d c e b d b d e f d c e c e c c e g f c a e b d g d # 21
Output
d
Input
c d c h h d h b a a g d h d f f d c a g e h a d d e c h c h e b # 21
Output
g
Input
g d g c e c g h h e b g h g e d g h h c f b f b h a f g b d e a # 13
Output
h
Input
b e a f f f g c b g b g g b f g d d b d h h d c b c g h f d a b # 18
Output
b

23. Odds First

L=32

Reorder a sequence so all odd-valued elements come first (preserving relative order), followed by even-valued elements (also in order). This is a stable partition — the model must route elements to two groups based on a predicate while preserving within-group ordering.

Input
6 6 8 7 1 9 4 8 3 10 3 7 8 3 8 8 2 9 10 2 5 3 8 10 6 4 10 7 10 2 10 1
Output
7 1 9 3 3 7 3 9 5 3 7 1 6 6 8 4 8 10 8 8 8 2 10 2 8 10 6 4 10 10 2 10
Input
6 10 2 3 6 2 6 3 8 1 4 9 4 4 8 6 2 4 9 1 9 3 2 5 3 7 5 5 7 3 10 6
Output
3 3 1 9 9 1 9 3 5 3 7 5 5 7 3 6 10 2 6 2 6 8 4 4 4 8 6 2 4 2 10 6
Input
5 7 6 5 1 4 9 1 2 4 10 4 8 2 4 5 9 6 7 7 5 10 4 10 10 9 3 2 9 1 5 2
Output
5 7 5 1 9 1 5 9 7 7 5 9 3 9 1 5 6 4 2 4 10 4 8 2 4 6 10 4 10 10 2 2
Input
2 9 8 6 6 3 1 4 10 3 4 1 6 2 4 2 5 6 1 10 5 7 5 6 9 3 8 3 2 6 5 6
Output
9 3 1 3 1 5 1 5 7 5 9 3 3 5 2 8 6 6 4 10 4 6 2 4 2 6 10 6 8 2 6 6
Input
6 4 1 9 7 2 6 8 6 4 8 10 1 5 5 2 7 3 4 10 7 9 9 6 7 3 6 6 2 9 2 2
Output
1 9 7 1 5 5 7 3 7 9 9 7 3 9 6 4 2 6 8 6 4 8 10 2 4 10 6 6 6 2 2 2

24. Repeat Copy N

L=10

Reproduce an input pattern N times, where N is provided as the first token. This generalizes Duplicate String to a variable repeat count, testing whether the model can learn a counting loop that controls how many times to replay the memorized pattern.

Input
x3 h b b f c g g c g
Output
h b b f c g g c g h b b f c g g c g h b b f c g g c g
Input
x4 g f a f f a e h e
Output
g f a f f a e h e g f a f f a e h e g f a f f a e h e g f a f f a e h e
Input
x1 e a g d f h a a g
Output
e a g d f h a a g
Input
x2 h h e f h f h f g
Output
h h e f h f h f g h h e f h f h f g
Input
x2 b c h d c a f g b
Output
b c h d c a f g b b c h d c a f g b

25. Square Root

L=19

Compute the integer floor square root of a number given as LSD-first decimal digits. The model must reconstruct the number, compute the square root, and re-encode the result as digits — a multi-step numerical computation.

Input
sqrt(6631768524860836807)
Output
2575222034
Input
sqrt(4351688309041996285)
Output
2086070063
Input
sqrt(2725580536311336250)
Output
1650933231
Input
sqrt(4179336610818884611)
Output
2044342586
Input
sqrt(2153665688313608472)
Output
1467537286

Binary

(7 tasks)

11. Binary Addition (8-bit)

L=8

Add two binary numbers in LSB-first format. Operands are interleaved as [a0, b0, a1, b1, ...] and the output is the sum bits including carry. The model must learn ripple-carry addition, propagating carry information across all bit positions.

Input
11101100 + 1100010
Output
101001110 (334)
Input
1100 + 11110111
Output
100000011 (259)
Input
1111001 + 1101011
Output
11100100 (228)
Input
1010000 + 11110
Output
1101110 (110)
Input
11100100 + 100001
Output
100000101 (261)

12. Binary Addition (16-bit)

L=16

Add two binary numbers in LSB-first format. Operands are interleaved as [a0, b0, a1, b1, ...] and the output is the sum bits including carry. The model must learn ripple-carry addition, propagating carry information across all bit positions.

Input
100100111010110 + 1101100100010011
Output
10010001011101001 (74473)
Input
1000001100010 + 1000010100000100
Output
1001010101100110 (38246)
Input
100011001010100 + 1110011111101001
Output
10010111000111101 (77373)
Input
1111010000011110 + 111101011111011
Output
10110111100011001 (93977)
Input
110111000101111 + 110101101110110
Output
1101100110100101 (55717)

13. Binary Addition (32-bit)

L=32

Add two binary numbers in LSB-first format. Operands are interleaved as [a0, b0, a1, b1, ...] and the output is the sum bits including carry. The model must learn ripple-carry addition, propagating carry information across all bit positions.

Input
10101001010011001000010000110011 + 1001000011100110101010010010101
Output
11110001101111111101100011001000 (4055881928)
Input
10011001111011010100010000011101 + 110100101100100111010100101001
Output
11001110100111111011100101000110 (3466574150)
Input
10110100001001100011000111110101 + 10101000011101111010101100011100
Output
101011100100111011101110100010001 (5848816913)
Input
1000110111100111000000110 + 111100001011110110000111011101
Output
111101010010110010111111100011 (1028337635)
Input
100000110010110110111011001101 + 11100111010011000110111111111010
Output
100001000000101111101111011000111 (4430749383)

14. Binary Addition (64-bit)

L=64

Add two binary numbers in LSB-first format. Operands are interleaved as [a0, b0, a1, b1, ...] and the output is the sum bits including carry. The model must learn ripple-carry addition, propagating carry information across all bit positions.

Input
1011110111011111110111110101010100110001100101000000011001111011 + 1001000011100111110101011001001000110001100110001110001001111011
Output
10100111011000111101101001110011101100011001011001110100011110110 (24123448834927683830)
Input
1100110111100001101111100010000001011101000111001010101111100 + 110001110011011100100100101000111110001101001111100110001001
Output
10011000101111101010100000111001001001110110001000111100000101 (2751604875691855621)
Input
1101011001100111001101101001000111111001100111011011110101111001 + 101111011100100011101101111100001010111011010010101001001110001
Output
10011010101001011101011011000101001010001000001110000111111101010 (22287097990549540842)
Input
100000111101101010000101011111110001110011010101100010110110110 + 1101100011100110110001111100001010011001010111110010110001000001
Output
10001101011010100000010101000001000100111110010011111000111110111 (20379925767887909367)
Input
1010010101011001010110010100011001000011100011001010000000101001 + 1011000000111101110000100011011101011111101110001001111101101
Output
1011101101100001000100011000110100101111100000111011010000010110 (13502092455918679062)

15. Binary Multiplication (8-bit)

L=8

Multiply two binary numbers in LSB-first format with interleaved input encoding. The output is the product bits. This is substantially harder than addition, requiring shift-and-add operations with carries that depend on partial products from all input positions.

Input
1011101 * 10000
Output
10111010000 (1488)
Input
10101010 * 11101010
Output
1001101101100100 (39780)
Input
11110100 * 10011001
Output
1001000111010100 (37332)
Input
101 * 1000111
Output
101100011 (355)
Input
11011001 * 110111
Output
10111010011111 (11935)

16. Binary Multiplication (16-bit)

L=16

Multiply two binary numbers in LSB-first format with interleaved input encoding. The output is the product bits. This is substantially harder than addition, requiring shift-and-add operations with carries that depend on partial products from all input positions.

Input
1001011001001101 * 11111001010101
Output
100100100110001000110110010001 (613977489)
Input
100010111011111 * 111101011
Output
100001100000001010110101 (8782517)
Input
1111100000010010 * 1100001100011000
Output
10111101000011001111011110110000 (3171743664)
Input
1000001011100010 * 1110110011011100
Output
1111001000110001101001000111000 (2031669816)
Input
1111101010001011 * 111000100001000
Output
1101110100111110010111101011000 (1855926104)

17. Binary Multiplication (32-bit)

L=32

Multiply two binary numbers in LSB-first format with interleaved input encoding. The output is the product bits. This is substantially harder than addition, requiring shift-and-add operations with carries that depend on partial products from all input positions.

Input
11001101111011110001011011111011 * 11001101000010100001100111111100
Output
1010010011110000100101011010010011110101011001110010001000010100 (11885163952355090964)
Input
11101000010101011100101111101100 * 10000111011101011000001011111100
Output
111101011101111111001001001111111101100110111101001010001010000 (8858550367585997904)
Input
1101100011100111000101010111111 * 1111000001011110011101011100000
Output
11001011101010001010110011000100010011100110011010110100100000 (3668792336228920608)
Input
10011111011110011111110101001 * 10100001001010000000111111
Output
110010001100100101011010010100110011100100101010010111 (14129096280656535)
Input
1101010110111100000110001000001 * 111011011010110011011110100100
Output
1100011001101111011101101110001000101000011001101000010100100 (1787347256954638500)

Data Processing

(3 tasks)

26. Mini Shrdlu

L=32

A blocks-world planning task. Given an initial grid of numbered blocks stacked under gravity and a set of spatial constraints (above, below, left-of, right-of), produce the target board configuration. The target is reachable via valid moves (pick top block, place atop another column). Tests spatial reasoning and implicit planning.

Input
[_ _ _] / [_ _ 4] / [2 3 1] | blk 1 above blk 2; blk 1 left-of blk 3; blk 1 above blk 4; blk 3 right-of blk 4
Output
[1 _ _] / [2 _ _] / [4 _ 3]
Input
[_ _ _] / [2 3 _] / [4 1 _] | blk 1 below blk 4; blk 2 right-of blk 3; blk 2 below blk 4; blk 3 left-of blk 4
Output
[_ 4 _] / [_ 2 _] / [3 1 _]
Input
[_ _ 2] / [_ _ 3] / [_ 4 1] | blk 1 left-of blk 2; blk 1 above blk 4; blk 2 right-of blk 3; blk 3 above blk 4
Output
[1 _ _] / [3 _ _] / [4 _ 2]
Input
[_ _ _] / [1 _ _] / [4 2 3] | blk 1 right-of blk 3; blk 2 below blk 3; blk 2 above blk 4; blk 3 above blk 4
Output
[3 _ _] / [2 _ _] / [4 1 _]
Input
[_ _ _] / [2 _ _] / [4 3 1] | blk 1 above blk 2; blk 1 below blk 3; blk 2 below blk 3; blk 2 right-of blk 4
Output
[_ 3 _] / [_ 1 _] / [4 2 _]

27. Python Execution

L=32

Predict the output of a simple Python-like program: x = a; for _ in range(n): x = x op b; print(x). The model must simulate loop execution step by step, tracking the accumulator through multiple iterations — a test of sequential program trace prediction.

Input
x = 4; for _ in range(1): x = x * 7; print(x)
Output
9
Input
x = 6; for _ in range(5): x = x - 3; print(x)
Output
0
Input
x = 1; for _ in range(2): x = x + 5; print(x)
Output
9
Input
x = 0; for _ in range(5): x = x * 9; print(x)
Output
0
Input
x = 4; for _ in range(3): x = x + 8; print(x)
Output
9

28. Sort

L=32

Sort a sequence of integers in ascending order. While conceptually simple, learning to sort from examples alone requires the model to discover comparison-based ordering — an algorithmic capability that must generalize across sequence lengths.

Input
[10, 37, 19, 83, 83, 36, 61, 49, 60, 10, 57, 89, 3, 18, 25, 3, 30, 1, 68, 96, 29, 27, 71, 83, 2, 65, 12, 34, 4, 7, 56, 45]
Output
[1, 2, 3, 3, 4, 7, 10, 10, 12, 18, 19, 25, 27, 29, 30, 34, 36, 37, 45, 49, 56, 57, 60, 61, 65, 68, 71, 83, 83, 83, 89, 96]
Input
[7, 51, 88, 16, 12, 50, 88, 60, 74, 36, 50, 78, 19, 7, 14, 96, 34, 16, 72, 98, 31, 1, 61, 62, 34, 71, 11, 78, 72, 72, 58, 60]
Output
[1, 7, 7, 11, 12, 14, 16, 16, 19, 31, 34, 34, 36, 50, 50, 51, 58, 60, 60, 61, 62, 71, 72, 72, 72, 74, 78, 78, 88, 88, 96, 98]
Input
[42, 28, 17, 53, 75, 44, 43, 89, 87, 35, 8, 99, 12, 52, 62, 27, 44, 69, 81, 68, 51, 24, 13, 17, 9, 15, 50, 75, 50, 4, 82, 20]
Output
[4, 8, 9, 12, 13, 15, 17, 17, 20, 24, 27, 28, 35, 42, 43, 44, 44, 50, 50, 51, 52, 53, 62, 68, 69, 75, 75, 81, 82, 87, 89, 99]
Input
[43, 72, 16, 80, 40, 38, 65, 31, 46, 71, 56, 39, 8, 47, 54, 49, 20, 51, 21, 92, 30, 26, 4, 10, 92, 78, 27, 58, 73, 40, 92, 17]
Output
[4, 8, 10, 16, 17, 20, 21, 26, 27, 30, 31, 38, 39, 40, 40, 43, 46, 47, 49, 51, 54, 56, 58, 65, 71, 72, 73, 78, 80, 92, 92, 92]
Input
[35, 19, 10, 52, 44, 34, 14, 15, 52, 92, 68, 55, 16, 46, 19, 8, 12, 75, 9, 44, 77, 44, 40, 27, 53, 95, 45, 40, 34, 36, 9, 79]
Output
[8, 9, 9, 10, 12, 14, 15, 16, 19, 19, 27, 34, 34, 35, 36, 40, 40, 44, 44, 44, 45, 46, 52, 52, 53, 55, 68, 75, 77, 79, 92, 95]

Graphs Geometry

(6 tasks)

29. Convex Hull

L=30

Given a set of 2D points, output a binary mask indicating which points lie on the convex hull — the smallest convex polygon enclosing all points. The model must determine whether each point is an extreme point that cannot be expressed as a convex combination of others.

Input
points [(58,90), (49,42), (50,66), (48,63), (56,6), (47,34), (29,39), (89,8), (27,38), (59,99)]
Output
hull: {p5(56,6), p8(89,8), p9(27,38), p10(59,99)}
Input
points [(90,99), (21,43), (57,58), (37,19), (25,53), (33,76), (30,85), (85,56), (1,62), (46,74)]
Output
hull: {p1(90,99), p4(37,19), p7(30,85), p8(85,56), p9(1,62)}
Input
points [(89,93), (46,41), (77,17), (40,62), (67,77), (75,30), (85,52), (55,8), (96,56), (84,27)]
Output
hull: {p1(89,93), p3(77,17), p4(40,62), p8(55,8), p9(96,56), p10(84,27)}
Input
points [(71,37), (51,87), (53,67), (51,42), (52,66), (56,86), (24,27), (63,76), (24,26), (43,53)]
Output
hull: {p1(71,37), p2(51,87), p6(56,86), p7(24,27), p8(63,76), p9(24,26)}
Input
points [(69,16), (0,89), (92,45), (52,80), (79,23), (32,4), (71,70), (24,59), (67,91), (50,53)]
Output
hull: {p1(69,16), p2(0,89), p3(92,45), p5(79,23), p6(32,4), p9(67,91)}

30. Delaunay

L=30

Given a set of 2D points, output the Delaunay triangulation as triangle vertex triples. In a Delaunay triangulation, no point lies inside the circumscribed circle of any triangle — this maximizes the minimum angle. The model must learn to partition the plane into triangles satisfying this geometric optimality criterion.

Input
points [(41,89), (93,49), (83,83), (53,49), (39,85), (69,19), (70,15), (60,74), (59,10), (18,59)]
Output
triangles: [(9,4,10), (4,6,2), (6,4,9), (5,1,10), (4,5,10), (7,6,9), (6,7,2), (8,5,4), (8,4,2), (3,8,2), (8,3,1), (5,8,1)]
Input
points [(40,26), (58,56), (39,83), (3,47), (13,85), (96,30), (15,75), (80,95), (59,21), (53,86)]
Output
triangles: [(8,2,6), (7,5,4), (1,7,4), (7,1,2), (5,10,8), (10,2,8), (2,9,6), (1,9,2), (7,3,5), (3,10,5), (3,7,2), (10,3,2)]
Input
points [(31,19), (5,3), (46,36), (52,13), (56,15), (22,58), (63,1), (31,24), (74,18), (30,55)]
Output
triangles: [(8,6,2), (8,10,6), (3,10,8), (10,3,9), (4,3,8), (7,4,2), (1,8,2), (4,1,2), (1,4,8), (3,5,9), (4,5,3), (5,7,9), (5,4,7)]
Input
points [(72,74), (65,60), (51,38), (43,51), (27,32), (66,55), (41,29), (67,77), (21,87), (82,26)]
Output
triangles: [(3,7,10), (6,3,10), (1,6,10), (6,1,2), (5,4,9), (4,6,2), (6,4,3), (7,4,5), (4,7,3), (1,8,2), (4,8,9), (8,4,2)]
Input
points [(77,4), (95,79), (53,11), (20,94), (80,54), (25,41), (15,30), (0,18), (84,70), (16,7)]
Output
triangles: [(5,1,2), (5,4,6), (10,7,8), (7,4,8), (4,7,6), (5,3,1), (3,5,6), (3,10,1), (7,3,6), (3,7,10), (9,5,2), (4,9,2), (9,4,5)]

31. Graph Traversal

L=30

Given an unweighted graph and source node, output the BFS visit rank of each node. The model must learn level-by-level expansion — exploring all nodes at distance d before moving to d+1.

Input
graph {1-3, 1-4, 2-3, 2-4, 3-4, 4-5}, src=0
Output
BFS order: 0 -> 2 -> 3 -> 1 -> 4
Input
graph {1-5, 2-4, 2-5, 3-4}, src=0
Output
BFS order: 0 -> 4 -> 1 -> 3 -> 2
Input
graph {1-3, 1-4, 1-5, 2-5, 3-4}, src=0
Output
BFS order: 0 -> 2 -> 3 -> 4 -> 1
Input
graph {1-3, 1-5, 2-3, 2-4}, src=0
Output
BFS order: 0 -> 2 -> 4 -> 1 -> 3
Input
graph {1-2, 1-3, 2-5, 4-5}, src=0
Output
BFS order: 0 -> 1 -> 2 -> 4 -> 3

32. Mst Prim

L=30

Given a weighted undirected graph, output its minimum spanning tree edges. Ground truth uses SciPy. The model must learn to greedily select the lowest-weight edge connecting a new node to the growing tree without forming cycles.

Input
graph {1-2:9, 2-4:9, 3-4:5, 3-5:3}
Output
MST {1-2:9, 2-4:9, 3-4:5, 3-5:3} (weight=26)
Input
graph {1-2:4, 1-5:7, 2-3:1, 2-4:4, 4-5:1}
Output
MST {1-2:4, 2-3:1, 2-4:4, 4-5:1} (weight=10)
Input
graph {1-2:3, 1-4:8, 1-5:8, 2-4:6, 3-5:9}
Output
MST {1-2:3, 1-5:8, 2-4:6, 3-5:9} (weight=26)
Input
graph {1-2:4, 1-3:7, 1-5:5, 2-4:1, 2-5:5}
Output
MST {1-2:4, 1-3:7, 1-5:5, 2-4:1} (weight=17)
Input
graph {1-5:7, 2-3:8, 2-4:9, 2-5:7, 3-4:6}
Output
MST {1-5:7, 2-3:8, 2-5:7, 3-4:6} (weight=28)

33. Shortest Path

L=30

Given a weighted undirected graph and a source-target pair, output the shortest path as a node sequence. Ground truth uses Dijkstra’s algorithm. The model must learn implicit graph search — propagating distance estimates to reconstruct the optimal path.

Input
graph {1-4:6, 1-5:4, 1-6:8, 2-3:4, 2-7:1, 3-6:9, 4-6:5, 4-7:6, 5-7:8, 6-7:4}, find path 2->3
Output
path: 2 -> 1 -> 6 -> 3
Input
graph {1-3:5, 1-4:4, 1-6:2, 1-7:5, 2-4:8, 2-7:5, 3-5:1, 4-6:7, 6-7:4}, find path 5->6
Output
path: 5 -> 6
Input
graph {1-3:7, 1-4:6, 2-3:6, 2-4:5, 2-5:7, 2-6:7, 3-5:9, 3-7:1, 4-6:1, 4-7:4, 5-6:6, 5-7:7}, find path 3->1
Output
path: 3 -> 1
Input
graph {1-2:5, 1-3:4, 1-6:3, 1-7:3, 3-4:6, 4-5:4, 4-6:7, 5-6:9, 5-7:4, 6-7:2}, find path 5->1
Output
path: 5 -> 0 -> 1
Input
graph {1-5:2, 1-7:1, 2-3:4, 2-4:6, 3-4:5, 3-5:8, 3-6:3, 3-7:7, 4-6:7, 4-7:1, 5-6:7, 6-7:6}, find path 2->3
Output
path: 2 -> 3

34. Tsp

L=30

Given 2D cities with integer coordinates, output a tour using the nearest-neighbor heuristic: starting from city 1, always visit the closest unvisited city. The model must learn to simulate this greedy algorithm — selecting the minimum-distance unvisited neighbor at each step.

Input
cities [(47,98), (4,14), (90,8), (84,42), (82,48), (84,85), (41,30), (90,82), (12,75), (13,42)]
Output
tour: 1 -> 6 -> 8 -> 5 -> 4 -> 3 -> 7 -> 10 -> 2 -> 9
Input
cities [(6,10), (29,88), (31,41), (10,80), (89,99), (14,30), (58,20), (20,62), (70,78), (46,32)]
Output
tour: 1 -> 6 -> 3 -> 10 -> 7 -> 8 -> 4 -> 2 -> 9 -> 5
Input
cities [(42,65), (51,33), (22,57), (61,10), (29,61), (85,66), (53,73), (10,4), (55,26), (68,27)]
Output
tour: 1 -> 5 -> 3 -> 7 -> 6 -> 10 -> 9 -> 2 -> 4 -> 8
Input
cities [(4,90), (70,71), (51,41), (14,54), (97,92), (9,29), (81,43), (56,76), (48,66), (51,36)]
Output
tour: 1 -> 4 -> 6 -> 10 -> 3 -> 9 -> 8 -> 2 -> 7 -> 5
Input
cities [(81,32), (88,15), (68,8), (9,67), (1,3), (57,22), (14,48), (93,57), (17,6), (63,18)]
Output
tour: 1 -> 2 -> 3 -> 10 -> 6 -> 9 -> 5 -> 7 -> 4 -> 8