Neural Automata Task Visualizer

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 3

Input

-> <- -> <- <- <- -> -> -> <- <- -> <- <- <- -> -> -> -> <- -> -> -> <- -> <- <- <- -> -> -> <-

Output

state 2

Input

<- -> <- -> <- -> -> -> <- <- <- <- -> -> <- -> <- -> <- <- <- <- -> -> -> <- <- <- <- <- <- ->

Output

state 4

Input

-> -> <- <- <- -> <- <- -> <- -> -> -> -> -> -> -> <- -> <- -> -> <- <- -> -> <- -> -> -> <- ->

Output

state 3

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

b a b b a b b b a b a b b b a b b a a a a a b b b a a b a a a a

Output

Input

a a a a a a b b b b b b a a b a b a a b a a a b a b b a a b b b

Output

Input

a b b b a a b a b a b a b b b a b a a b b b a a b a b b b a b b

Output

Input

a b b b b a a a b a a b a a a a b a b b b a a b a a a b a a a b

Output

Input

b a a a a b b b a a b a b a a b b b a b b b a b b b a b a b a a

Output

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

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

Output

Input

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

Output

Input

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

Output

Input

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

Output

Input

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

Output

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 a a b b b b b b a a b a b a a b b a a a a b b b b b a b b a b

Output

odd (count(a)=13)

Input

b b a a a a b b a b b b a b b a b a a a b a b a b b a a b b b a

Output

odd (count(a)=15)

Input

b b b b a a a b b a b a a a b a a b b b b a b b a a a b b a b b

Output

even (count(a)=14)

Input

b a a a a b a b b a b b a b a a a a a b b a a a a a a b a b a b

Output

even (count(a)=20)

Input

b b a a a a b b b b a b b a a a b b a b a a b a a b a a b b b b

Output

odd (count(a)=15)

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

balanced

Input

