Nemotron-Post-Training-v3 Prompt-Only
Collection
51 items • Updated
Datasets:
dataset stringclasses 1
value | config stringclasses 2
values | split stringclasses 2
values | row_index int64 0 10k | prompt stringlengths 182 10.5k | prompt_source stringclasses 1
value | prompt_source_detail stringclasses 1
value | system_prompt stringclasses 2
values | system_source stringclasses 1
value | tools float64 | tools_source float64 | schema_str float64 | extraction_error float64 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 0 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
292
444
999
Output:
000
555
555
Train Example 2:
Input:
733
666
377
Output:
000
555
000
Train Example 3:
Input:
224
224
111
Output:
000
000
555
Train Example 4:
Input:
444
232
233
Output:
555
000
000
Test Input:
444
323
888
| responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 1 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
995
558
589
Output:
955
958
589
Train Example 2:
Input:
225
622
555
Output:
265
225
525
Train Example 3:
Input:
266
211
262
Output:
222
616
612
Train Example 4:
Input:
221
151
522
Output:
215
252
112
Test Input:
934
944
934
| responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 2 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
440044
440044
440044
440044
440044
440044
Output:
99
99
Train Example 2:
Input:
440044
440044
004400
004400
440044
440044
Output:
99
99
Train Example 3:
Input:
440000
440000
440000
440000
004400
004400
Output:
66
66
Train Example 4:
Input:
444400
444... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 3 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
333
333
333
Output:
555
000
000
Train Example 2:
Input:
333
422
442
Output:
005
050
500
Train Example 3:
Input:
444
444
444
Output:
555
000
000
Train Example 4:
Input:
444
444
333
Output:
500
050
005
Train Example 5:
Input:
222
323
333
Output:
50... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 4 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00200
00000
00000
Output:
00000
08070
00000
Train Example 2:
Input:
00000
00000
00002
Output:
00000
00030
00000
Train Example 3:
Input:
00000
00020
00000
Output:
00306
00000
00807
Train Example 4:
Input:
00000
02000
00000
Output:
30600
00000
80700
... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 5 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000880
0000080
0080000
0088000
0000000
0000800
0008800
Output:
0000880
0000180
0081000
0088000
0000000
0001800
0008800
Train Example 2:
Input:
0000000
0800000
0880000
0000880
0000080
0000000
0000000
Output:
0000000
0810000
0880000
0000880
0000180
0000000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 6 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
080
000
000
Output:
000
020
000
Train Example 2:
Input:
88000
88000
00000
00000
00000
Output:
00000
22000
22000
00000
00000
Train Example 3:
Input:
00000
08880
00000
00000
00000
Output:
00000
00000
02220
00000
00000
Test Input:
00800
08800
00800
000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 7 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
9494
9944
4444
Output:
4444
9944
9494
9494
9944
4444
Train Example 2:
Input:
4114
1111
4441
Output:
4441
1111
4114
4114
1111
4441
Train Example 3:
Input:
3355
3553
5533
Output:
5533
3553
3355
3355
3553
5533
Train Example 4:
Input:
9959
5599
9599
Out... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 8 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
22222
22222
22022
22222
22222
Output:
02220
20202
22022
20202
02220
Train Example 2:
Input:
111
101
111
Output:
010
101
010
Train Example 3:
Input:
3333333
3333333
3333333
3330333
3333333
3333333
3333333
Output:
0333330
3033303
3303033
3330333
3303033
... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 9 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00000000000
02222000000
02222000000
02222000000
02222000000
00000000000
00000000000
00111111000
00111111000
00111111000
00000000000
00000000000
Output:
00000000000
02222000000
02882000000
02882000000
02222000000
00000000000
00000000000
00111111000
0018888100... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 10 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000000000
0103000000
0000000000
0004000000
0000000000
0000000000
0000000000
0000000008
0000000000
0000000202
Output:
11113333000000000000
11113333000000000000
11113333000000000000
11113333000000000000
00004444000000000000
00004444000000000000
00004444000000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 11 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00000002
00000000
00030000
00000000
00000080
00000000
00200000
00000000
Output:
00000012
00000011
00030000
00000000
00000080
01110000
01210000
01110000
Train Example 2:
Input:
20000
00020
00000
06000
00000
Output:
21111
11121
00111
06000
00000
Train Exam... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 12 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
3030033303
0222002020
0220000200
0208088020
3220880220
3008080200
0028088220
0220222220
0022202023
3330333303
Output:
3333333333
3222222223
3222222223
3228888223
3228888223
3228888223
3228888223
3222222223
3222222223
3333333333
Train Example 2:
Input:
0000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 13 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
1105010
0015111
1105010
Output:
020
002
020
Train Example 2:
Input:
1005010
0105111
1005000
Output:
000
020
000
Train Example 3:
Input:
0015000
1105101
0115101
Output:
000
200
002
Test Input:
1015101
0105101
1015010
| responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 14 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00080608006
00080008060
06080608000
88888888888
00080008000
00080608000
60080008060
88888888888
00080008600
06080008006
00086008000
Output:
011
000
001
Train Example 2:
Input:
60080008000
00080068006
00080008000
88888888888
60080008000
00080008060
00080068... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 15 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00000000000
08880000770
00800020070
08800220070
08800020070
00000000000
Output:
888
080
880
880
Train Example 2:
Input:
0000000660
0300440060
3330440000
0300440000
0000000000
Output:
44
44
44
Train Example 3:
Input:
000000000
000700222
000770020
0000702... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 16 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
000000000000000
044440000000000
044440000002200
044440000002200
044440000002200
044440011002200
044440011002200
Output:
0000000000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 17 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00000000000000
00000000000000
00000000000000
00000000000000
00000000400000
00000000800000
00000002384000
00000000200000
00000000000000
00000000000000
00000000000000
00000000000000
00000000000000
00000000000000
00000000000000
Output:
00000000400000
0000000080... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 18 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
667766777
767776677
777677776
776667676
767677676
767777777
767777766
777766676
777766677
Output:
447788777
747778877
777377772
773337972
727377972
727777777
727777744
777755574
777755577
Train Example 2:
Input:
777777777
767767777
666767667
767777767
7777... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 19 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000000000
0040000002
0000008000
0000000000
0000600000
9000000000
0000000050
0300000000
0000000000
0000000000
Output:
934
586
200
Train Example 2:
Input:
0000000000
0000000000
0100600000
0000000000
3000000000
0000007000
0000000000
0000000009
0080000000
000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 20 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
777777777
777777777
777777777
777777777
277787777
555555777
555555777
555555777
555555777
Output:
777777777
777777777
777777777
777777777
777727777
555555777
555555777
555555777
555555877
Train Example 2:
Input:
7777777
7727877
7755577
7755577
7755577
7755... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 21 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
11111111111111111
11111111111111111
11111111111111111
11111111111111111
11111111111155555
11111111111155555
11111111111151515
11111111111151515
11111111111151515
11111111111151515
11111111111151515
66666666666666666
66666666666666666
66666666666666666
6666666... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 22 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000822228000080000
0000822228000080000
0000822228000080000
0000822228000080000
8888888888888888888
2222811118000080000
2222811118000080000
2222811118000080000
2222811118000080000
8888888888888888888
0000800008111180000
0000800008111180000
0000800008111180000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 23 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
4442444
4442414
4442444
2222222
4442444
4442444
4442444
Output:
444
414
444
Train Example 2:
Input:
88388
88388
33333
88388
48388
Output:
88
48
Train Example 3:
Input:
33333133333
33333133333
38333133333
33333133333
33333133333
11111111111
33333133333
3... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 24 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
303080000
330080000
300080000
000080000
888888888
000080000
000080000
000080000
000080000
Output:
80800808
88000088
80000008
00000000
00000000
80000008
88000088
80800808
Train Example 2:
Input:
00000200000
01000200000
11000200000
01100200000
00000200000
22... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 25 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
1111111111
1111211111
1111211111
1188888811
1111111111
1212111111
1111111111
1111111111
1111111111
1111111111
Output:
1111111111
1111211111
1222211111
1288888811
1211111111
1222111111
1111111111
1111111111
1111111111
1111111111
Train Example 2:
Input:
1111... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 26 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
6666
6961
4662
6656
Output:
6666
6666
6622
6622
Train Example 2:
Input:
5606
6666
6266
6664
Output:
6666
6666
2266
2266
Train Example 3:
Input:
6900
9616
6661
8662
Output:
6666
6666
6622
6622
Test Input:
2681
6666
4699
0566
| responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 27 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
7777577777577777
7777757777757777
7777775777775777
7777777577777577
7777777757777757
7777777775777775
7777777777577777
7777777757757777
7777777577775777
7777775777777577
7777757777777777
7777577777777777
7775777777777777
7757777777777777
7577777777777777
5777... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 28 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
9657777
8717777
0897777
7777777
7771847
7774767
7776247
Output:
5897777
8767777
9107777
7777777
7774447
7772787
7771667
Train Example 2:
Input:
7777777
7777777
7752877
7717977
7743077
7777777
7777777
Output:
7777777
7777777
7781077
7737277
7759477
7777777... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 29 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
02020
22022
02220
02200
02222
20202
44444
20222
02200
20202
20002
22020
20220
Output:
33303
30333
33033
33303
30303
00033
Train Example 2:
Input:
02222
00002
20222
00220
22220
22002
44444
00000
00200
20002
00020
02020
02220
Output:
03333
00303
00330
00300... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 30 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00000000000
00000000800
00000000000
00000000000
00000000000
02000000000
00000000000
00000000000
Output:
00000000000
00000000800
00000000400
00000000400
00000000400
02444444400
00000000000
00000000000
Train Example 2:
Input:
000000000000
000000000000
080000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 31 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
351
458
249
Output:
381
485
249
Train Example 2:
Input:
27888
55654
85552
88436
65193
Output:
27555
88684
58882
55436
68193
Train Example 3:
Input:
653
575
882
Output:
683
878
552
Test Input:
8845
3875
3719
6488
| responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 32 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
7777777777777777
7777777777777777
7777777777777777
7777777777777777
7777766766777777
7777677677677777
7777766266777777
7777677677677777
7777766266777777
7777677677677777
7777777777777777
7777777777777777
7777777777777777
7777777777777777
7777777777777777
7777... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 33 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
33330303033003330300
00330030330303300330
33333003000303303333
30330000303303330330
00030303330333033300
33003303333003033330
03000033030030003030
30300000033303333333
03300003033033003333
00033003333303030333
30330333003030003303
30030003333003030333
0330003... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 34 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000000000
0101010100
0000000000
0000000000
0010100000
0000000000
0000001010
0000000000
0001010000
0000000000
Output:
0000000000
0121212100
0000000000
0000000000
0012100000
0000000000
0000001210
0000000000
0001210000
0000000000
Train Example 2:
Input:
1010... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 35 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000005555
0666605555
0886805555
0688800000
0000000000
0000555500
0000555500
0000555500
0000000000
0000000000
Output:
0000006666
0666608868
0886806888
0688800000
0000000000
0000666600
0000886800
0000688800
0000000000
0000000000
Train Example 2:
Input:
0000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 36 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000000000
0000000000
1000010000
0100100000
0011000000
0011000000
0000400004
0000040040
0000004400
0000004400
Output:
0000000000
0000000000
1111110000
0111100000
0011000000
0011000000
0000444444
0000044440
0000004400
0000004400
Train Example 2:
Input:
0000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 37 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
000000000000000
000000000000000
022222222222220
022222222222220
022777722222220
022777722222220
022777722222220
022222222222220
022222222222220
022222333333320
000000333333300
000000333333300
000000333333300
Output:
7777
7777
7777
Train Example 2:
Input:
0... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 38 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000006005
0000006005
0000006005
0000006000
6666666666
0000006000
0000006000
0000006000
0000006000
0000006000
Output:
0006000000
0006000000
0006000000
0006000000
0006000000
0006000000
0006000000
6666666666
0006000000
0006000000
Train Example 2:
Input:
0004... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 39 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
7071550
7701555
0701000
0001505
Output:
000
000
303
030
Train Example 2:
Input:
7701500
0001000
7701500
0771550
Output:
003
333
003
000
Train Example 3:
Input:
0771500
0071055
0701550
0071000
Output:
000
300
003
330
Train Example 4:
Input:
7001050
00... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 40 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
000000000
020000000
020000020
020200020
020200020
020202020
020202020
020202020
Output:
000000000
020000000
020000020
020200020
020200020
080202080
080802080
080808080
Train Example 2:
Input:
000000000
020000000
020200000
020202000
020202020
020202020
0202... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 41 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
11118111111
11118111111
11118111111
88888888888
11118111111
11118111111
11118111111
11118111111
11118111111
88888888888
11118111111
Output:
11
11
11
Train Example 2:
Input:
373333333373373
373333333373373
777777777777777
373333333373373
373333333373373
373... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 42 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
000000000000000
000000000000000
000000000000000
000011100010000
000010100010000
000011100000000
000000000000000
000000000000000
000010000101100
000000000100100
000000000111100
000000000000000
000000000000000
000000000000000
000000000000000
Output:
0000000000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 43 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
4444444444444444
4114444444444664
4114444444444664
4114444444444664
4444444444444444
Output:
4441111166666444
4111111166666664
4111111166666664
4111111166666664
4441111166666444
Train Example 2:
Input:
22222222222222222
21122222222222332
21122222222222332
... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 44 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00050205200
20050005002
00050005000
55555555555
20050005000
20050025000
00050005020
55555555555
00050005000
20050025002
00050005000
Output:
00050005222
00050005222
00050005222
55555555555
22250005000
22250005000
22250005000
55555555555
00050005000
0005000500... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 45 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00000000000
03333300000
03222300008
03222300000
03333300000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
Output:
00000000000
03333333333
03222222223
03222222223
03333333333
00000000000
00000000000
00000000000
00000000000
0000000000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 46 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
000000
080000
000000
000000
000500
000000
Output:
000000
088888
000008
000008
000555
000005
Train Example 2:
Input:
000
060
000
Output:
000
066
006
Train Example 3:
Input:
00000
00800
00000
07000
00000
00600
00000
Output:
00000
00888
00008
07777
00007
... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 47 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00200020002000200
02020202020202020
02020202020202020
20002000200020002
Output:
00200020002000200
02020202020202020
02020202020202020
20002000200020002
02020202020202020
02020202020202020
00200020002000200
02020202020202020
02020202020202020
2000200020002000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 48 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
000009
000800
000000
400000
407800
407000
Output:
000000
000000
000000
400000
407800
407809
Train Example 2:
Input:
0409
0000
0460
1000
Output:
0000
0000
0400
1469
Train Example 3:
Input:
00010
03000
03012
60000
03000
Output:
00000
00000
03000
03010
63... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 49 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
42446455
24446445
42446455
24464445
42464455
24464445
42464455
24446445
42446455
24446445
Output:
62456455
26456425
62456455
26465425
62465455
26465425
62465455
26456425
62456455
26456425
Train Example 2:
Input:
00000009
40003090
04000009
00403009
04000090... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 50 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
000808000
000888000
000880000
000004000
000444000
000040000
Output:
000808808
000888888
000880088
000004000
000444000
000040000
Train Example 2:
Input:
000808000
000088000
000008000
000400000
000444000
000040000
Output:
808808000
880088000
800008000
00040... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 51 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
11460
11460
44460
66660
00000
Output:
1146114611
1146114611
4446114611
6666114611
1111114611
1111114611
4444444611
6666666611
1111111111
1111111111
Train Example 2:
Input:
22230
22230
22230
33330
00000
Output:
2223222322
2223222322
2223222322
3333222322
2... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 52 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
9999919999999
9999999919999
9919999111199
9111199919999
9199199919999
9111199911199
9999199999999
9999199999999
9199999111999
1119999991999
9199991911999
1199991119999
Output:
9999919999999
9999999919999
9989999111199
9888899919999
9899899919999
988889991119... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 53 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000000000
0000008888
0888800088
0008800088
0008880000
0000000000
0008888000
0000088000
0000088800
0000000000
Output:
0000000000
0000002222
0111100022
0001100022
0001110000
0000000000
0001111000
0000011000
0000011100
0000000000
Train Example 2:
Input:
0000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 54 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
88888888
80000008
80555508
80588508
80588508
80555508
80000008
88888888
Output:
55555555
58888885
58000085
58055085
58055085
58000085
58888885
55555555
Train Example 2:
Input:
000000
077770
076670
076670
077770
000000
Output:
666666
600006
607706
607706
6... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 55 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
63636361
36363631
63636361
36363631
63636361
36363631
63636361
11111111
Output:
36363636
63636363
36363636
63636363
36363636
63636363
36363636
63636363
Train Example 2:
Input:
67676763333
76767673333
67676763333
76767673333
67676763333
76767673333
67676763... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 56 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000000000
0000000000
0000000000
0002222000
0002772000
0002772000
0002222000
0000000000
0000000000
0000000000
Output:
0000000000
0002222000
0002222000
0227777220
0227227220
0227227220
0227777220
0002222000
0002222000
0000000000
Train Example 2:
Input:
0000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 57 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00000000000
00000000000
00001110000
00001310000
00001110000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
Output:
333
313
333
Train Example 2:
Input:
0000000000000
0002222000000
0002442000000
0002442000000
000222200000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 58 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
5555555555
5555555555
5555555155
5555555555
5555555555
5555555555
5555555555
5555555655
5555555555
5555555555
Output:
5555555555
5555555555
5555555155
5555555555
5555555555
5555555555
5555555655
5555555555
5555555555
5555555555
Train Example 2:
Input:
655
... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 59 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
552
100
000
Output:
000
001
255
Train Example 2:
Input:
338
370
500
Output:
005
073
833
Test Input:
635
680
400
| responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 60 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
000000000000
002000000000
000000000000
000000000000
030000000000
000000600000
000000000000
000000000000
000000000000
000000000000
Output:
000000000000
002525252525
000000000000
000000000000
035353535353
000000656565
000000000000
000000000000
000000000000
000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 61 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00000000000
00000000000
00000000000
30000000007
00000000000
Output:
00000000000
00000000000
00000000000
33333577777
00000000000
Train Example 2:
Input:
00000000000
10000000002
00000000000
00000000000
00000000000
Output:
00000000000
11111522222
00000000000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 62 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00000001010000
00400001110000
00044000100000
00400000000400
00000000000044
00000020200400
01010002000000
01110020200000
00100000040000
00000000004400
00400000040000
00044000000101
00400000000111
00000000000010
Output:
400
044
400
Train Example 2:
Input:
00... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 63 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
88888288848888888888
88888888888888888888
88888888888888888888
88888888888888888888
88888888888888888888
88888888888888888888
88222222222888888888
88222222222888888888
88222222222888888888
88222222222888888888
88222222222888888888
88222222222888888888
8888888... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 64 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
22222222222222222
22222222222222222
22228882222222222
22228222222222222
22228882222222222
22222282222222222
22228882222222222
22222222222222222
22222222222222222
22222222222222222
22222222323232222
22222222333332222
22222222223222222
11112222222222222
1111222... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 65 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
7777777777
7777777797
7222777797
7777777797
7777577797
7777777777
7777777777
7777777777
7777777777
7777777777
Output:
7777777777
7777777777
7777777777
7777777777
7777777777
7222577797
7777777797
7777777797
7777777797
7777777777
Train Example 2:
Input:
7777... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 66 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
833383877877778778383338
383838787888888787838383
333333777877778777333333
383833888787787888338383
833388787887788787883338
383383787778877787383383
877877000000000000778778
787888008000000800888787
777877088080080880778777
888787000000000000787888
787887008... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 67 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
855666
508666
825666
585528
502805
858558
Output:
858
205
585
Train Example 2:
Input:
3072139570466666666666
7572248920866666666666
4422112091566666666666
0848098485066666666666
8238424937066666666666
2821115577166666666666
3820204849766666666666
338073073... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 68 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
000000812
000000841
888888888
003303800
330000800
330303800
000030800
333333800
000030800
Output:
001202
110000
110202
000010
444111
000010
Train Example 2:
Input:
248000000
168000000
888888888
008030030
008333333
008030030
008030030
008333333
008030030
O... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 69 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00200000000000000000000
00000200001110001110020
00000200001110001110000
02000000001110001110000
02200000000001110000200
00000000202021110020000
02000000020201110000000
00000000001110000000000
00000002001110000000002
00000020001110022000000
2000000000002000000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 70 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000000000000000000
0888880888880888880
0888880888880888880
0888880888880899980
0888880888880888880
0888880888880888880
0000000000000000000
0222220222220222220
0222220222220222220
0222220222220222220
0222220222220222220
0222220222220222220
0000000000000000000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 71 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
9000000000900766
0900000009000733
0090000090000766
0009000900000733
0000909009090700
0000090000900722
0000909009090722
0009000900000766
0090000090000700
0900000009000788
9000000000900733
Output:
6000000000500766
0300000005000733
0060000050000766
000300050000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 72 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000000000000000000
0000000000000000030
0000000000000000000
0000000000000104000
0000000000000000000
0000000000000001000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000
0000000000000000000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 73 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
2222222222222222222
2222222222222222222
2221122222222222222
2221422222222822222
2222212222228222222
2222222222222222222
2222222222222222222
2222222222222222222
2222222222222222222
2222222222222222222
2222222222222242222
2222222222222222222
2222223282222222222... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 74 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
7777877777777777
7777877777777777
9999199999999999
7777877777777777
7777877777777777
7777877777777777
7777877777777777
7777877777777777
7777877777777777
7777877777777777
6666166666666666
7777877777777777
7777877777777777
7777877777777777
3333133333333333
7777... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 75 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
7747670777
7513777791
7237277777
7897870728
5971756878
7270777176
7777777774
7787740775
6777127704
7777721767
Output:
7778887777
7777777777
7777777777
7777777777
7788888887
7777778888
7777777777
7777777777
8888877777
7777778887
Train Example 2:
Input:
7777... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 76 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000000000000000000000000000
0333000000000000000000000000
0999000000000000000000000000
0888000000000000000000000000
0000000000000000000000000000
0000000000000000000000000000
0000000000000000000000000000
0000000000000000000000000000
000000000000000000000000000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 77 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
4488885
4488858
6665444
6364474
6664444
4444447
Output:
444444888888888888444
444444888888888888444
444444888888888888444
444444888888888444888
444444888888888444888
444444888888888444888
666666666444444444444
666666666444444444444
666666666444444444444
6663... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 78 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
401111
901441
801441
601111
000000
000000
001111
001991
001991
001111
000000
000000
001111
001881
001881
001111
000000
000000
001111
001661
001661
001111
Output:
400001111
900001441
700001441
600001111
000000440
000000440
000001111
000001991
000001991
000001... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 79 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
817
050
032
Output:
0000000000
0000000000
0000000000
0000000000
0000000000
8817788177
8817788177
0050000500
0032200322
0032200322
Train Example 2:
Input:
487
170
018
Output:
0000000000
0000000000
0000000000
0000000000
0000000000
4487744877
4487744877
1170... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 80 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
7777777777
7666667777
7677767777
7677767777
7677767777
7666667777
7777777777
7557777777
7557777777
7777777777
Output:
7777777777
7666667777
7655567777
7655567777
7655567777
7666667777
7777777777
7777777777
7777777777
7777777777
Train Example 2:
Input:
7777... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 81 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
8727872787
8727877787
8727872787
8777877787
8777877787
8888888888
Output:
8777877787
8727877787
8727872787
8727872787
8777877787
8888888888
Train Example 2:
Input:
766776667
776777677
776777777
277727772
Output:
766777777
776776667
776777677
277727772
Tr... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 82 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00000000000000800
00000000000008000
00000070080040000
00000000000040040
00000000040040040
00000000040040040
00000000000040040
00000000000000040
00000000000000000
00000000000000000
00008000000000000
00000008000000000
00004400000004440
Output:
5555855958555985... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 83 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
444444444444444444444444
422222444444444444444444
425552444444444444444444
422222444444111111444444
422222444444155551444444
422222444444111111444444
422222444444111111444444
422222444444155551444444
422222444444111111444444
422222444444444444444444
422222444... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 84 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
2420
5870
2620
0001
Output:
22422
22422
55117
22112
22622
Train Example 2:
Input:
3630
2490
3530
0008
Output:
33633
33633
22889
33883
33533
Train Example 3:
Input:
2720
8530
2420
0006
Output:
22722
22722
88663
22662
22422
Train Example 4:
Input:
8280... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 85 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
014
269
013
Output:
00144
00144
22699
00133
00133
Train Example 2:
Input:
969
917
806
Output:
99699
99699
99177
88066
88066
Train Example 3:
Input:
045
317
252
Output:
00455
00455
33177
22522
22522
Train Example 4:
Input:
146
729
030
Output:
11466
1... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 86 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
000000000000000000000000000000
000000000000000000000000000000
000000000000000000000000000000
000000000000000000000000000000
000000000000000000000000000000
000000000006660000000000007320
000000000006660000000000000000
000000000006660000000000000000
00000000000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 87 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0000000000000000000000000
0000000000000000000000000
0000000000000000000000000
0000000000000000000000000
0000000000000000000000002
0000000000000000000000000
6000000000000000000000000
0000000088000000000333000
0000000088880007770303000
0000000088888007070333000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 88 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
00000000000000000000000
00000000000000000000000
00000999990000000040006
00000999990000000000000
00050999990000000000000
00000999990000000000000
00000999990000000000000
00000999990300099999990
00000000002000099999990
00000000000000099999990
0000000099990009090... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 89 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
0220000000
0202000000
0022000000
0000330000
0000330000
0000000000
0000000000
0000000000
0000000000
0000000000
Output:
0220000220
0202002020
0022002200
0000330000
0000330000
0022002200
0202002020
0220000220
0000000000
0000000000
Train Example 2:
Input:
0000... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
nvidia/Nemotron-RL-ARC-AGI-v1 | transductive | train | 90 | Please solve this ARC-AGI problem:
Train Example 1:
Input:
200
200
230
Output:
200000000
200000000
203000000
200000000
200000000
203000000
200000000
200000000
203000000
Train Example 2:
Input:
444
010
000
Output:
444444444
000000000
010010010
000000000
000000000
000000000
000000000
000000000
000000000
Train Exam... | responses_input | first_user_message | Find the common rule that maps an input grid to an output grid, given the examples below.
After reasoning you must provide only the output and nothing else.
Output format: \boxed{solution} where solution is an array of rows separated by newlines, values by spaces.
| responses_create_params.input | null | null | null | null |
End of preview. Expand in Data Studio
Nemotron-RL-ARC-AGI-v1-prompt-only
Prompt-only extraction from nvidia/Nemotron-RL-ARC-AGI-v1.
Files:
prompts.csv: one prompt extraction record per source row. Records includeprompt, separatedsystem_prompt, and structuredtoolswhen the source row defines available tools. Nested values are JSON-encoded inside CSV cells.summary.md: source row counts, extracted row counts, count deltas, and failed prompt counts.null_or_empty_rows.md: row indexes where prompt extraction produced a null or empty prompt.
Summary:
- extracted rows: 21028
- failed prompt rows: 0
- row count delta: 0
Uploaded under jamesdborin from the Nemotron Post-Training v3 prompt extractor workflow.
- Downloads last month
- 88