<}>[<{]{{{{{[{)]({}>()[]}}({<>)<

Output

unbalanced

Input

{[(<>[<><(<[<{}[]([]<>)>]>)>])]}

Output

balanced

Input

{()<>}{}[<(({<{[<(<[]>)>]}>}))>]

Output

balanced

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

(2-((1+4)+3)) mod 5

Output

Input

(((2-1)+(1+2))-2) mod 5

Output

Input

(1-((4*1)*2)) mod 5

Output

Input

(((1*0)+(0-4))+2) mod 5

Output

Input

(1*((3+0)*2)) mod 5

Output

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

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

Output

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

Input

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

Output

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

Input

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

Output

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

Input

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

Output

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

Input

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

Output

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

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 + 2 = 4

Output

x = 3

Input

8 * x + 2 = 4

Output

x = 4

Input

7 * x + 6 = 0

Output

x = 2

Input

8 * x + 9 = 9

Output

x = 5

Input

1 * x + 8 = 2

Output

x = 4

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 ↓2 ↑ ↓2 ↑ ↓1 ↓1 ↓1 ↑ ↑ ↓1 ↓3 ↑ ↓1 ↓2 ↓2 ↓2 ↓4 ↓3 ↓1 ↓4 ↓1 ↓1 ↓4 ↓3 ↓3 ↓1 ↓3 ↓4 ↑ ↓4 ↑

Output

top: [4 2 4 2 4 1 1 1 1 1 1 3 1 1 2 2 2 4 3 1 4 1 1 4 3 3 1 3 4 3 4 3]

Input

↓3 ↓1 ↑ ↓4 ↑ ↓1 ↑ ↑ ↓1 ↓4 ↓3 ↓3 ↓2 ↓1 ↓3 ↑ ↑ ↓1 ↓3 ↓1 ↑ ↑ ↓4 ↑ ↓1 ↑ ↓2 ↑ ↑ ↓1 ↑ ↓3

Output

top: [3 1 3 4 3 1 3 _ 1 4 3 3 2 1 3 1 2 1 3 1 3 1 4 1 1 1 2 1 2 1 2 3]

Input

↓1 ↓2 ↓1 ↓1 ↓3 ↓3 ↓2 ↑ ↓1 ↓3 ↑ ↓1 ↑ ↓3 ↑ ↓4 ↓1 ↓4 ↑ ↓1 ↓1 ↓1 ↓2 ↓1 ↓4 ↓2 ↓1 ↓2 ↑ ↓1 ↑ ↓1

Output

top: [1 2 1 1 3 3 2 3 1 3 1 1 1 3 1 4 1 4 1 1 1 1 2 1 4 2 1 2 1 1 1 1]

Input

↓2 ↓3 ↓1 ↓4 ↑ ↓1 ↓2 ↓2 ↓4 ↓1 ↓3 ↓4 ↓2 ↓2 ↓1 ↓1 ↓4 ↓1 ↓3 ↓3 ↓4 ↓3 ↓3 ↓1 ↓3 ↑ ↓2 ↓4 ↓1 ↓2 ↓1 ↑

Output

top: [2 3 1 4 1 1 2 2 4 1 3 4 2 2 1 1 4 1 3 3 4 3 3 1 3 1 2 4 1 2 1 2]

Input

↑ ↑ ↓4 ↓2 ↓4 ↑ ↓2 ↑ ↓2 ↓2 ↓3 ↓1 ↓3 ↓2 ↓3 ↓4 ↓4 ↓3 ↓1 ↓3 ↓1 ↓1 ↓3 ↑ ↓4 ↓3 ↑ ↓4 ↓3 ↑ ↓2 ↓4

Output

top: [_ _ 4 2 4 2 2 2 2 2 3 1 3 2 3 4 4 3 1 3 1 1 3 1 4 3 4 4 3 4 2 4]

Context Sensitive

(8 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

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

Output

Input

{b:f, h:b, f:b, c:h, a:c} ? f

Output

Input

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

Output

Input

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

Output

Input

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

Output

18. Count N

L=30

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

Input

cbacbaabababbcaaabbbaccbcbacbb

Output

invalid

Input

aabaacaaabbcaacaccbcabaaacabab

Output

invalid

Input

aaaaaaaaaabbbbbbbbbbcccccccccc

Output

valid

Input

aaaaaaaaaabbbbbbbbbbcccccccccc

Output

valid

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

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

Output

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

Input

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

Output

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

Input

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

Output

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

Input

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

Output

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

Input

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

Output

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

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

b c f a b g c g b b c b g a f c d d d a a e e c b a e a d b c g

Output

b c f a b g c g b b c b g a f c d d d a a e e c b a e a d b c g b c f a b g c g b b c b g a f c d d d a a e e c b a e a d b c g

Input

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

Output

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

Input

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

Output

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

Input

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

Output

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

Input

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

Output

c h g a b f d g f f f f h d a h e g c b f d e e d g h f g g f h c h g a b f d g f f f f h d a h e g c b f d e e d g h f g g f 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

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

Output

missing: 24

Input

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

Output

missing: 32

Input

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

Output

missing: 14

Input

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

Output

missing: 3

Input

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

Output

missing: 15

22. 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

3 2 7 8 4 4 4 10 8 6 3 9 9 6 2 4 4 4 3 3 6 7 4 10 3 2 4 6 2 7 10 8

Output

3 7 3 9 9 3 3 7 3 7 2 8 4 4 4 10 8 6 6 2 4 4 4 6 4 10 2 4 6 2 10 8

Input

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

Output

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

Input

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

Output

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

Input

9 7 7 8 2 6 10 3 4 3 9 7 9 7 3 5 9 8 2 7 5 6 7 8 6 6 8 2 10 2 9 6

Output

9 7 7 3 3 9 7 9 7 3 5 9 7 5 7 9 8 2 6 10 4 8 2 6 8 6 6 8 2 10 2 6

Input

6 4 5 7 6 6 7 3 9 2 1 2 6 5 7 5 4 5 6 2 3 7 1 3 4 6 2 3 3 6 5 3

Output

5 7 7 3 9 1 5 7 5 5 3 7 1 3 3 3 5 3 6 4 6 6 2 2 6 4 6 2 4 6 2 6

23. 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

x2 a b g b h a a h h

Output

a b g b h a a h h a b g b h a a h h

Input

x3 d c e h e c g h g

Output

d c e h e c g h g d c e h e c g h g d c e h e c g h g

Input

x4 h e b a c h g g c

Output

h e b a c h g g c h e b a c h g g c h e b a c h g g c h e b a c h g g c

Input

x2 a e a a f e a c g

Output

a e a a f e a c g a e a a f e a c g

Input

x5 e d d d d h a b a

Output

e d d d d h a b a e d d d d h a b a e d d d d h a b a e d d d d h a b a e d d d d h a b a

24. 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(6779584166557280589)

Output

2603763462

Input

sqrt(7557634773297768672)

Output

2749115271

Input

sqrt(9441102427498148589)

Output

3072637698

Input

sqrt(6141659993849542321)

Output

2478237275

Input

sqrt(6407445883877837623)

Output

2531293322

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

110110 + 11010111

Output

100001101 (269)

Input

10000011 + 10101

Output

10011000 (152)

Input

11001000 + 100010

Output

11101010 (234)

Input

11101101 + 101111

Output

100011100 (284)

Input

1110110 + 1000011

Output

10111001 (185)

12. Binary Addition (16-bit)

L=16

Input

1111111001101000 + 1101111111011

Output

10001101001100011 (72291)

Input

100101111001001 + 1000001000001

Output

101110000001010 (23562)

Input

1001101100011100 + 11011100000011

Output

1101001000011111 (53791)

Input

1100111110000001 + 100110010011110

Output

10001110000011111 (72735)

Input

100101000110001 + 1010001001010010

Output

1110110010000011 (60547)

13. Binary Addition (32-bit)

L=32

Input

10111110110100101001101110110110 + 1100101111100101001101100110110

Output

100100100110001010011011011101100 (4911871724)

Input

10011000011111110000110001110 + 11011001011010101100001011111000

Output

11101100011110101010010010000110 (3967460486)

Input

11100111110001011100100000110000 + 10001101110111000010110010111100

Output

101110101101000011111010011101100 (6268515564)

Input

11110111110101000110110100100000 + 1111110010111010111110011011111

Output

101110110001100011110100111111111 (6277949951)

Input

10110001100011110011001100010101 + 11011010011011101110111000011011

Output

110001011111111100010000100110000 (6643654960)

14. Binary Addition (64-bit)

L=64

Input

1110110111110000000001100010101010010010001001011010011101101010 + 1000011110010000001111001010101101010101101001111000001101100100

Output

10111010110000000010000101101010111100111110011010010101011001110 (26913584859650534094)

Input

10010101000010001001011001001011001110011110011111001110101110 + 1101010110011011111101100111001011111111111110101111001100100100

Output

1111101011011110000111000000010111001110011101001110011011010010 (18076916765575931602)

Input

1111111100001010001110011010011001111011101111111101100010110111 + 101011011010001100111000001111111000001111010100100111001101001

Output

10101010111011011110101011100011000111101101010100010011100100000 (24633517634247862048)

Input

1101011111000010101011101010101001011011110011001000010110110 + 1111000010111101100110010111100100001001100111011010011010101111

Output

10000101110110101111011110100111001010101000101110011011101100101 (19290587698625460069)

Input

1101001111001101001110101000010111111000011111111001101000101111 + 10010011100011110111111001100111011110111000111000000001001110

Output

1111100010110001000110100001111111010111011000110001101001111101 (17920133116343818877)

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

1100001 * 100011

Output

110101000011 (3395)

Input

1100011 * 1101010

Output

10100011111110 (10494)

Input

10110000 * 1100000

Output

100001000000000 (16896)

Input

100101 * 11000101

Output

1110001111001 (7289)

Input

10110100 * 11001000

Output

1000110010100000 (36000)

16. Binary Multiplication (16-bit)

L=16

Input

1111101011001011 * 1000000000001100

Output

1111101011100010100000110000100 (2104574340)

Input

110101010101101 * 1011101001110011

Output

1001101101100011001110110110111 (1303485879)

Input

1000101010000101 * 1101100101111011

Output

1110101101011010100101011100111 (1974291175)

Input

100010000101110 * 1101010100011100

Output

111000110000011011101100001000 (952220424)

Input

1110010000010000 * 110110011110111

Output

1100001000100101100101101110000 (1628621680)

17. Binary Multiplication (32-bit)

L=32

Input

1101010100100100100100010010010 * 10101010110110101111000011110100

Output

100011100100000010010010001000101110111110010100000101100101000 (5125176715320625960)

Input

10111110101110101010101011110000 * 10011101010111010101101100001100

Output

111010100111110000010000111101010010100101100110101001101000000 (8448199273567441728)

Input

11101110001000110011000001100110 * 10111011000100011110001111010001

Output

1010111000000100010110001001110001010111011010101111010101000110 (12539244691011073350)

Input

10111100010111010010110100111000 * 11000111010000001010110010010000

Output

1001001010011100000001000110101001100100110010110000111110000000 (10564323680908414848)

Input

1001010111001101000001010011110 * 11001001001001000110001010101

Output

11101011011001101000011101010111010001011111100011001110110 (530074807982605942)

Data Processing

(3 tasks)

25. 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

[_ _ _] / [_ 3 _] / [2 4 1] | blk 1 above blk 3; blk 1 above blk 4; blk 3 below blk 4

Output

[_ 1 _] / [_ 4 _] / [2 3 _]

Input

[3 _ _] / [1 _ _] / [2 _ 4] | blk 1 left-of blk 2; blk 1 left-of blk 3; blk 2 above blk 4; blk 3 above blk 4

Output

[_ _ 3] / [_ _ 2] / [1 _ 4]

Input

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

Output

[_ _ _] / [3 _ 4] / [2 _ 1]

Input

[3 _ _] / [2 _ _] / [1 4 _] | blk 1 right-of blk 2; blk 1 above blk 3; blk 1 above blk 4; blk 3 above blk 4

Output

[_ 1 _] / [_ 3 _] / [2 4 _]

Input

[_ _ _] / [_ 3 2] / [_ 1 4] | blk 1 above blk 3

Output

[_ _ _] / [_ 1 2] / [_ 3 4]

26. 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 = 7; for _ in range(2): x = x - 3; print(x)

Output

Input

x = 0; for _ in range(3): x = x * 2; print(x)

Output

Input

x = 7; for _ in range(2): x = x * 8; print(x)

Output

Input

x = 8; for _ in range(2): x = x * 7; print(x)

Output

Input

x = 3; for _ in range(4): x = x - 7; print(x)

Output

27. 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

[96, 10, 54, 63, 79, 61, 2, 75, 60, 45, 52, 60, 73, 26, 62, 23, 85, 75, 77, 21, 62, 88, 83, 29, 22, 43, 96, 36, 18, 81, 5, 95]

Output

[2, 5, 10, 18, 21, 22, 23, 26, 29, 36, 43, 45, 52, 54, 60, 60, 61, 62, 62, 63, 73, 75, 75, 77, 79, 81, 83, 85, 88, 95, 96, 96]

Input

[25, 90, 17, 83, 55, 90, 53, 50, 28, 23, 62, 79, 88, 3, 32, 54, 85, 96, 3, 15, 52, 77, 17, 5, 27, 42, 28, 15, 19, 71, 50, 79]

Output

[3, 3, 5, 15, 15, 17, 17, 19, 23, 25, 27, 28, 28, 32, 42, 50, 50, 52, 53, 54, 55, 62, 71, 77, 79, 79, 83, 85, 88, 90, 90, 96]

Input

[83, 83, 13, 75, 23, 18, 92, 67, 37, 13, 14, 70, 56, 98, 72, 2, 7, 76, 69, 55, 21, 81, 85, 94, 23, 51, 15, 37, 30, 87, 72, 76]

Output

[2, 7, 13, 13, 14, 15, 18, 21, 23, 23, 30, 37, 37, 51, 55, 56, 67, 69, 70, 72, 72, 75, 76, 76, 81, 83, 83, 85, 87, 92, 94, 98]

Input

[43, 75, 6, 80, 41, 60, 83, 43, 20, 52, 59, 94, 37, 15, 16, 21, 90, 78, 33, 37, 24, 73, 57, 66, 64, 79, 1, 88, 43, 14, 4, 66]

Output

[1, 4, 6, 14, 15, 16, 20, 21, 24, 33, 37, 37, 41, 43, 43, 43, 52, 57, 59, 60, 64, 66, 66, 73, 75, 78, 79, 80, 83, 88, 90, 94]

Input

[31, 67, 5, 36, 71, 9, 83, 25, 63, 5, 43, 31, 8, 10, 54, 16, 73, 68, 79, 16, 1, 85, 24, 23, 33, 47, 58, 36, 91, 56, 8, 37]

Output

[1, 5, 5, 8, 8, 9, 10, 16, 16, 23, 24, 25, 31, 31, 33, 36, 36, 37, 43, 47, 54, 56, 58, 63, 67, 68, 71, 73, 79, 83, 85, 91]

Graphs Geometry

(6 tasks)

28. 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 [(31,5), (56,17), (1,89), (81,43), (68,33), (14,93), (21,87), (95,84), (75,33), (88,73)]

Output

hull: {p1(31,5), p2(56,17), p3(1,89), p4(81,43), p6(14,93), p8(95,84), p9(75,33)}

Input

points [(88,29), (11,22), (23,49), (27,19), (13,17), (27,12), (32,76), (90,86), (29,4), (11,41)]

Output

hull: {p1(88,29), p2(11,22), p5(13,17), p7(32,76), p8(90,86), p9(29,4), p10(11,41)}

Input

points [(85,36), (86,28), (34,88), (14,97), (95,91), (46,82), (67,39), (62,20), (94,57), (3,9)]

Output

hull: {p2(86,28), p4(14,97), p5(95,91), p8(62,20), p9(94,57), p10(3,9)}

Input

points [(68,64), (1,27), (2,29), (89,38), (84,19), (50,30), (67,31), (34,16), (10,67), (74,61)]

Output

hull: {p1(68,64), p2(1,27), p4(89,38), p5(84,19), p8(34,16), p9(10,67), p10(74,61)}

Input

points [(81,80), (66,55), (44,70), (49,49), (21,35), (89,84), (78,26), (70,42), (52,45), (1,67)]

Output

hull: {p5(21,35), p6(89,84), p7(78,26), p10(1,67)}

29. 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 [(44,46), (49,66), (3,28), (0,43), (75,61), (58,52), (69,5), (34,69), (15,38), (77,64)]

Output

triangles: [(6,1,7), (1,9,7), (9,3,7), (3,9,4), (9,8,4), (8,9,1), (5,7,10), (5,6,7), (2,8,1), (6,2,1), (5,2,6), (8,2,10), (2,5,10)]

Input

points [(15,7), (61,14), (5,83), (7,99), (44,1), (24,84), (32,32), (61,68), (28,50), (86,48)]

Output

triangles: [(1,9,3), (8,2,10), (7,9,1), (5,7,1), (2,7,5), (7,8,9), (7,2,8), (9,6,3), (8,6,9), (6,4,3), (6,8,4)]

Input

points [(60,1), (89,18), (56,30), (37,81), (19,21), (61,74), (53,0), (75,46), (21,29), (31,64)]

Output

triangles: [(7,3,5), (3,1,2), (1,3,7), (10,6,4), (6,10,3), (3,9,5), (10,9,3), (8,3,2), (8,6,3)]

Input

points [(61,10), (27,58), (59,49), (76,38), (8,12), (4,92), (81,89), (85,8), (98,23), (94,52)]

Output

triangles: [(5,2,6), (2,7,6), (7,2,3), (4,8,9), (8,1,5), (1,2,5), (2,1,3), (1,4,3), (4,1,8), (10,7,3), (4,10,3), (10,4,9)]

Input

points [(23,75), (20,57), (15,48), (47,96), (75,18), (5,42), (46,0), (70,52), (11,90), (62,24)]

Output

triangles: [(2,9,6), (8,10,5), (10,7,5), (2,10,8), (1,8,4), (1,2,8), (9,1,4), (2,1,9), (3,2,6), (3,10,2), (7,3,6), (10,3,7)]

30. 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-4, 1-5, 2-3, 2-5}, src=0

Output

BFS order: 0 -> 3 -> 4 -> 1 -> 2

Input

graph {1-2, 1-4, 3-4, 3-5}, src=0

Output

BFS order: 0 -> 1 -> 3 -> 2 -> 4

Input

graph {1-3, 1-4, 1-5, 2-3, 4-5}, src=0

Output

BFS order: 0 -> 2 -> 3 -> 4 -> 1

Input

graph {1-3, 1-4, 2-3, 2-4, 2-5}, src=0

Output

BFS order: 0 -> 2 -> 3 -> 1 -> 4

Input

graph {1-2, 1-4, 2-3, 3-5, 4-5}, src=0

Output

BFS order: 0 -> 1 -> 3 -> 2 -> 4

31. 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:2, 1-5:6, 2-4:2, 2-5:3, 3-4:6}

Output

MST {1-2:2, 2-4:2, 2-5:3, 3-4:6} (weight=13)

Input

graph {1-3:8, 1-5:3, 2-3:3, 4-5:7}

Output

MST {1-3:8, 1-5:3, 2-3:3, 4-5:7} (weight=21)

Input

graph {1-4:5, 1-5:7, 2-3:3, 2-4:5, 3-4:7}

Output

MST {1-4:5, 1-5:7, 2-3:3, 2-4:5} (weight=20)

Input

graph {1-2:9, 1-3:8, 1-4:6, 1-5:1, 2-3:2, 2-5:4, 3-4:7}

Output

MST {1-4:6, 1-5:1, 2-3:2, 2-5:4} (weight=13)

Input

graph {1-2:3, 1-4:1, 1-5:3, 2-3:9, 3-5:6}

Output

MST {1-2:3, 1-4:1, 1-5:3, 3-5:6} (weight=13)

32. 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-6:7, 1-7:5, 2-3:6, 2-4:7, 2-5:7, 2-6:7, 2-7:7, 3-4:3, 3-5:9, 3-6:6, 4-6:6, 4-7:4, 5-6:5, 6-7:3}, find path 3->2

Output

path: 3 -> 2

Input

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

Output

path: 6 -> 2

Input

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

Output

path: 2 -> 3 -> 5 -> 4

Input

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

Output

path: 3 -> 6 -> 0

Input

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

Output

path: 5 -> 2 -> 3

33. 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 [(14,15), (11,31), (70,96), (67,49), (58,30), (63,3), (5,57), (25,34), (64,34), (54,76)]

Output

tour: 1 -> 2 -> 8 -> 7 -> 10 -> 3 -> 4 -> 9 -> 5 -> 6

Input

cities [(40,67), (58,28), (6,34), (84,88), (86,53), (57,67), (51,94), (69,24), (20,16), (55,52)]

Output

tour: 1 -> 6 -> 10 -> 2 -> 8 -> 5 -> 4 -> 7 -> 3 -> 9

Input

cities [(60,16), (74,43), (20,87), (52,94), (85,19), (50,80), (98,16), (34,47), (36,75), (3,18)]

Output

tour: 1 -> 5 -> 7 -> 2 -> 8 -> 9 -> 6 -> 4 -> 3 -> 10

Input

cities [(21,74), (38,20), (33,33), (4,84), (89,60), (74,42), (50,88), (75,46), (65,88), (35,72)]

Output

tour: 1 -> 10 -> 7 -> 9 -> 5 -> 8 -> 6 -> 3 -> 2 -> 4

Input

cities [(41,86), (12,16), (40,26), (5,67), (46,19), (67,82), (50,13), (38,1), (63,0), (75,97)]

Output

tour: 1 -> 6 -> 10 -> 4 -> 2 -> 3 -> 5 -> 7 -> 8 -> 9