\n<|im_start|>assistant\n"},"abstraction_prompt_length":{"kind":"number","value":1586,"string":"1,586"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>Look for a small, contiguous block of non-background pixels that appears in the same place in every input. When that block is a compact square (two-by-two), it is a strong candidate for the transformation's source.</description>\n<example>Imagine a grid where a 2×2 colored square sits in the top-left and the rest of the grid is background. If the output changes only inside that small square while other areas remain identical, the 2×2 square is likely the object to focus on.</example>\n</note1>\n\n<note2>\n<description>Compare the output to the input to find which cells were modified and which remain the same. The unchanged rows/columns usually indicate the background (zero) and the rows/columns that changed point to the area of interest.</description>\n<example>For instance, if the top-left two rows and two columns are altered in the output but the rest of the grid is identical, those altered rows/columns are the ones to investigate further.</example>\n</note2>\n\n<note3>\n<description>Think in terms of diagonals: a 2×2 square has two diagonals (top-left→bottom-right and top-right→bottom-left). Ask whether the transformation targets one diagonal or both — that distinction often determines the pattern of new pixels.</description>\n<example>With a 2×2 block occupying rows 1–2 and columns 1–2, the two main diagonals run (1,1)–(2,2) and (1,2)–(2,1). If the output shows a single colored pixel per diagonal, the rule is about marking diagonals rather than copying or rotating the whole block.</example>\n</note3>\n\n<note4>\n<description>Consider that the diagonal pixels are a new color distinct from the original block and the surrounding background. The added pixels should not overwrite other non-background values already present in the grid.</description>\n<example>If the original 2×2 square uses color A and the grid background is B, the output may introduce color C on the diagonals; check that existing non-background cells are preserved and not replaced.</example>\n</note4>\n\n<note5>\n<description>Verify the rule is local and consistent: it should apply only to that specific 2×2 square and only on its diagonals, not on other colored shapes or elsewhere in the grid. Use that consistency to decide what to do in the test case.</description>\n<example>If you find another colored cluster elsewhere that is not a 2×2 square, do not expect the same diagonal marking there. The transformation is targeted and repeatable only when the exact 2×2 square condition is met.</example>\n</note5>","<note1>\n<description>Check which two rows are preserved exactly and which row is transformed. When one full row (the top) and the bottom row are identical across examples, the middle row is the only one that changes — focus your attention on that middle row.</description>\n<example>Imagine a 7×7 grid where the top and bottom rows are identical and the center row is different. In the output you should see the top and bottom rows unchanged, while the center row is altered in a regular way; this narrows the problem to finding the rule that modifies the middle row.</example>\n</note1>\n\n<note2>\n<description>Look for a vertical offset between a middle-row pixel and the corresponding bottom-row pixel: the distance is constant across the middle row. If the bottom-row pixel is always one row below the middle-row pixel (and the middle row is two rows from the bottom), the vertical offset is +1.</description>\n<example>For instance, if the middle-row pixel at column j is aligned with the bottom-row pixel at column j, then every column in the middle row has the same vertical offset of +1 to reach its counterpart on the bottom row. That constant offset tells you to use a one-row vertical shift when comparing cells.</example>\n</note2>\n\n<note3>\n<description>Compare values in the same column: the middle-row cell and the bottom-row cell in that column are often the same color. If they match, the transformation is not a recoloring but a placement of a new marker relative to that matching pair.</description>\n<example>Suppose column j of the middle row and column j of the bottom row both show color X. The rule does not change X to a different color; instead it introduces a new marker at the middle cell relative to that matching pair. So first confirm equality before deciding to place a marker.</example>\n</note3>\n\n<note4>\n<description>When the middle and bottom cells match, insert a new marker (a distinct color) into the middle cell; when they differ, leave the middle cell unchanged. In other words, the marker is placed only when the two cells are identical.</description>\n<example>For example, if the middle cell is X and the bottom cell is X, paint the middle cell with the marker color. If the bottom cell is Y (different from X), keep the middle cell as it was. This conditional placement explains why some middle cells become the marker and others remain as they were.</example>\n</note4>\n\n<note5>\n<description>Use a consistent marker color that does not appear in the input and apply it to every matching column. Do not alter the top or bottom rows and do not overwrite any existing non-background values in the middle row.</description>\n<example>Choose a marker color not present in the grid and place it into the middle row only at columns where the middle-row and bottom-row cells match. Leave other middle-row cells unchanged and keep the top and bottom rows exactly as they are.</example>\n</note5>","<note1>\n<description>Look for a compact block of identical non-background pixels that appears in the same place in every input. That repeated block is often the anchor for the transformation and should be treated as a single object rather than many separate pixels.</description>\n<example>Imagine a grid where the top-left contains a 2×2 block of the same color while the rest of the top row and bottom row are different. Treat that 2×2 as one object; its location and color will be relevant for what follows.</example>\n</note1>\n\n<note2>\n<description>Compare the top row and the bottom row as sequences. The transformation often uses one of these rows as a “source” of values to be placed elsewhere, so record the sequence order exactly (left-to-right or right-to-left).</description>\n<example>If the top row reads [A B C D] and the bottom row reads [E F G H], check whether the examples use the top row’s left-to-right order or the bottom row’s left-to-right order as the sequence to be copied into the interior.</example>\n</note2>\n\n<note3>\n<description>Decide whether the sequence is copied left-to-right or right-to-left. The direction is consistent across examples and can be determined by comparing the first and last elements of the source row with the corresponding interior cells.</description>\n<example>Take a short sequence [X Y Z]. If the interior cells become [Z Y X], the copy is reversed; if they become [X Y Z], the copy is in the original order. Test both directions on the training pairs to pick the correct one.</example>\n</note3>\n\n<note4>\n<description>When copying the sequence, place each source value into the same row but into the interior columns that are currently background (zeros). Do not overwrite existing non-background pixels; only fill empty cells.</description>\n<example>Given an interior row [0 0 0 0], copying [A B C] left-to-right yields [A B C 0]; copying [C B A] right-to-left yields [0 0 0 C B A]. Always leave any non-zero cells already present unchanged.</example>\n</note4>\n\n<note5>\n<description>Use a single, distinct marker color (the same color in every example) for any newly introduced interior pixels and verify that the marker is not used elsewhere in the grid. This ensures the added pattern is unambiguous and consistent.</description>\n<example>If the training outputs introduce a new color M in the interior positions, adopt M for all new placements. Also check that no other non-background pixels were replaced—only background cells should be filled with the marker.</example>\n</note5>","<note1>\n<description>Look for a compact colored object in the top-left that acts as a template: it may be a single small block, a repeated pattern, or a set of adjacent pixels that repeat across rows. This template is the source of the repeated pattern you should reproduce elsewhere.</description>\n<example>Imagine a 2×2 colored square at the top-left and a separate colored pixel at the top-right; the 2×2 square is the template because it is a small, contiguous motif, while the single pixel is just a lone color. Mark that contiguous block as the template to compare with other areas.</example>\n</note1>\n\n<note2>\n<description>Search the bottom-right corner for a small horizontal sequence of distinct colors (often a single column of different colors). Treat this sequence as the target that will be copied into the empty area, preserving the order and spacing of its colors.</description>\n<example>If the bottom-right contains a column like [A,B,C,D] (one color per row), regard that column as a sequence to be reproduced elsewhere. The important thing is the order A→B→C→D, not which specific letters they are.</example>\n</note2>\n\n<note3>\n<description>Decide which rows to copy by matching the template's height to the target's length: the template's number of rows (or its repeated-unit height) determines how many consecutive rows you will copy from the bottom-right. Align the template's rows with the bottom-right rows so the copy fits the available empty rows.</description>\n<example>If the template is two rows tall and the bottom-right has four distinct colors, copy two rows from the bottom-right into the empty area; if the template is three rows tall and the bottom-right has five colors, copy three rows. Use the template's height as the size parameter for the copy.</example>\n</note3>\n\n<note4>\n<description>Place the copied sequence into the empty area so the template's columns line up with the copied columns (use the template's column indices as the target column positions). Fill the empty cells in that area with a single consistent filler color so the pattern is clear and aligned.</description>\n<example>With a 2×2 template occupying columns 0–1, copy the chosen bottom-right column sequence into columns 0–1 of the empty area and fill other cells with the same filler color. This keeps the template's layout visible while adding the new pattern.</example>\n</note4>\n\n<note5>\n<description>Preserve the original non-empty rows and do not alter the template or the bottom-right source. If the number of available empty rows is less than the template's height, copy the required number of rows from the bottom-right (the topmost rows of that sequence) rather than truncating the template.</description>\n<example>If the template is 3 rows tall but only 2 rows are available for copying, take the top two rows of the bottom-right sequence and place them into the empty area; do not remove or change the original template or the bottom-right column. This keeps the transformation consistent and unambiguous.</example>\n</note5>","<note1>\n<description>Look for a single small, unchanged object in the input that acts like an anchor. Often this is a 2×2 block of identical non-background color that remains in the same place between input and output; its presence usually indicates the transformation uses that block as a reference.</description>\n<example>Imagine a 7×7 grid where a 2×2 red square sits at the top-left and everything else is background or single pixels. In the output that 2×2 red square is still there and in the same color, so treat that 2×2 as the anchor when you try to explain the rest of the change.</example>\n</note1>\n\n<note2>\n<description>Check whether the background cells around the anchor are being filled by new pixels. If the newly introduced pixels always form a straight diagonal (one cell down-and-right per step), the rule is likely “fill background cells along that diagonal with a marker.”</description>\n<example>For example, if the anchor is at (0,0), you might observe a new color appearing at (1,1), (2,2), etc. Those are not random fills — they follow a consistent down-right diagonal path.</example>\n</note2>\n\n<note3>\n<description>Decide how far that diagonal is drawn: it usually stops when it reaches the opposite edge of the grid or when it would step outside the grid. The rule is to continue until you cannot step further, not to wrap around.</description>\n<example>If the diagonal would step beyond the bottom row, stop at the last valid cell (the bottom row). If the diagonal would step beyond the rightmost column, stop at the last valid column; the diagonal simply ends at the grid boundary.</example>\n</note3>\n\n<note4>\n<description>When the diagonal passes through a non-background cell, the transformation typically treats those cells as “already filled” and does not overwrite them with the marker. So the final diagonal shows only background cells turned into the marker, skipping any occupied cells.</description>\n<example>Suppose the diagonal would land on a cell that already contains a different colored pixel; that cell remains its original color and the marker is not placed there. The visible diagonal is therefore a set of background cells turned into the marker, with any original colored cells left unchanged.</example>\n</note4>\n\n<note5>\n<description>Use the anchor's color to determine the marker used for the diagonal, and always preserve all other non-background pixels (including any color already on the diagonal). This keeps the anchor visible and prevents accidental overwriting of other meaningful objects.</description>\n<example>If the anchor is blue, the diagonal will use blue as the marker color; other colored pixels elsewhere remain as they were. After filling the diagonal, verify that the anchor is still intact and that no other colored cells were changed.</example>\n</note5>","<note1>\n<description>Check the two outermost rows and columns for a repeated small motif. When the same short pattern appears at the grid edges, that motif is often the source of the transformation rather than isolated pixels.</description>\n<example>Imagine a 7×7 grid whose top row and left column both start with [A A ...]. Treat [A A] as the motif and record its coordinates (top-left and top-right of the motif) so you can compare those positions across rows.</example>\n</note1>\n<note2>\n<description>Compare motif positions down the rows: if the motif’s top-right coordinate stays the same while its top-left moves one column per row, that indicates a diagonal (down‑right) propagation. Tracking that shift reveals the direction and spacing of the added pattern.</description>\n<example>For instance, if the motif’s top-right is always column 6 across rows but its top-left moves from column 1 to 2 to 3 as you go down rows, then the motif is being shifted down-right by one column per row.</example>\n</note2>\n<note3>\n<description>Look for a single marker color used only to show where the motif was placed; this marker is typically distinct from the motif and the rest of the grid. The marker appears exactly where the motif would have been placed in each row.</description>\n<example>Suppose the motif is color A and the output introduces a new color X only at the motif positions. X marks the motif’s landing spots while A remains unchanged elsewhere.</example>\n</note3>\n<note4>\n<description>Decide which rows receive the marker by checking whether the motif appears in the input for that row (it may be present only on some rows). Only those rows are candidates for adding the marker at the motif’s projected positions.</description>\n<example>If the motif is visible on rows 1–3 but not on row 4, then only rows 1–3 should receive the marker at their projected motif coordinates; row 4 stays as it is.</example>\n</note4>\n<note5>\n<description>When projecting the motif down the diagonal, clip the projection at the grid boundary and do not overwrite existing non-background pixels. Use the motif’s top-right anchor as the reference for placement and stop when you reach the grid edge.</description>\n<example>If the motif’s top-right is at column 6, place markers at columns 6, 5, 4, … as you move down the diagonal but do not write into columns outside the grid; if a target cell already contains a non-background color, leave it unchanged.</example>\n</note5>","<note1>\n<description>Look for a single-color rectangular block that appears in the same place in every input and remains unchanged in the outputs; this block is the anchor for the transformation. Treat that block as fixed and ignore it when reasoning about new markings.</description>\n<example>Imagine a grid where the top-left 2×2 is all the same color and every example keeps that 2×2 identical. You should first mark that 2×2 as the anchor and do not alter those cells when you try to explain the differences between input and output.</example>\n</note1>\n<note2>\n<description>After removing the anchor, check whether the remaining colored pixels form a repeated motif (for example, a 1×1 colored pixel) that appears in the same column order across the rows below the anchor. The motif is the element being copied or extended.</description>\n<example>For instance, if the area below the anchor contains a sequence like [A, B, C] down the columns, and the output shows that same sequence repeated in other rows, then the motif is that column-wise sequence and it is the thing to propagate.</example>\n</note2>\n<note3>\n<description>Decide the propagation rule: the examples consistently place a new marker in the column immediately to the right of each motif instance, one row at a time (i.e., a down‑right diagonal). Think of it as advancing one column and one row per repetition rather than copying the motif into multiple columns at once.</description>\n<example>With a motif [A, B, C] in columns 4–6, the rule would place a marker in column 4, then column 5, then column 6, each time one row lower (a down‑right diagonal), rather than putting markers in columns 4, 5 and 6 for every row.</example>\n</note3>\n<note4>\n<description>Only mark cells that are currently background (zeros) so the new markers do not overwrite existing colored pixels. This preserves original colored pixels and prevents accidental overwriting.</description>\n<example>If a target cell is already a non-zero color, leave it unchanged; only convert empty (zero) cells along the diagonal into the marker color, while keeping the original colored pixels intact.</example>\n</note4>\n<note5>\n<description>Apply the diagonal propagation only within the rows below the anchor and stop when you reach the bottom edge or the next row that already contains a non-zero in that diagonal position. This keeps the operation bounded and consistent with the examples.</description>\n<example>Start the diagonal at the row immediately beneath the anchor and step one row down per marker; if the next row already has a colored pixel in the intended diagonal position, do not overwrite it and stop there rather than continuing the diagonal further.</example>\n</note5>","<note1>\n<description>Look for a small, contiguous block that is repeated in a regular way across the grid (often a 2×2 square). If that block appears in the same relative positions in every row, treat it as a single object whose internal pattern you should preserve.</description>\n<example>Imagine a grid where rows 1–2 contain the same two-column block of two non-background colors. Treat that 2×2 block as one object and do not split its two colors into separate cells when reasoning about the transformation.</example>\n</note1>\n\n<note2>\n<description>Compare the leftmost column of the top block with the rightmost column of the bottom block. The examples align those two columns so the leftmost column of the top block sits directly above the rightmost column of the bottom block.</description>\n<example>If the top block’s left column has colors [A,B] and the bottom block’s right column has colors [X,Y], place A above X and B above Y. This alignment is what the examples use to pair the two blocks.</example>\n</note2>\n\n<note3>\n<description>For each aligned pair of cells, check whether the two colors are the same. When they match, the output marks that cell with a distinct marker color (a single, consistent marker across the grid); when they differ, leave the cell as background.</description>\n<example>With aligned pairs (A,X) and (B,Y), if A == X and B == Y then the corresponding positions receive the marker color; if A != X or B != Y, those positions remain background.</example>\n</note3>\n\n<note4>\n<description>Apply the same marker independently to every aligned position in every row. The marker only highlights matches; it does not alter the original colors of the top or bottom blocks.</description>\n<example>Across multiple rows, if the top-left column and bottom-right column each contain matching pairs in several rows, place the marker at each matching cell; mismatches in any row remain background.</example>\n</note4>\n\n<note5>\n<description>Use simple checks to confirm you found the correct blocks and alignment: the top block should be contiguous and repeated in the same place for several rows, and the bottom block should be a second contiguous block in the same relative column positions. If those conditions are met, the pairwise test above will reproduce the example outputs.</description>\n<example>If you find two identical 2×2 blocks in the same columns across rows, align their leftmost/top and rightmost/bottom columns and perform the per-pair equality test; if the resulting marked cells match the examples’ pattern, your interpretation is correct.</example>\n</note5>","<note1>\n<description>Look for a repeated, small object: a compact block of identical non-background pixels that appears in the same relative location across examples. This repeated block is usually the anchor for the transformation because its exact placement is preserved.</description>\n<example>Imagine a grid where a 2×2 square of blue pixels sits in the same top-left corner in every example. That square is a strong candidate to be the anchor: the rest of the changes are likely relative to this fixed block.</example>\n</note1>\n\n<note2>\n<description>Compare the bottom-right corner of the grid to the top-left corner: many ARC tasks place a small pattern there that is reused elsewhere. Check whether the bottom-right color appears multiple times (especially at the same column indices) and whether those positions are aligned with the anchor.</description>\n<example>For instance, if the bottom-right corner shows three different colors in a horizontal sequence and you find that same sequence (in the same order) appears somewhere else in the grid, treat that sequence as a candidate motif to be relocated.</example>\n</note2>\n\n<note3>\n<description>Decide whether the motif is being copied or mirrored: the motif’s internal order may be preserved, reversed, or rotated. Determine orientation by checking which cells of the motif correspond to which cells of the anchor in the output.</description>\n<example>If the motif’s left-to-right order is reversed when it appears at the anchor’s location, that indicates a horizontal mirror; if the motif’s top-to-bottom order is reversed, that indicates a vertical mirror. Try both possibilities and see which matches all examples.</example>\n</note3>\n\n<note4>\n<description>Apply the transformation by translating the motif so its center (or a chosen reference pixel) aligns with the anchor’s center, then place the motif at that translated location. The motif’s orientation (original, flipped, rotated) should be consistent with the earlier comparison.</description>\n<example>If the motif is 3×3 and the anchor is 2×2, align the motif’s center with the anchor’s center and place it so the motif occupies the same relative area. If the motif must be mirrored, flip it horizontally or vertically before placing.</example>\n</note4>\n\n<note5>\n<description>Use invariants to validate your hypothesis: the anchor itself should remain identical, background cells should stay background, and non-background colors outside the motif should be preserved. Only replace background cells with the motif’s colors when placing it.</description>\n<example>After placing the motif, scan the grid: the original anchor block must be unchanged, the motif’s colors should occupy only background positions, and every other colored pixel must match the input. If any invariant fails, reconsider orientation or alignment.</example>\n</note5>","<note1>\n<description>Look for a small, contiguous block of identical non-background pixels that appears in the same corner in every input. That block is the anchor: its color and its exact pixel positions determine where any further change will be placed.</description>\n<example>Imagine a grid where the top-left 2×2 area is entirely color A. Treat that 2×2 as the anchor; any rule that depends on that block will use A as the marker color and the two adjacent columns/rows as the relative positions to inspect.</example>\n</note1>\n\n<note2>\n<description>Consider the two columns immediately to the right of the anchor as the candidate columns for the transformation. The examples consistently use these two columns (not columns further away), so focus your attention there.</description>\n<example>With an anchor occupying columns 0–1, columns 2 and 3 are the only places to look for the new marks. If you instead checked columns 4–5 you would miss the intended pattern.</example>\n</note2>\n\n<note3>\n<description>For each of those two candidate columns, look down the column for the first non-background cell (the earliest row where that column contains a color). If that first non-background cell is in the same row as the anchor's bottom edge, mark that column's top cell with the anchor color.</description>\n<example>Suppose the anchor occupies rows 0–1 and the first colored pixel in column 2 is at row 3; then the cell at column 2, row 0 should be changed to the anchor color (a vertical marker). If the first colored pixel in column 3 were at row 2, then column 3, row 0 would be marked instead.</example>\n</note3>\n\n<note4>\n<description>If a candidate column contains no colored pixel at all, the rule does not mark that column. Only columns that contain at least one non-background cell in the relevant rows are candidates for the top-row marker.</description>\n<example>Given columns 2–3 where column 2 has no colored pixels but column 3 has one, only column 3 would get the top-row marker. Column 2 remains unchanged.</example>\n</note4>\n\n<note5>\n<description>When multiple columns meet the criteria, apply the same top-row marker independently to each qualifying column; the marker is placed at the top of the column (the anchor's top row), not below or beside the anchor. This produces a vertical alignment with the anchor's top edge.</description>\n<example>If both column 2 and column 3 have non-background pixels in the same rows below the anchor, change both column 2,row 0 and column 3,row 0 to the anchor color; if only one qualifies, change only that one. Do not shift or copy the anchor itself—only add the single-cell vertical markers in the anchor's top row.</example>\n</note5>","<note1>\n<description>Look for a small, repeated object that appears in the same relative positions across examples; this object is usually the seed for the transformation. The seed is often a compact multi-cell shape (e.g., two adjacent cells) that stands out from the rest of the grid.</description>\n<example>Imagine a 6×6 grid where one 2×2 block of a single color appears in the top-left while the rest of the grid is mostly background. That repeated 2×2 block is a likely seed: it is compact, identical across examples, and positioned consistently, so it is the natural starting point for further change.</example>\n</note1>\n\n<note2>\n<description>Check the orientation and color of the seed: determine whether it is a horizontal pair (two adjacent cells in the same row) or a vertical pair (two adjacent cells in the same column). The orientation tells you which diagonal direction will be used.</description>\n<example>If the seed occupies two adjacent cells in the same row (for example two identical cells side-by-side), treat it as a horizontal pair and plan to operate along the diagonal that runs down-right from that pair. If instead the two cells are stacked, treat it as a vertical pair and plan for the down-left diagonal.</example>\n</note2>\n\n<note3>\n<description>Extend the seed by following the diagonal that runs from the seed toward the bottom-right corner (for a horizontal pair) or toward the bottom-left corner (for a vertical pair). Only cells that lie exactly on that diagonal and are background (0) should be considered for change.</description>\n<example>Given a horizontal seed at the top-left, draw a diagonal that goes down-right from the seed's top-left cell; then check each cell along that diagonal (one step down and one step right each time) until you hit the grid edge or a non-background cell. Only those background cells on that diagonal are candidates for modification.</example>\n</note3>\n\n<note4>\n<description>When you fill the diagonal, replace only background (0) cells with a single, consistent marker color (distinct from the seed and other existing colors). Do not overwrite any non-zero cells already present in the grid.</description>\n<example>If the diagonal cells you identified are all zeros, change them to one marker color (the same marker color each time) while leaving any other colored pixels untouched. This preserves original information while marking the newly created diagonal.</example>\n</note4>\n\n<note5>\n<description>Use simple heuristics to avoid mistakes: only change background cells, use the same marker everywhere, and choose the diagonal that points toward the bottom-right (for horizontal seeds) or bottom-left (for vertical seeds). If there are multiple identical seeds, repeat the same diagonal-filling step for each seed.</description>\n<example>If you see two identical horizontal seeds in the same grid, perform the down-right diagonal fill for both seeds independently, replacing background cells with the marker color each time. If you encounter a diagonal cell that is already non-zero, skip it so you do not overwrite existing content.</example>\n</note5>","<note1>\n<description>Look for a small, repeated L-shaped block in the top-left of the input: a 2×2 square of one color plus a single pixel of a different color one cell down and one cell right. This L is the seed that determines where the transformation will occur.</description>\n<example>Imagine a 2×2 blue block at (0,0)–(1,1) and a red pixel at (2,2). That configuration is the seed: the blue 2×2 is the anchor and the red pixel is the marker. Recognizing this exact pattern is the first step before you try to reproduce it elsewhere.</example>\n</note1>\n\n<note2>\n<description>Check whether the same marker color appears elsewhere in the grid — specifically along the diagonal that runs from the top-right to the bottom-left. The marker often appears at several positions along that diagonal; those positions are the ones to consider for replication.</description>\n<example>For instance, if the marker color appears at (0,5), (1,4), (2,3), (3,2), (4,1), (5,0) then those diagonal positions are the targets. If the marker does not appear there, the transformation is not about copying that color but about a different geometric operation.</example>\n</note2>\n\n<note3>\n<description>The core operation is a diagonal translation: every marker pixel at (r,c) is moved to (r+1,c-1). That is, each marker moves one row down and one column left along the anti-diagonal.</description>\n<example>With a marker at (0,5) you would place a new marker at (1,4); a marker at (2,3) becomes (3,2), and so on. This produces a chain of new markers that follow the same anti-diagonal as the original marker.</example>\n</note3>\n\n<note4>\n<description>When placing the new markers, use a single consistent fill color that is distinct from the background and the seed colors. The fill color is the same for every placed marker and should not be confused with the original marker or seed colors.</description>\n<example>Suppose the original marker is red and the seed is blue; you should place new markers in a single neutral color (e.g., green) so each new marker is visually distinct and the chain is unambiguous. This keeps the transformation predictable and easy to verify.</example>\n</note4>\n\n<note5>\n<description>Apply the translation only to markers that lie strictly below the seed (their row index is larger than the seed’s row). If a marker would move outside the grid, it is simply omitted; also ignore markers that are already on the same row or column as the seed.</description>\n<example>If the seed is at row 0 and a marker is at row 0, do not move it. If a marker at row 2 would move to row 3 but column −1 (off the grid), omit it. These checks prevent accidental overwrites and ensure the chain stays inside the grid.</example>\n</note5>","<note1>\n<description>Look for a small vertical block (a 2×2) that appears in the top-left of many inputs and remains unchanged in the outputs. That block is the anchor: it determines which rows and columns are used for the transformation.</description>\n<example>Imagine a grid whose top-left 2×2 contains four different colors (for example, a 2×2 block of four distinct values). If you see that same 2×2 block in every example and it is not modified in the outputs, treat it as the fixed anchor and ignore it when searching for the rule.</example>\n</note1>\n\n<note2>\n<description>Ignore the bottom-right cell that contains a different color (it is a separate marker and not part of the pattern). Focus on the 2×2 anchor as the source of the colors that will be used to build the new marks.</description>\n<example>For instance, if the bottom-right corner shows a color not present in the top-left 2×2, do not treat that corner as part of the 2×2 block. Instead, extract the four values from the top-left 2×2 as the palette you will work with.</example>\n</note2>\n\n<note3>\n<description>Form the two-row motif by pairing the top row of the 2×2 with the bottom row of the 2×2 in reverse order (top-left with bottom-right, top-right with bottom-left). That pairing yields two 2‑element sequences that determine where to place marks.</description>\n<example>If the top row of the 2×2 is [A, B] and the bottom row is [C, D], then the paired sequences are [A, D] and [B, C]. These two sequences are the vertical patterns you will use to decide which rows and columns receive the marker color.</example>\n</note3>\n\n<note4>\n<description>Turn each paired sequence into a diagonal: place the marker color in every column where the first element of the pair is present, and place the marker color in every column where the second element of the pair is present. The two diagonals run down the same two columns (the anchor columns) across the grid.</description>\n<example>With paired sequences [A, D] and [B, C], scan the grid and, whenever you find A or D, put the marker in the same column; do the same for B or C. If A and D occur in different columns, you get two parallel diagonals (one for A/D and one for B/C).</example>\n</note4>\n\n<note5>\n<description>Only write the marker into cells that are currently background (0) and never overwrite any existing non-zero cell. Also, do not modify the top-left 2×2 anchor or the bottom-right marker cell.</description>\n<example>If a column already contains a non-zero value from the anchor or from the bottom-right marker, leave it as-is. Only fill background cells along the diagonals you computed; if a diagonal would land on a non-background cell, skip that position so the original pattern remains intact.</example>\n</note5>","<note1>\n<description>Look for a small, repeated block of non-background pixels that appears in the same relative position in every training input. Such a repeated block is often the \"seed\" that the transformation uses as a template for further changes.</description>\n<example>Imagine a 2×2 colored square in the top-left of several inputs; if that same 2×2 appears in the same place across examples, treat it as the motif to focus on. Ignore the rest of the grid for now and concentrate on how that motif is altered between input and output.</example>\n</note1>\n<note2>\n<description>Compare the seed block in input versus output to see what changes: do colors change, are pixels added or removed, or does the block remain identical? This tells you whether the transformation is a copy, a recoloring, or an insertion.</description>\n<example>For example, if the 2×2 seed is identical in input and output but there are new colored pixels elsewhere, the seed itself is preserved while other pixels are being modified. If the seed's colors differ in the output, the rule may be copying or recoloring the seed rather than simply copying pixels.</example>\n</note2>\n<note3>\n<description>Check for a diagonal propagation: many tasks place copies of the seed along the main diagonal (top-left to bottom-right). Ask whether the output contains new colored pixels that line up along that diagonal and whether those new pixels match the seed's color.</description>\n<example>Take a small seed in the top-left; if the output shows additional colored pixels one cell down-and-right from the seed, two cells further, etc., that indicates a diagonal copying pattern. Confirm the diagonal positions by counting rows and columns from the seed.</example>\n</note3>\n<note4>\n<description>Identify the background color (often 0) and treat any non-background pixel that is not part of the seed as a candidate target for the transformation. The rule typically targets background cells that lie on the diagonal path, not existing colored pixels.</description>\n<example>If most of the interior is empty (zeros) and the seed sits in the top-left, the zeros along the down-right diagonal are the likely targets. Avoid changing other non-zero pixels already present elsewhere in the grid.</example>\n</note4>\n<note5>\n<description>Decide how far the diagonal propagation goes: usually it stops at the bottom-right border or when a non-background cell is encountered. Use the examples to determine whether the copy continues until the edge or is blocked by an existing colored pixel.</description>\n<example>Imagine a diagonal of empty cells starting at the seed; if the output shows the seed color filling those empty cells until the last row/column, the rule continues to the border. If the output stops earlier, check whether it encountered a non-zero pixel that blocked further copying.</example>\n</note5>","<note1>\n<description>Scan the grid for a single contiguous horizontal run of the same non-zero color that appears in the top rows. When such a run exists, it typically serves as a template or anchor that determines where new pixels will be placed.</description>\n<example>Imagine a grid where row 0 has three adjacent identical colored pixels (e.g., \"A A A\"). Treat that run as a reference: its length and starting column tell you which column to use for subsequent placements rather than the color values themselves.</example>\n</note1>\n\n<note2>\n<description>Look for a bottom-row segment made of distinct non-zero colors; this segment usually supplies the values used to fill new cells. The order of those colors along the bottom row is the sequence you will use for filling.</description>\n<example>For example, if the last row reads [B C D E] from left to right, those four colors are the candidates for the cells you will color in the interior of the grid—use their left-to-right order when assigning values.</example>\n</note2>\n\n<note3>\n<description>Construct the new cells by placing the bottom-row colors in a regular pattern down the middle columns: start at the column immediately to the right of the top-row run, then place the next color one column to the right, and repeat. This produces a diagonal-like band of filled cells whose spacing equals the run length.</description>\n<example>If the top-row run starts at column 0 and has length 2, then the first new cell goes at column 2, the next at column 4, and so on; if the run length is 3, start at column 1 and step by 3. The step size is the run length, not the number of bottom-row colors.</example>\n</note3>\n\n<note4>\n<description>Only overwrite background (zero) cells when filling; do not replace any existing non-zero pixels. If a candidate fill position already contains a non-zero color, leave it unchanged and skip that position in the pattern.</description>\n<example>If a planned fill location already has a colored pixel, do not change it. If multiple candidate positions fall on zeros, fill them in order according to the bottom-row sequence (first bottom-row color, then the next, etc.), preserving zeros elsewhere.</example>\n</note4>\n\n<note5>\n<description>After filling, verify that the top-row run and the bottom-row segment remain identical to the inputs and that the newly filled cells form a single contiguous band along the middle columns. These checks confirm you used the correct template and sequence.</description>\n<example>Once you have filled the diagonal band, scan the top and bottom rows to ensure they match the originals and that the filled cells form a continuous band aligned with the middle columns—any deviation means you misaligned the start or stepped the wrong amount.</example>\n</note5>","<note1>\n<description>Look for a single small filled object in the top-left that acts as a template: its shape and orientation are preserved in the output and are used to decide where to place new pixels. Treat that object as the source of the transformation rather than as something to be modified.</description>\n<example>Imagine a 2×2 block of a single color at the top-left. In the output you should expect to find that same 2×2 shape in place; the transformation uses that block’s pattern and position to determine where additional pixels will be placed.</example>\n</note1>\n\n<note2>\n<description>Find the corresponding bottom-right region and mark the cells that are the same color as the top-left object. These matching cells are the targets where the transformation produces a new marker (a distinct color). Matching is exact color equality, not color counts or adjacency.</description>\n<example>If the top-left object is color A, scan the bottom-right for any cell that is also color A; those cells are the ones to be highlighted by the new marker in the output.</example>\n</note2>\n\n<note3>\n<description>Decide the placement rule by aligning the template with the matching cells: for each matching cell in the bottom-right, place the marker at the corresponding cell that is directly below the template (same column but one row down). This produces a vertical column of markers aligned with the template.</description>\n<example>With a 2×2 template in the top-left, the marker will appear at the cell immediately beneath the template in the same column — in other words, the marker sits one row down and in the same column as the template’s corresponding cell.</example>\n</note3>\n\n<note4>\n<description>Apply the marker to every matching cell in the bottom-right and keep all other pixels unchanged; do not alter the template or any unrelated colors. The marker should be a single, distinct color not present in the original grid.</description>\n<example>If there are three matching cells in the bottom-right, place the marker at the three corresponding positions below the template and leave every other cell exactly as it was in the input.</example>\n</note4>\n\n<note5>\n<description>Watch for pitfalls: the template’s exact size and color must match the target; the marker is placed one row down in the same column, not shifted or rotated; and only exact color equality counts as a match. If a matching cell is missing, do not invent or fill it.</description>\n<example>If the template is 2×2 but you find only one matching cell in the bottom-right, place the marker only at that one cell beneath the template — do not try to extend or rotate the placement.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Look for a small, contiguous block of non-background pixels that appears in the same place in every input. When that block is a compact square (two-by-two), it is a strong candidate for the transformation's source.</description>\\n<example>Imagine a grid where a 2×2 colored square sits in the top-left and the rest of the grid is background. If the output changes only inside that small square while other areas remain identical, the 2×2 square is likely the object to focus on.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the output to the input to find which cells were modified and which remain the same. The unchanged rows/columns usually indicate the background (zero) and the rows/columns that changed point to the area of interest.</description>\\n<example>For instance, if the top-left two rows and two columns are altered in the output but the rest of the grid is identical, those altered rows/columns are the ones to investigate further.</example>\\n</note2>\\n\\n<note3>\\n<description>Think in terms of diagonals: a 2×2 square has two diagonals (top-left→bottom-right and top-right→bottom-left). Ask whether the transformation targets one diagonal or both — that distinction often determines the pattern of new pixels.</description>\\n<example>With a 2×2 block occupying rows 1–2 and columns 1–2, the two main diagonals run (1,1)–(2,2) and (1,2)–(2,1). If the output shows a single colored pixel per diagonal, the rule is about marking diagonals rather than copying or rotating the whole block.</example>\\n</note3>\\n\\n<note4>\\n<description>Consider that the diagonal pixels are a new color distinct from the original block and the surrounding background. The added pixels should not overwrite other non-background values already present in the grid.</description>\\n<example>If the original 2×2 square uses color A and the grid background is B, the output may introduce color C on the diagonals; check that existing non-background cells are preserved and not replaced.</example>\\n</note4>\\n\\n<note5>\\n<description>Verify the rule is local and consistent: it should apply only to that specific 2×2 square and only on its diagonals, not on other colored shapes or elsewhere in the grid. Use that consistency to decide what to do in the test case.</description>\\n<example>If you find another colored cluster elsewhere that is not a 2×2 square, do not expect the same diagonal marking there. The transformation is targeted and repeatable only when the exact 2×2 square condition is met.</example>\\n</note5>\",\n \"<note1>\\n<description>Check which two rows are preserved exactly and which row is transformed. When one full row (the top) and the bottom row are identical across examples, the middle row is the only one that changes — focus your attention on that middle row.</description>\\n<example>Imagine a 7×7 grid where the top and bottom rows are identical and the center row is different. In the output you should see the top and bottom rows unchanged, while the center row is altered in a regular way; this narrows the problem to finding the rule that modifies the middle row.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a vertical offset between a middle-row pixel and the corresponding bottom-row pixel: the distance is constant across the middle row. If the bottom-row pixel is always one row below the middle-row pixel (and the middle row is two rows from the bottom), the vertical offset is +1.</description>\\n<example>For instance, if the middle-row pixel at column j is aligned with the bottom-row pixel at column j, then every column in the middle row has the same vertical offset of +1 to reach its counterpart on the bottom row. That constant offset tells you to use a one-row vertical shift when comparing cells.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare values in the same column: the middle-row cell and the bottom-row cell in that column are often the same color. If they match, the transformation is not a recoloring but a placement of a new marker relative to that matching pair.</description>\\n<example>Suppose column j of the middle row and column j of the bottom row both show color X. The rule does not change X to a different color; instead it introduces a new marker at the middle cell relative to that matching pair. So first confirm equality before deciding to place a marker.</example>\\n</note3>\\n\\n<note4>\\n<description>When the middle and bottom cells match, insert a new marker (a distinct color) into the middle cell; when they differ, leave the middle cell unchanged. In other words, the marker is placed only when the two cells are identical.</description>\\n<example>For example, if the middle cell is X and the bottom cell is X, paint the middle cell with the marker color. If the bottom cell is Y (different from X), keep the middle cell as it was. This conditional placement explains why some middle cells become the marker and others remain as they were.</example>\\n</note4>\\n\\n<note5>\\n<description>Use a consistent marker color that does not appear in the input and apply it to every matching column. Do not alter the top or bottom rows and do not overwrite any existing non-background values in the middle row.</description>\\n<example>Choose a marker color not present in the grid and place it into the middle row only at columns where the middle-row and bottom-row cells match. Leave other middle-row cells unchanged and keep the top and bottom rows exactly as they are.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a compact block of identical non-background pixels that appears in the same place in every input. That repeated block is often the anchor for the transformation and should be treated as a single object rather than many separate pixels.</description>\\n<example>Imagine a grid where the top-left contains a 2×2 block of the same color while the rest of the top row and bottom row are different. Treat that 2×2 as one object; its location and color will be relevant for what follows.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the top row and the bottom row as sequences. The transformation often uses one of these rows as a “source” of values to be placed elsewhere, so record the sequence order exactly (left-to-right or right-to-left).</description>\\n<example>If the top row reads [A B C D] and the bottom row reads [E F G H], check whether the examples use the top row’s left-to-right order or the bottom row’s left-to-right order as the sequence to be copied into the interior.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide whether the sequence is copied left-to-right or right-to-left. The direction is consistent across examples and can be determined by comparing the first and last elements of the source row with the corresponding interior cells.</description>\\n<example>Take a short sequence [X Y Z]. If the interior cells become [Z Y X], the copy is reversed; if they become [X Y Z], the copy is in the original order. Test both directions on the training pairs to pick the correct one.</example>\\n</note3>\\n\\n<note4>\\n<description>When copying the sequence, place each source value into the same row but into the interior columns that are currently background (zeros). Do not overwrite existing non-background pixels; only fill empty cells.</description>\\n<example>Given an interior row [0 0 0 0], copying [A B C] left-to-right yields [A B C 0]; copying [C B A] right-to-left yields [0 0 0 C B A]. Always leave any non-zero cells already present unchanged.</example>\\n</note4>\\n\\n<note5>\\n<description>Use a single, distinct marker color (the same color in every example) for any newly introduced interior pixels and verify that the marker is not used elsewhere in the grid. This ensures the added pattern is unambiguous and consistent.</description>\\n<example>If the training outputs introduce a new color M in the interior positions, adopt M for all new placements. Also check that no other non-background pixels were replaced—only background cells should be filled with the marker.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a compact colored object in the top-left that acts as a template: it may be a single small block, a repeated pattern, or a set of adjacent pixels that repeat across rows. This template is the source of the repeated pattern you should reproduce elsewhere.</description>\\n<example>Imagine a 2×2 colored square at the top-left and a separate colored pixel at the top-right; the 2×2 square is the template because it is a small, contiguous motif, while the single pixel is just a lone color. Mark that contiguous block as the template to compare with other areas.</example>\\n</note1>\\n\\n<note2>\\n<description>Search the bottom-right corner for a small horizontal sequence of distinct colors (often a single column of different colors). Treat this sequence as the target that will be copied into the empty area, preserving the order and spacing of its colors.</description>\\n<example>If the bottom-right contains a column like [A,B,C,D] (one color per row), regard that column as a sequence to be reproduced elsewhere. The important thing is the order A→B→C→D, not which specific letters they are.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide which rows to copy by matching the template's height to the target's length: the template's number of rows (or its repeated-unit height) determines how many consecutive rows you will copy from the bottom-right. Align the template's rows with the bottom-right rows so the copy fits the available empty rows.</description>\\n<example>If the template is two rows tall and the bottom-right has four distinct colors, copy two rows from the bottom-right into the empty area; if the template is three rows tall and the bottom-right has five colors, copy three rows. Use the template's height as the size parameter for the copy.</example>\\n</note3>\\n\\n<note4>\\n<description>Place the copied sequence into the empty area so the template's columns line up with the copied columns (use the template's column indices as the target column positions). Fill the empty cells in that area with a single consistent filler color so the pattern is clear and aligned.</description>\\n<example>With a 2×2 template occupying columns 0–1, copy the chosen bottom-right column sequence into columns 0–1 of the empty area and fill other cells with the same filler color. This keeps the template's layout visible while adding the new pattern.</example>\\n</note4>\\n\\n<note5>\\n<description>Preserve the original non-empty rows and do not alter the template or the bottom-right source. If the number of available empty rows is less than the template's height, copy the required number of rows from the bottom-right (the topmost rows of that sequence) rather than truncating the template.</description>\\n<example>If the template is 3 rows tall but only 2 rows are available for copying, take the top two rows of the bottom-right sequence and place them into the empty area; do not remove or change the original template or the bottom-right column. This keeps the transformation consistent and unambiguous.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single small, unchanged object in the input that acts like an anchor. Often this is a 2×2 block of identical non-background color that remains in the same place between input and output; its presence usually indicates the transformation uses that block as a reference.</description>\\n<example>Imagine a 7×7 grid where a 2×2 red square sits at the top-left and everything else is background or single pixels. In the output that 2×2 red square is still there and in the same color, so treat that 2×2 as the anchor when you try to explain the rest of the change.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the background cells around the anchor are being filled by new pixels. If the newly introduced pixels always form a straight diagonal (one cell down-and-right per step), the rule is likely “fill background cells along that diagonal with a marker.”</description>\\n<example>For example, if the anchor is at (0,0), you might observe a new color appearing at (1,1), (2,2), etc. Those are not random fills — they follow a consistent down-right diagonal path.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide how far that diagonal is drawn: it usually stops when it reaches the opposite edge of the grid or when it would step outside the grid. The rule is to continue until you cannot step further, not to wrap around.</description>\\n<example>If the diagonal would step beyond the bottom row, stop at the last valid cell (the bottom row). If the diagonal would step beyond the rightmost column, stop at the last valid column; the diagonal simply ends at the grid boundary.</example>\\n</note3>\\n\\n<note4>\\n<description>When the diagonal passes through a non-background cell, the transformation typically treats those cells as “already filled” and does not overwrite them with the marker. So the final diagonal shows only background cells turned into the marker, skipping any occupied cells.</description>\\n<example>Suppose the diagonal would land on a cell that already contains a different colored pixel; that cell remains its original color and the marker is not placed there. The visible diagonal is therefore a set of background cells turned into the marker, with any original colored cells left unchanged.</example>\\n</note4>\\n\\n<note5>\\n<description>Use the anchor's color to determine the marker used for the diagonal, and always preserve all other non-background pixels (including any color already on the diagonal). This keeps the anchor visible and prevents accidental overwriting of other meaningful objects.</description>\\n<example>If the anchor is blue, the diagonal will use blue as the marker color; other colored pixels elsewhere remain as they were. After filling the diagonal, verify that the anchor is still intact and that no other colored cells were changed.</example>\\n</note5>\",\n \"<note1>\\n<description>Check the two outermost rows and columns for a repeated small motif. When the same short pattern appears at the grid edges, that motif is often the source of the transformation rather than isolated pixels.</description>\\n<example>Imagine a 7×7 grid whose top row and left column both start with [A A ...]. Treat [A A] as the motif and record its coordinates (top-left and top-right of the motif) so you can compare those positions across rows.</example>\\n</note1>\\n<note2>\\n<description>Compare motif positions down the rows: if the motif’s top-right coordinate stays the same while its top-left moves one column per row, that indicates a diagonal (down‑right) propagation. Tracking that shift reveals the direction and spacing of the added pattern.</description>\\n<example>For instance, if the motif’s top-right is always column 6 across rows but its top-left moves from column 1 to 2 to 3 as you go down rows, then the motif is being shifted down-right by one column per row.</example>\\n</note2>\\n<note3>\\n<description>Look for a single marker color used only to show where the motif was placed; this marker is typically distinct from the motif and the rest of the grid. The marker appears exactly where the motif would have been placed in each row.</description>\\n<example>Suppose the motif is color A and the output introduces a new color X only at the motif positions. X marks the motif’s landing spots while A remains unchanged elsewhere.</example>\\n</note3>\\n<note4>\\n<description>Decide which rows receive the marker by checking whether the motif appears in the input for that row (it may be present only on some rows). Only those rows are candidates for adding the marker at the motif’s projected positions.</description>\\n<example>If the motif is visible on rows 1–3 but not on row 4, then only rows 1–3 should receive the marker at their projected motif coordinates; row 4 stays as it is.</example>\\n</note4>\\n<note5>\\n<description>When projecting the motif down the diagonal, clip the projection at the grid boundary and do not overwrite existing non-background pixels. Use the motif’s top-right anchor as the reference for placement and stop when you reach the grid edge.</description>\\n<example>If the motif’s top-right is at column 6, place markers at columns 6, 5, 4, … as you move down the diagonal but do not write into columns outside the grid; if a target cell already contains a non-background color, leave it unchanged.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single-color rectangular block that appears in the same place in every input and remains unchanged in the outputs; this block is the anchor for the transformation. Treat that block as fixed and ignore it when reasoning about new markings.</description>\\n<example>Imagine a grid where the top-left 2×2 is all the same color and every example keeps that 2×2 identical. You should first mark that 2×2 as the anchor and do not alter those cells when you try to explain the differences between input and output.</example>\\n</note1>\\n<note2>\\n<description>After removing the anchor, check whether the remaining colored pixels form a repeated motif (for example, a 1×1 colored pixel) that appears in the same column order across the rows below the anchor. The motif is the element being copied or extended.</description>\\n<example>For instance, if the area below the anchor contains a sequence like [A, B, C] down the columns, and the output shows that same sequence repeated in other rows, then the motif is that column-wise sequence and it is the thing to propagate.</example>\\n</note2>\\n<note3>\\n<description>Decide the propagation rule: the examples consistently place a new marker in the column immediately to the right of each motif instance, one row at a time (i.e., a down‑right diagonal). Think of it as advancing one column and one row per repetition rather than copying the motif into multiple columns at once.</description>\\n<example>With a motif [A, B, C] in columns 4–6, the rule would place a marker in column 4, then column 5, then column 6, each time one row lower (a down‑right diagonal), rather than putting markers in columns 4, 5 and 6 for every row.</example>\\n</note3>\\n<note4>\\n<description>Only mark cells that are currently background (zeros) so the new markers do not overwrite existing colored pixels. This preserves original colored pixels and prevents accidental overwriting.</description>\\n<example>If a target cell is already a non-zero color, leave it unchanged; only convert empty (zero) cells along the diagonal into the marker color, while keeping the original colored pixels intact.</example>\\n</note4>\\n<note5>\\n<description>Apply the diagonal propagation only within the rows below the anchor and stop when you reach the bottom edge or the next row that already contains a non-zero in that diagonal position. This keeps the operation bounded and consistent with the examples.</description>\\n<example>Start the diagonal at the row immediately beneath the anchor and step one row down per marker; if the next row already has a colored pixel in the intended diagonal position, do not overwrite it and stop there rather than continuing the diagonal further.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a small, contiguous block that is repeated in a regular way across the grid (often a 2×2 square). If that block appears in the same relative positions in every row, treat it as a single object whose internal pattern you should preserve.</description>\\n<example>Imagine a grid where rows 1–2 contain the same two-column block of two non-background colors. Treat that 2×2 block as one object and do not split its two colors into separate cells when reasoning about the transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the leftmost column of the top block with the rightmost column of the bottom block. The examples align those two columns so the leftmost column of the top block sits directly above the rightmost column of the bottom block.</description>\\n<example>If the top block’s left column has colors [A,B] and the bottom block’s right column has colors [X,Y], place A above X and B above Y. This alignment is what the examples use to pair the two blocks.</example>\\n</note2>\\n\\n<note3>\\n<description>For each aligned pair of cells, check whether the two colors are the same. When they match, the output marks that cell with a distinct marker color (a single, consistent marker across the grid); when they differ, leave the cell as background.</description>\\n<example>With aligned pairs (A,X) and (B,Y), if A == X and B == Y then the corresponding positions receive the marker color; if A != X or B != Y, those positions remain background.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the same marker independently to every aligned position in every row. The marker only highlights matches; it does not alter the original colors of the top or bottom blocks.</description>\\n<example>Across multiple rows, if the top-left column and bottom-right column each contain matching pairs in several rows, place the marker at each matching cell; mismatches in any row remain background.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple checks to confirm you found the correct blocks and alignment: the top block should be contiguous and repeated in the same place for several rows, and the bottom block should be a second contiguous block in the same relative column positions. If those conditions are met, the pairwise test above will reproduce the example outputs.</description>\\n<example>If you find two identical 2×2 blocks in the same columns across rows, align their leftmost/top and rightmost/bottom columns and perform the per-pair equality test; if the resulting marked cells match the examples’ pattern, your interpretation is correct.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a repeated, small object: a compact block of identical non-background pixels that appears in the same relative location across examples. This repeated block is usually the anchor for the transformation because its exact placement is preserved.</description>\\n<example>Imagine a grid where a 2×2 square of blue pixels sits in the same top-left corner in every example. That square is a strong candidate to be the anchor: the rest of the changes are likely relative to this fixed block.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the bottom-right corner of the grid to the top-left corner: many ARC tasks place a small pattern there that is reused elsewhere. Check whether the bottom-right color appears multiple times (especially at the same column indices) and whether those positions are aligned with the anchor.</description>\\n<example>For instance, if the bottom-right corner shows three different colors in a horizontal sequence and you find that same sequence (in the same order) appears somewhere else in the grid, treat that sequence as a candidate motif to be relocated.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide whether the motif is being copied or mirrored: the motif’s internal order may be preserved, reversed, or rotated. Determine orientation by checking which cells of the motif correspond to which cells of the anchor in the output.</description>\\n<example>If the motif’s left-to-right order is reversed when it appears at the anchor’s location, that indicates a horizontal mirror; if the motif’s top-to-bottom order is reversed, that indicates a vertical mirror. Try both possibilities and see which matches all examples.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the transformation by translating the motif so its center (or a chosen reference pixel) aligns with the anchor’s center, then place the motif at that translated location. The motif’s orientation (original, flipped, rotated) should be consistent with the earlier comparison.</description>\\n<example>If the motif is 3×3 and the anchor is 2×2, align the motif’s center with the anchor’s center and place it so the motif occupies the same relative area. If the motif must be mirrored, flip it horizontally or vertically before placing.</example>\\n</note4>\\n\\n<note5>\\n<description>Use invariants to validate your hypothesis: the anchor itself should remain identical, background cells should stay background, and non-background colors outside the motif should be preserved. Only replace background cells with the motif’s colors when placing it.</description>\\n<example>After placing the motif, scan the grid: the original anchor block must be unchanged, the motif’s colors should occupy only background positions, and every other colored pixel must match the input. If any invariant fails, reconsider orientation or alignment.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a small, contiguous block of identical non-background pixels that appears in the same corner in every input. That block is the anchor: its color and its exact pixel positions determine where any further change will be placed.</description>\\n<example>Imagine a grid where the top-left 2×2 area is entirely color A. Treat that 2×2 as the anchor; any rule that depends on that block will use A as the marker color and the two adjacent columns/rows as the relative positions to inspect.</example>\\n</note1>\\n\\n<note2>\\n<description>Consider the two columns immediately to the right of the anchor as the candidate columns for the transformation. The examples consistently use these two columns (not columns further away), so focus your attention there.</description>\\n<example>With an anchor occupying columns 0–1, columns 2 and 3 are the only places to look for the new marks. If you instead checked columns 4–5 you would miss the intended pattern.</example>\\n</note2>\\n\\n<note3>\\n<description>For each of those two candidate columns, look down the column for the first non-background cell (the earliest row where that column contains a color). If that first non-background cell is in the same row as the anchor's bottom edge, mark that column's top cell with the anchor color.</description>\\n<example>Suppose the anchor occupies rows 0–1 and the first colored pixel in column 2 is at row 3; then the cell at column 2, row 0 should be changed to the anchor color (a vertical marker). If the first colored pixel in column 3 were at row 2, then column 3, row 0 would be marked instead.</example>\\n</note3>\\n\\n<note4>\\n<description>If a candidate column contains no colored pixel at all, the rule does not mark that column. Only columns that contain at least one non-background cell in the relevant rows are candidates for the top-row marker.</description>\\n<example>Given columns 2–3 where column 2 has no colored pixels but column 3 has one, only column 3 would get the top-row marker. Column 2 remains unchanged.</example>\\n</note4>\\n\\n<note5>\\n<description>When multiple columns meet the criteria, apply the same top-row marker independently to each qualifying column; the marker is placed at the top of the column (the anchor's top row), not below or beside the anchor. This produces a vertical alignment with the anchor's top edge.</description>\\n<example>If both column 2 and column 3 have non-background pixels in the same rows below the anchor, change both column 2,row 0 and column 3,row 0 to the anchor color; if only one qualifies, change only that one. Do not shift or copy the anchor itself—only add the single-cell vertical markers in the anchor's top row.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a small, repeated object that appears in the same relative positions across examples; this object is usually the seed for the transformation. The seed is often a compact multi-cell shape (e.g., two adjacent cells) that stands out from the rest of the grid.</description>\\n<example>Imagine a 6×6 grid where one 2×2 block of a single color appears in the top-left while the rest of the grid is mostly background. That repeated 2×2 block is a likely seed: it is compact, identical across examples, and positioned consistently, so it is the natural starting point for further change.</example>\\n</note1>\\n\\n<note2>\\n<description>Check the orientation and color of the seed: determine whether it is a horizontal pair (two adjacent cells in the same row) or a vertical pair (two adjacent cells in the same column). The orientation tells you which diagonal direction will be used.</description>\\n<example>If the seed occupies two adjacent cells in the same row (for example two identical cells side-by-side), treat it as a horizontal pair and plan to operate along the diagonal that runs down-right from that pair. If instead the two cells are stacked, treat it as a vertical pair and plan for the down-left diagonal.</example>\\n</note2>\\n\\n<note3>\\n<description>Extend the seed by following the diagonal that runs from the seed toward the bottom-right corner (for a horizontal pair) or toward the bottom-left corner (for a vertical pair). Only cells that lie exactly on that diagonal and are background (0) should be considered for change.</description>\\n<example>Given a horizontal seed at the top-left, draw a diagonal that goes down-right from the seed's top-left cell; then check each cell along that diagonal (one step down and one step right each time) until you hit the grid edge or a non-background cell. Only those background cells on that diagonal are candidates for modification.</example>\\n</note3>\\n\\n<note4>\\n<description>When you fill the diagonal, replace only background (0) cells with a single, consistent marker color (distinct from the seed and other existing colors). Do not overwrite any non-zero cells already present in the grid.</description>\\n<example>If the diagonal cells you identified are all zeros, change them to one marker color (the same marker color each time) while leaving any other colored pixels untouched. This preserves original information while marking the newly created diagonal.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple heuristics to avoid mistakes: only change background cells, use the same marker everywhere, and choose the diagonal that points toward the bottom-right (for horizontal seeds) or bottom-left (for vertical seeds). If there are multiple identical seeds, repeat the same diagonal-filling step for each seed.</description>\\n<example>If you see two identical horizontal seeds in the same grid, perform the down-right diagonal fill for both seeds independently, replacing background cells with the marker color each time. If you encounter a diagonal cell that is already non-zero, skip it so you do not overwrite existing content.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a small, repeated L-shaped block in the top-left of the input: a 2×2 square of one color plus a single pixel of a different color one cell down and one cell right. This L is the seed that determines where the transformation will occur.</description>\\n<example>Imagine a 2×2 blue block at (0,0)–(1,1) and a red pixel at (2,2). That configuration is the seed: the blue 2×2 is the anchor and the red pixel is the marker. Recognizing this exact pattern is the first step before you try to reproduce it elsewhere.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the same marker color appears elsewhere in the grid — specifically along the diagonal that runs from the top-right to the bottom-left. The marker often appears at several positions along that diagonal; those positions are the ones to consider for replication.</description>\\n<example>For instance, if the marker color appears at (0,5), (1,4), (2,3), (3,2), (4,1), (5,0) then those diagonal positions are the targets. If the marker does not appear there, the transformation is not about copying that color but about a different geometric operation.</example>\\n</note2>\\n\\n<note3>\\n<description>The core operation is a diagonal translation: every marker pixel at (r,c) is moved to (r+1,c-1). That is, each marker moves one row down and one column left along the anti-diagonal.</description>\\n<example>With a marker at (0,5) you would place a new marker at (1,4); a marker at (2,3) becomes (3,2), and so on. This produces a chain of new markers that follow the same anti-diagonal as the original marker.</example>\\n</note3>\\n\\n<note4>\\n<description>When placing the new markers, use a single consistent fill color that is distinct from the background and the seed colors. The fill color is the same for every placed marker and should not be confused with the original marker or seed colors.</description>\\n<example>Suppose the original marker is red and the seed is blue; you should place new markers in a single neutral color (e.g., green) so each new marker is visually distinct and the chain is unambiguous. This keeps the transformation predictable and easy to verify.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the translation only to markers that lie strictly below the seed (their row index is larger than the seed’s row). If a marker would move outside the grid, it is simply omitted; also ignore markers that are already on the same row or column as the seed.</description>\\n<example>If the seed is at row 0 and a marker is at row 0, do not move it. If a marker at row 2 would move to row 3 but column −1 (off the grid), omit it. These checks prevent accidental overwrites and ensure the chain stays inside the grid.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a small vertical block (a 2×2) that appears in the top-left of many inputs and remains unchanged in the outputs. That block is the anchor: it determines which rows and columns are used for the transformation.</description>\\n<example>Imagine a grid whose top-left 2×2 contains four different colors (for example, a 2×2 block of four distinct values). If you see that same 2×2 block in every example and it is not modified in the outputs, treat it as the fixed anchor and ignore it when searching for the rule.</example>\\n</note1>\\n\\n<note2>\\n<description>Ignore the bottom-right cell that contains a different color (it is a separate marker and not part of the pattern). Focus on the 2×2 anchor as the source of the colors that will be used to build the new marks.</description>\\n<example>For instance, if the bottom-right corner shows a color not present in the top-left 2×2, do not treat that corner as part of the 2×2 block. Instead, extract the four values from the top-left 2×2 as the palette you will work with.</example>\\n</note2>\\n\\n<note3>\\n<description>Form the two-row motif by pairing the top row of the 2×2 with the bottom row of the 2×2 in reverse order (top-left with bottom-right, top-right with bottom-left). That pairing yields two 2‑element sequences that determine where to place marks.</description>\\n<example>If the top row of the 2×2 is [A, B] and the bottom row is [C, D], then the paired sequences are [A, D] and [B, C]. These two sequences are the vertical patterns you will use to decide which rows and columns receive the marker color.</example>\\n</note3>\\n\\n<note4>\\n<description>Turn each paired sequence into a diagonal: place the marker color in every column where the first element of the pair is present, and place the marker color in every column where the second element of the pair is present. The two diagonals run down the same two columns (the anchor columns) across the grid.</description>\\n<example>With paired sequences [A, D] and [B, C], scan the grid and, whenever you find A or D, put the marker in the same column; do the same for B or C. If A and D occur in different columns, you get two parallel diagonals (one for A/D and one for B/C).</example>\\n</note4>\\n\\n<note5>\\n<description>Only write the marker into cells that are currently background (0) and never overwrite any existing non-zero cell. Also, do not modify the top-left 2×2 anchor or the bottom-right marker cell.</description>\\n<example>If a column already contains a non-zero value from the anchor or from the bottom-right marker, leave it as-is. Only fill background cells along the diagonals you computed; if a diagonal would land on a non-background cell, skip that position so the original pattern remains intact.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a small, repeated block of non-background pixels that appears in the same relative position in every training input. Such a repeated block is often the \\\"seed\\\" that the transformation uses as a template for further changes.</description>\\n<example>Imagine a 2×2 colored square in the top-left of several inputs; if that same 2×2 appears in the same place across examples, treat it as the motif to focus on. Ignore the rest of the grid for now and concentrate on how that motif is altered between input and output.</example>\\n</note1>\\n<note2>\\n<description>Compare the seed block in input versus output to see what changes: do colors change, are pixels added or removed, or does the block remain identical? This tells you whether the transformation is a copy, a recoloring, or an insertion.</description>\\n<example>For example, if the 2×2 seed is identical in input and output but there are new colored pixels elsewhere, the seed itself is preserved while other pixels are being modified. If the seed's colors differ in the output, the rule may be copying or recoloring the seed rather than simply copying pixels.</example>\\n</note2>\\n<note3>\\n<description>Check for a diagonal propagation: many tasks place copies of the seed along the main diagonal (top-left to bottom-right). Ask whether the output contains new colored pixels that line up along that diagonal and whether those new pixels match the seed's color.</description>\\n<example>Take a small seed in the top-left; if the output shows additional colored pixels one cell down-and-right from the seed, two cells further, etc., that indicates a diagonal copying pattern. Confirm the diagonal positions by counting rows and columns from the seed.</example>\\n</note3>\\n<note4>\\n<description>Identify the background color (often 0) and treat any non-background pixel that is not part of the seed as a candidate target for the transformation. The rule typically targets background cells that lie on the diagonal path, not existing colored pixels.</description>\\n<example>If most of the interior is empty (zeros) and the seed sits in the top-left, the zeros along the down-right diagonal are the likely targets. Avoid changing other non-zero pixels already present elsewhere in the grid.</example>\\n</note4>\\n<note5>\\n<description>Decide how far the diagonal propagation goes: usually it stops at the bottom-right border or when a non-background cell is encountered. Use the examples to determine whether the copy continues until the edge or is blocked by an existing colored pixel.</description>\\n<example>Imagine a diagonal of empty cells starting at the seed; if the output shows the seed color filling those empty cells until the last row/column, the rule continues to the border. If the output stops earlier, check whether it encountered a non-zero pixel that blocked further copying.</example>\\n</note5>\",\n \"<note1>\\n<description>Scan the grid for a single contiguous horizontal run of the same non-zero color that appears in the top rows. When such a run exists, it typically serves as a template or anchor that determines where new pixels will be placed.</description>\\n<example>Imagine a grid where row 0 has three adjacent identical colored pixels (e.g., \\\"A A A\\\"). Treat that run as a reference: its length and starting column tell you which column to use for subsequent placements rather than the color values themselves.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a bottom-row segment made of distinct non-zero colors; this segment usually supplies the values used to fill new cells. The order of those colors along the bottom row is the sequence you will use for filling.</description>\\n<example>For example, if the last row reads [B C D E] from left to right, those four colors are the candidates for the cells you will color in the interior of the grid—use their left-to-right order when assigning values.</example>\\n</note2>\\n\\n<note3>\\n<description>Construct the new cells by placing the bottom-row colors in a regular pattern down the middle columns: start at the column immediately to the right of the top-row run, then place the next color one column to the right, and repeat. This produces a diagonal-like band of filled cells whose spacing equals the run length.</description>\\n<example>If the top-row run starts at column 0 and has length 2, then the first new cell goes at column 2, the next at column 4, and so on; if the run length is 3, start at column 1 and step by 3. The step size is the run length, not the number of bottom-row colors.</example>\\n</note3>\\n\\n<note4>\\n<description>Only overwrite background (zero) cells when filling; do not replace any existing non-zero pixels. If a candidate fill position already contains a non-zero color, leave it unchanged and skip that position in the pattern.</description>\\n<example>If a planned fill location already has a colored pixel, do not change it. If multiple candidate positions fall on zeros, fill them in order according to the bottom-row sequence (first bottom-row color, then the next, etc.), preserving zeros elsewhere.</example>\\n</note4>\\n\\n<note5>\\n<description>After filling, verify that the top-row run and the bottom-row segment remain identical to the inputs and that the newly filled cells form a single contiguous band along the middle columns. These checks confirm you used the correct template and sequence.</description>\\n<example>Once you have filled the diagonal band, scan the top and bottom rows to ensure they match the originals and that the filled cells form a continuous band aligned with the middle columns—any deviation means you misaligned the start or stepped the wrong amount.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single small filled object in the top-left that acts as a template: its shape and orientation are preserved in the output and are used to decide where to place new pixels. Treat that object as the source of the transformation rather than as something to be modified.</description>\\n<example>Imagine a 2×2 block of a single color at the top-left. In the output you should expect to find that same 2×2 shape in place; the transformation uses that block’s pattern and position to determine where additional pixels will be placed.</example>\\n</note1>\\n\\n<note2>\\n<description>Find the corresponding bottom-right region and mark the cells that are the same color as the top-left object. These matching cells are the targets where the transformation produces a new marker (a distinct color). Matching is exact color equality, not color counts or adjacency.</description>\\n<example>If the top-left object is color A, scan the bottom-right for any cell that is also color A; those cells are the ones to be highlighted by the new marker in the output.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide the placement rule by aligning the template with the matching cells: for each matching cell in the bottom-right, place the marker at the corresponding cell that is directly below the template (same column but one row down). This produces a vertical column of markers aligned with the template.</description>\\n<example>With a 2×2 template in the top-left, the marker will appear at the cell immediately beneath the template in the same column — in other words, the marker sits one row down and in the same column as the template’s corresponding cell.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the marker to every matching cell in the bottom-right and keep all other pixels unchanged; do not alter the template or any unrelated colors. The marker should be a single, distinct color not present in the original grid.</description>\\n<example>If there are three matching cells in the bottom-right, place the marker at the three corresponding positions below the template and leave every other cell exactly as it was in the input.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for pitfalls: the template’s exact size and color must match the target; the marker is placed one row down in the same column, not shifted or rotated; and only exact color equality counts as a match. If a matching cell is missing, do not invent or fill it.</description>\\n<example>If the template is 2×2 but you find only one matching cell in the bottom-right, place the marker only at that one cell beneath the template — do not try to extend or rotate the placement.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[6, 6, 0, 0, 0, 0, 9], [6, 6, 0, 0, 0, 0, 5], [0, 0, 0, 0, 0, 0, 8], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 7], [9, 5, 8, 1, 7, 6, 6]], \"output\": [[6, 6, 0, 0, 0, 0, 9], [6, 6, 0, 0, 0, 0, 5], [0, 0, 2, 0, 0, 0, 8], [0, 0, 0, 2, 0, 0, 1], [0, 0, 0, 0, 2, 0, 7], [9, 5, 8, 1, 7, 6, 6]]}, {\"input\": [[7, 7, 0, 0, 0, 7], [7, 7, 0, 0, 0, 8], [0, 0, 0, 0, 0, 5], [0, 0, 0, 0, 0, 6], [0, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 3], [7, 8, 5, 6, 2, 9]], \"output\": [[7, 7, 0, 0, 0, 7], [7, 7, 0, 0, 0, 8], [0, 0, 2, 0, 0, 5], [0, 0, 0, 2, 0, 6], [0, 0, 0, 0, 2, 2], [0, 0, 0, 0, 0, 3], [7, 8, 5, 6, 2, 9]]}, {\"input\": [[5, 5, 0, 0, 0, 0, 6], [5, 5, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 7], [0, 0, 0, 0, 0, 0, 5], [0, 0, 0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 0, 3], [6, 1, 7, 5, 2, 3, 8]], \"output\": [[5, 5, 0, 0, 0, 0, 6], [5, 5, 0, 0, 0, 0, 1], [0, 0, 2, 0, 0, 0, 7], [0, 0, 0, 2, 0, 0, 5], [0, 0, 0, 0, 2, 0, 2], [0, 0, 0, 0, 0, 2, 3], [6, 1, 7, 5, 2, 3, 8]]}]"},"test":{"kind":"string","value":"[{\"input\": [[6, 6, 0, 0, 0, 5], [6, 6, 0, 0, 0, 8], [0, 0, 0, 0, 0, 9], [0, 0, 0, 0, 0, 7], [0, 0, 0, 0, 0, 6], [0, 0, 0, 0, 0, 2], [5, 8, 9, 7, 6, 4]], \"output\": [[6, 6, 0, 0, 0, 5], [6, 6, 0, 0, 0, 8], [0, 0, 2, 0, 0, 9], [0, 0, 0, 2, 0, 7], [0, 0, 0, 0, 2, 6], [0, 0, 0, 0, 0, 2], [5, 8, 9, 7, 6, 4]]}]"},"source":{"kind":"string","value":"barc_heavy"},"prompt":{"kind":"string","value":"You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n6 6 0 0 0 0 9\n6 6 0 0 0 0 5\n0 0 0 0 0 0 8\n0 0 0 0 0 0 1\n0 0 0 0 0 0 7\n9 5 8 1 7 6 6\n```\n\nOutput:\n```\n6 6 0 0 0 0 9\n6 6 0 0 0 0 5\n0 0 2 0 0 0 8\n0 0 0 2 0 0 1\n0 0 0 0 2 0 7\n9 5 8 1 7 6 6\n```\n\n## Example 2\nInput:\n```\n7 7 0 0 0 7\n7 7 0 0 0 8\n0 0 0 0 0 5\n0 0 0 0 0 6\n0 0 0 0 0 2\n0 0 0 0 0 3\n7 8 5 6 2 9\n```\n\nOutput:\n```\n7 7 0 0 0 7\n7 7 0 0 0 8\n0 0 2 0 0 5\n0 0 0 2 0 6\n0 0 0 0 2 2\n0 0 0 0 0 3\n7 8 5 6 2 9\n```\n\n## Example 3\nInput:\n```\n5 5 0 0 0 0 6\n5 5 0 0 0 0 1\n0 0 0 0 0 0 7\n0 0 0 0 0 0 5\n0 0 0 0 0 0 2\n0 0 0 0 0 0 3\n6 1 7 5 2 3 8\n```\n\nOutput:\n```\n5 5 0 0 0 0 6\n5 5 0 0 0 0 1\n0 0 2 0 0 0 7\n0 0 0 2 0 0 5\n0 0 0 0 2 0 2\n0 0 0 0 0 2 3\n6 1 7 5 2 3 8\n```\n\n# Test Problem:\n```\n6 6 0 0 0 5\n6 6 0 0 0 8\n0 0 0 0 0 9\n0 0 0 0 0 7\n0 0 0 0 0 6\n0 0 0 0 0 2\n5 8 9 7 6 4\n```"},"answer":{"kind":"string","value":"```\n6 6 0 0 0 5\n6 6 0 0 0 8\n0 0 2 0 0 9\n0 0 0 2 0 7\n0 0 0 0 2 6\n0 0 0 0 0 2\n5 8 9 7 6 4\n```"},"num_tokens":{"kind":"number","value":882,"string":"882"}}},{"rowIdx":96,"cells":{"abstraction_prompt":{"kind":"string","value":"<|im_start|>user\nDeveloper: # ARC HINT GENERATOR\n\n## Role & Goal\nYou are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that helps the user discover the core transformation principle for themselves without revealing the answer.\n\nBegin with a concise checklist (3-7 bullets) of what you will do; keep items conceptual, not implementation-level.\n\n---\n\n## Hint Generation Strategy\n1. **Compare** the input and output grids for each example. Identify the shared transformation pattern that allows the input grid to be converted into the output grid.\n2. **Identify the Core Principle**: Review the problem description and ground-truth solution to fully discern the key transformation rule. Break it down into its essential operations (e.g., object completion, pattern repetition, symmetry, gravity), paying close attention to properties such as object count, shapes, colors, sizes, symmetry, repetition, relative positioning, and broader grid-level patterns.\n3. **Craft a Targeted Hint**: Generate a hint that guides the user toward the core insight needed to solve the problem. The hint should assist the user during their attempt without revealing the solution.\n4. Structure each note using the template below:\n - **Description** (up to 3 sentences): Explain the concept, when and why it applies, and why it is effective. Include any relevant general formula or principle in its most general form.\n - **Example** (up to 6 sentences): Present a worked example covering all aspects of the description, using a simplified yet representative scenario (not necessarily from the current problem).\n - Optionally, include **Heuristics** or **Pitfalls** in the note where relevant.\n - Focus on methodologies and core principles over specific calculations or problem details.\n - Ensure each hint applies broadly—at least 80% of analogous problems.\n\nAfter generating a hint, verify that no specifics of the solution are revealed, and that the hint remains at the level of guiding the approach.\n\n### Output Format\nProduce a **sequence of 5** notes in the structure:\n<note1>\n<description>...</description>\n<example>...</example>\n</note1>\n<note2>\n<description>...</description>\n<example>...</example>\n</note2>\n...\n\n### Design Guidelines\n- Clarity: Use precise language and correct sentence structure.\n- Atomicity: Each note addresses one recognizable sub-problem.\n- Self-containment: All information needed to understand the idea and its application is within the note.\n- Generalizability: Avoid problem-specific details or variables.\n- Transferability: Notes should apply across a class of problems.\n- Distinctness: Each note addresses a distinct principle.\n\n---\n\n## Guidelines\n- **Guide, Don't Solve**: Illuminate the approach, not the answer. Emphasize what to observe or consider.\n- **Specific yet Abstract**: Use concrete grid details (e.g., \"note the relationship between the blue and red pixels\") to ground abstract patterns (e.g., \"think about one color containing another\").\n\nValidate your generated hint: confirm it is self-contained, actionable, and nondirective. If any aspect is too revealing, revise before finalizing.\n\n---\n\n## Inputs\n### Problem Description\nA full ARC problem, including input/output pairs for training and testing.\n\nYou will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n8 0 8 8 0 8 0 0 8 8 8 8 8 8 8 8 8 0 8 8 8\n0 0 8 8 8 0 8 8 8 8 8 8 8 8 8 8 0 0 8 8 8\n8 0 8 8 8 8 0 8 8 8 8 0 0 8 8 8 8 8 8 8 0\n8 8 8 8 8 8 8 8 8 8 8 8 8 0 8 8 8 8 8 8 8\n8 0 8 8 8 8 8 8 0 8 8 8 8 8 8 8 8 8 0 0 8\n5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 0 0 0\n0 0 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 0\n0 0 0 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n3 0 3 3 0 3 0 0 3 3 3 3 3 3 3 3 3 0 3 3 3\n0 0 3 3 3 0 3 3 3 3 3 3 3 3 3 3 0 3 3 3 3\n3 0 0 3 3 3 0 3 3 3 3 0 0 3 3 3 3 3 3 0 0\n3 3 3 3 3 3 3 3 3 0 3 3 3 0 3 3 3 3 3 3 3\n3 0 3 3 3 3 3 3 0 3 3 3 3 3 3 3 3 3 0 0 3\n```\n\n## Example 2\nInput:\n```\n2 2 2 2 1 4 4 4 4\n2 0 0 0 1 4 0 0 4\n0 0 0 2 1 4 4 4 0\n0 0 2 0 1 4 4 4 0\n0 0 0 0 1 4 0 0 0\n2 2 0 2 1 0 0 4 4\n0 2 2 0 1 0 4 0 4\n0 0 2 0 1 0 4 4 4\n2 0 0 2 1 0 4 4 4\n0 0 0 0 1 0 0 4 4\n2 2 2 0 1 0 4 4 0\n0 0 0 0 1 4 0 4 4\n2 0 2 2 1 4 4 4 0\n2 2 0 2 1 4 4 4 4\n0 2 0 0 1 0 4 4 0\n0 0 0 0 1 4 0 4 0\n0 2 0 2 1 4 4 0 4\n0 0 2 0 1 4 4 4 4\n```\n\nOutput:\n```\n0 0 0 0\n0 0 0 3\n3 3 3 3\n3 3 0 0\n3 0 0 0\n3 3 3 0\n0 0 3 3\n0 3 0 3\n3 3 3 0\n0 0 3 3\n3 0 0 0\n3 0 3 3\n0 3 0 3\n0 0 3 0\n0 0 3 0\n3 0 3 0\n3 0 0 0\n3 3 0 3\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 5\n0 0 0 0 0 0 5 0 0\n5 5 0 5 5 0 0 5 0\n0 0 0 5 5 5 5 0 5\n0 0 5 5 5 0 5 0 0\n0 5 5 0 0 0 0 0 0\n5 5 0 5 5 0 0 5 5\n0 5 0 5 0 0 5 5 5\n1 1 1 1 1 1 1 1 1\n4 4 4 4 4 4 4 4 0\n4 4 4 4 4 4 4 4 4\n4 4 0 0 0 4 4 4 4\n4 4 4 4 4 4 4 4 4\n4 4 0 4 4 4 4 4 0\n4 4 4 4 4 4 0 4 4\n4 4 4 4 4 4 4 4 4\n4 4 4 4 4 4 4 4 4\n```\n\nOutput:\n```\n3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 0 3 3\n0 0 0 3 3 3 3 0 3\n3 3 3 0 0 0 0 3 0\n3 3 3 0 0 3 0 3 0\n3 0 0 3 3 3 0 3 3\n0 0 3 0 0 3 3 0 0\n3 0 3 0 3 3 0 0 0\n```\n\n# Test Problem:\n```\n0 0 0 0 0 0 0 1 0 1 0\n0 1 1 1 1 0 0 0 0 1 1\n0 0 0 0 0 1 1 1 0 1 0\n0 0 1 0 1 1 1 1 0 1 0\n0 1 0 1 1 1 1 1 0 0 1\n1 0 0 1 1 1 0 0 0 1 0\n1 0 1 0 1 0 0 0 1 0 0\n5 5 5 5 5 5 5 5 5 5 5\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 6\n0 0 0 6 0 0 6 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 6 0\n0 0 0 0 6 0 0 0 0 0 0\n0 0 0 0 0 6 0 0 0 0 0\n```\n\n---\n\n\n# Generated Hint<|im_end|>\n<|im_start|>assistant\n"},"abstraction_prompt_length":{"kind":"number","value":2890,"string":"2,890"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>Look for a single column or row that is entirely one color and runs across the whole grid; that uniform stripe usually acts as a clear separator. When you find it, treat the grid as two parts on either side and use that stripe as the boundary between the two regions to compare.</description>\n<example>Imagine a grid where column 5 is every cell the same color from top to bottom. That column cleanly divides the grid into a left block and a right block; you should ignore the stripe itself and compare the left and right blocks as separate pieces.</example>\n</note1>\n\n<note2>\n<description>Compare the two blocks cell-by-cell at the same coordinates relative to the dividing line: for each position, check whether the left-side and right-side cells are equal. This simple equality test reveals where the two halves agree and where they disagree.</description>\n<example>For a 4×4 example with a vertical divider, check (0,0) vs (0,0) on the other side, (1,0) vs (1,0) on the other side, and so on. If both sides have the same color at that position, record a match; if they differ, record a mismatch.</example>\n</note2>\n\n<note3>\n<description>Decide which color to use as the output color: the examples consistently use a single non-background color for matches and the background color for mismatches. In other words, the output is a binary mask of agreement (one color) versus disagreement (background).</description>\n<example>If the two halves agree at many positions and disagree at others, create an output grid the same size where each cell is the chosen highlight color when the halves match, and the background color when they do not match.</example>\n</note3>\n\n<note4>\n<description>When the divider is horizontal, apply the same pairwise comparison to rows (left column vs right column) instead of columns. The orientation only changes which axis you compare; the rest of the logic remains identical.</description>\n<example>For a horizontal stripe, compare column 0 of the top block with column 0 of the bottom block, column 1 with column 1, etc. The result will be a mask showing where the top and bottom agree or disagree.</example>\n</note4>\n\n<note5>\n<description>Be careful with the background and edge cases: treat the divider as the boundary (do not include its cells in the comparison), and do not confuse a single-pixel stripe with a full separator. Also confirm which color is background before using it as the mismatch color.</description>\n<example>If the divider is a full column of one color, exclude that column when comparing halves; if the divider is only a single pixel, re-check whether a full uniform stripe exists first. If you accidentally include the stripe cells in the comparison, you will misclassify many positions.</example>\n</note5>","<note1>\n<description>Look for a full row or full column that is a single repeated color; that line usually acts as a divider. When present, it cleanly splits the grid into two subgrids and you should treat those two halves separately.</description>\n<example>Imagine a grid where row 5 is entirely blue; that blue row separates the grid into a top block (rows 1–4) and a bottom block (rows 6–end). Ignore the blue row itself and work with the two blocks independently.</example>\n</note1>\n\n<note2>\n<description>Decide which block to keep by checking the examples: the kept block is the one whose rows are more varied (contain non-background colors) compared to the other block. The chosen block is the one that shows the meaningful pattern to preserve.</description>\n<example>If the top block contains many colored pixels forming shapes while the bottom block is mostly background, then the top block is the meaningful half and you should keep that half; conversely, if the bottom block has many colored pixels, keep the bottom.</example>\n</note2>\n\n<note3>\n<description>After selecting the half, remove the divider and any completely background rows/columns from that half so the final grid is the minimal bounding rectangle that contains the pattern. This yields the output dimensions and preserves the pattern's relative layout.</description>\n<example>If you keep the top half but the first and last rows are all background, drop them; the remaining rows form a compact rectangle that exactly captures the pattern you need to output.</example>\n</note3>\n\n<note4>\n<description>Inside the selected rectangle, convert every cell that is not the background color into a single uniform marker color (the examples use a single new color for all non-background pixels). This normalizes the pattern so only shape and position matter.</description>\n<example>Suppose the chosen rectangle has several red and green pixels; replace all red and green with one chosen color (e.g., 3) so the output shows the same shapes but in a single consistent color.</example>\n</note4>\n\n<note5>\n<description>Finally, check that the output size matches the kept half and that no divider or stray rows/columns remain. If the kept block is not rectangular (e.g., two disconnected halves), apply the same removal rules to make it a compact rectangle before recoloring.</description>\n<example>If the kept block originally had extra empty rows/columns or was split into two parts, trim away empty rows/columns and merge the parts into one rectangle; then recolor non-background cells and confirm the dimensions and pattern match the examples.</example>\n</note5>","<note1>\n<description>Look for a horizontal divider: a row made entirely of one color that separates two blocks. This row is not part of the pattern and marks the boundary between two regions you should analyze separately.</description>\n<example>Imagine a grid where row 5 is every cell equal to color X; treat rows 1–4 and rows 6–end as two independent blocks. Ignore that full row when deciding which block to transform.</example>\n</note1>\n\n<note2>\n<description>Decide which block to transform by comparing block heights: choose the block that is narrower (fewer rows). In many tasks the output keeps the smaller block’s row count and mirrors the pattern from the larger block.</description>\n<example>If the top block has 5 rows and the bottom block has 11 rows, keep the top block as the output canvas and derive its pattern from the bottom block. If the bottom block is narrower, keep the bottom block as the canvas.</example>\n</note2>\n\n<note3>\n<description>When mapping the larger block’s pixels into the smaller canvas, preserve the column indices (left-to-right) but compress rows: place each non-background pixel of the larger block into the corresponding column of the smaller block, stacking them vertically in order.</description>\n<example>For a 2×4 larger block and a 3×4 smaller block, take the first non-background pixel in the larger block’s first row and put it into the smaller block’s first column; the next pixel (same column) goes into the second column, and so on. If the larger block has more rows than the smaller canvas, continue stacking the same column until the canvas is filled.</example>\n</note3>\n\n<note4>\n<description>Use a single, consistent color for all mapped non-background pixels in the output and treat background pixels (zeros) as blanks. The mapping should not change the relative horizontal arrangement—only the vertical stacking is compressed.</description>\n<example>If the larger block uses colors A and B, convert every mapped non-background cell to one chosen output color (e.g., 3). Leave cells that were background in the larger block as zeros in the smaller canvas.</example>\n</note4>\n\n<note5>\n<description>Check alignment and avoid common pitfalls: do not shift columns horizontally, do not rotate or mirror the pattern, and do not copy the divider row. If two blocks are equal in height, the examples typically use the bottom block as the source.</description>\n<example>After compressing, scan columns left-to-right and top-to-bottom to confirm each column’s non-zero cells are in the same vertical order as the source block. If a column in the source is entirely background, the output column should remain background.</example>\n</note5>","<note1>\n<description>Look for a full row or full column made of a single color that divides the grid into two rectangular regions. This divider is the key landmark that tells you which half to extract and transform.</description>\n<example>Imagine a grid where every cell in row 4 is color X. That row is a clear horizontal divider: the rows above it form one rectangle and the rows below form another. If instead you see a column of X, treat that as a vertical divider and split left vs. right.</example>\n</note1>\n\n<note2>\n<description>Choose the rectangle that contains the non-background objects (the pattern to transform). The other rectangle is usually a uniform background and is not altered by the transformation.</description>\n<example>If the left side has many colored pixels and the right side is mostly background, pick the left rectangle. If the top block contains scattered shapes and the bottom block is uniform, pick the top block. The chosen rectangle is the one you will operate on.</example>\n</note2>\n\n<note3>\n<description>Inside the chosen rectangle, map every non-zero (non-background) pixel to a single consistent marker color and every zero pixel to the background color. This converts the pattern into a two-color image while preserving shape and position.</description>\n<example>For instance, if the rectangle contains colors A, B and background 0, replace A and B by the same marker color M and leave 0 as background. The result is a binary mask (M vs 0) that shows the original pattern without its original hues.</example>\n</note3>\n\n<note4>\n<description>Do not alter the divider row/column or the other rectangle: keep them exactly as they were and preserve their orientation when you output the transformed rectangle. The output should be the transformed rectangle only, not the whole grid.</description>\n<example>If the divider was a horizontal line, the output should be the rectangle on one side of that line (without including the divider). If the divider was vertical, the output should be the left/right rectangle. Do not paste or rotate the divider into the output.</example>\n</note4>\n\n<note5>\n<description>When there are several candidate uniform rows/columns, prefer the one that is fully one color and that separates two distinct regions. If you are unsure which side contains the pattern, count non-background pixels on each side to decide.</description>\n<example>If you see two uniform rows but only the top uniform row separates a region with many colored pixels from a uniform background, choose that top row as the divider. If counts are close, use the divider that cleanly partitions the grid into two meaningful halves.</example>\n</note5>","<note1>\n<description>Look for a full row or column made of a single color that separates the grid into two equal-sized subgrids. That uniform line is the divider; everything above or below it belongs to one side and everything left or right belongs to the other side.</description>\n<example>Imagine a grid where column 6 is entirely color A. That column splits the grid into a left block (columns 1–5) and a right block (columns 7–11). You should treat each side independently rather than mixing pixels across the divider.</example>\n</note1>\n\n<note2>\n<description>Decide which subgrid to keep by comparing the two halves: choose the side that contains more non-background (non-zero) pixels. The side with the greater count of colored pixels is the one that will become the output grid.</description>\n<example>Suppose the left half has 20 colored pixels and the right half has 10; keep the left half because it is the richer side. If both halves are equally rich, consult the examples to see which side the training outputs prefer (often the side with the more complex shape).</example>\n</note2>\n\n<note3>\n<description>When you keep a half, preserve the same internal arrangement of colors and positions—do not rotate, reflect, or recolor pixels. The output grid should match the kept half exactly (same cell values and coordinates).</description>\n<example>If the kept half contains a small cluster of color B at certain coordinates, those same coordinates and values remain in the output; only the background (zeros) may be treated differently in the final step.</example>\n</note3>\n\n<note4>\n<description>After selecting the kept half, replace every background (zero) pixel inside that half with a single, uniform marker color (the same marker everywhere). This highlights the background while keeping the original colored pixels unchanged.</description>\n<example>In a kept half where zeros represent empty space, change every zero to a single color M so the empty areas are consistent and easy to see; leave any non-zero pixels as they were.</example>\n</note4>\n\n<note5>\n<description>Do not alter the shape or dimensions of the kept half—output exactly that subgrid with the marker applied. Also ensure you do not accidentally copy or merge pixels across the divider line.</description>\n<example>If the kept half is 6 rows by 9 columns, produce a 6×9 output with the marker applied to zeros; do not include the divider row/column or swap halves.</example>\n</note5>","<note1>\n<description>Look for a single full row or a single full column made of one non-background color; this continuous stripe usually acts as a deliberate divider. When you find such a stripe, it cleanly separates the grid into two rectangular regions (above/below or left/right) that are handled independently.</description>\n<example>Imagine a grid where one row is entirely color X while the rest vary. That row is not part of either side's pattern — it splits the grid into a top block and a bottom block. Treat those two blocks as separate canvases for the next steps.</example>\n</note1>\n\n<note2>\n<description>Choose the block on the side that contains the non-background pattern (i.e., the block with many colored pixels). Ignore the stripe and any block that is uniformly background; the chosen block is the one you will transform.</description>\n<example>If the top block has scattered colored pixels while the bottom block is mostly zeros, pick the top block as the active region. If instead the left block contains a pattern and the right is empty, pick the left block. The chosen block is the one that contains meaningful structure.</example>\n</note2>\n\n<note3>\n<description>Within the chosen block, compress repeated rows by merging identical consecutive rows into a single representative row. This preserves vertical structure but removes redundant repetition and often makes the pattern more compact and easier to reason about.</description>\n<example>For instance, three identical rows can be replaced by one identical row; two rows that differ become two rows. Apply this to every consecutive run of identical rows so that each distinct vertical pattern appears once.</example>\n</note3>\n\n<note4>\n<description>Apply the same row-compression to the other block (the one on the opposite side of the stripe) but do not alter the stripe itself. After both blocks are compressed, the two compressed blocks will be the same size and ready for comparison.</description>\n<example>If the left block compresses to 4 rows and the right block compresses to 4 rows, you now have two 4×N grids to align and compare. Keep the stripe as a divider — do not include it in the final output grid.</example>\n</note4>\n\n<note5>\n<description>Compare the two compressed blocks cell-by-cell and choose a simple binary rule to produce the final grid: one side is usually the pattern to keep (e.g., the side that contains the original non-background color) and the other side is converted to background. The output grid’s dimensions equal the compressed block size.</description>\n<example>If the top compressed block contains meaningful colored pixels and the bottom compressed block is mostly zeros, keep the top block’s colored pixels and replace the bottom block’s pixels with background (zeros). If the left block is the patterned side, keep the left block and convert the right block to background. A common rule is: keep the block that originally contained the non-background color and set the other block to background.</example>\n</note5>","<note1>\n<description>Look for a full row or full column that is a single color and spans the entire grid; such a continuous stripe usually acts as a deliberate divider that separates the image into two regions. This stripe is a reliable marker because it is uniform across the whole row/column and is distinct from scattered pixels.</description>\n<example>Imagine a 7×7 grid where column 4 is entirely blue while other columns contain mixed colors. That blue column is a clear divider: it cleanly separates left and right blocks and should be ignored when deciding which block to work with.</example>\n</note1>\n\n<note2>\n<description>After locating the divider, determine which side contains the meaningful pattern: the side with varied colors (shapes, blobs, or sparse pixels) is the one to keep; the other side is typically uniform background and can be discarded. This reduces the problem to a single rectangular block of interest.</description>\n<example>For instance, if the left block contains many colored pixels forming shapes and the right block is a solid background, choose the left block as the target region and ignore the solid block when producing the output.</example>\n</note2>\n\n<note3>\n<description>Extract the target rectangle exactly as it appears (same dimensions and internal arrangement) and preserve all original colors inside it—do not rotate, flip, or recolor it. The task is to present the pattern as-is, but with a single consistent color applied uniformly to the non-background cells.</description>\n<example>If the chosen rectangle is 5 rows by 4 columns with colored pixels and zeros, keep those 5×4 cells in the same positions and keep the zeros as background; you are not altering their arrangement or numeric values.</example>\n</note3>\n\n<note4>\n<description>Within the extracted rectangle, replace every non-background (non-zero) cell with one uniform accent color so the pattern becomes visible while leaving zeros untouched. The accent color is chosen so it is consistent across the output and different from the background and any original accent colors used.</description>\n<example>Suppose the rectangle contains several colored blobs and some zeros. Convert each colored cell to the same new color (for example, all non-zero cells become blue) and leave zeros as black; this makes the shapes easy to see without changing their layout.</example>\n</note4>\n\n<note5>\n<description>Do not include the divider itself in the output and do not attempt to merge or combine information from both sides. If there are multiple candidate stripes, prefer the full stripe that cleanly splits the grid; if the divider is ambiguous, choose the stripe that yields two clearly different blocks.</description>\n<example>If you find two uniform rows but only one cleanly separates a varied block from a uniform background, use that one. The final output should be the extracted rectangle with its internal pattern recolored uniformly and nothing else added.</example>\n</note5>","<note1>\n<description>Look for a full row or full column that is a single color and runs across the entire grid; that continuous line usually acts as a divider and splits the grid into two rectangular regions. This divider is not part of the pattern to keep — it separates the two areas you will compare.</description>\n<example>Imagine a 7×9 grid where column 4 is entirely color X; that column cleanly separates a left 3×9 block from a right 4×9 block. Treat those two blocks as the two halves to be processed, rather than treating the X column itself as a patterned region.</example>\n</note1>\n\n<note2>\n<description>After removing the divider, compare the two resulting rectangles cell-by-cell. The intended transformation is a one-to-one mapping between the two halves: each cell in one half corresponds to the cell in the same position in the other half.</description>\n<example>With a left 3×4 and a right 3×4 block, pair up (row 0, col 0) with (row 0, col 0), and so on. You should expect the same number of rows and columns in both halves so every position has a direct partner.</example>\n</note2>\n\n<note3>\n<description>Identify which half is the \"source\" and which is the \"target\" by looking for a clear, repeated, non-background shape or color on one side. The source is typically the half that contains the distinctive pattern; the target is the half that is mostly background or contains a different color.</description>\n<example>If the left half has many colored pixels arranged in a recognizable shape while the right half is mostly zeros, treat the left half as the source and the right half as the target. The distinctive shape on the source half indicates where to look for the rule.</example>\n</note3>\n\n<note4>\n<description>The core operation is to copy the source half into the target half: for each position, use the source's color if it is not the background color, otherwise use the target's background color. In short, propagate the source's non-background pixels into the target, leaving any target background cells unchanged.</description>\n<example>Suppose the source cell at (r,c) is color A (non-background) and the target cell at (r,c) is 0; the output cell becomes A. If the source cell is 0, the output cell stays 0. This preserves the shape of the source while filling the target accordingly.</example>\n</note4>\n\n<note5>\n<description>Keep the grid orientation and dimensions of the target half when producing the output; do not rotate, reflect, or change the size of the result. Also be careful to ignore the divider color when pairing cells — it should not be treated as a source or target cell.</description>\n<example>If the target half is 4 rows by 5 columns, your final output should be 4×5 and should be produced by mapping the source's values into the corresponding positions of that target half. A common pitfall is to accidentally include the divider in the mapping or to transpose the halves instead of copying them in place.</example>\n</note5>","<note1>\n<description>Look for a single column that is entirely one color; that column is a deliberate divider and should not be part of the region you analyze. It cleanly separates the grid into two independent subgrids. Treat that column as a boundary rather than as content to be copied.</description>\n<example>Imagine a 6×6 grid where column 3 is filled entirely with a single color; that column splits the grid into a 6×2 block on the left and a 6×2 block on the right. When solving, ignore that full column and consider the two halves separately.</example>\n</note1>\n<note2>\n<description>Compare the two halves cell-by-cell: the transformation often copies the left half onto the right half, but with a color substitution. That is, each cell on the right is set to the same position as the corresponding cell on the left, but its color is changed to a single target color. The spatial pattern (which cells are filled and which are empty) is preserved, only the color is mapped.</description>\n<example>For instance, if the left half has a 2×2 pattern of colored pixels and the right half is blank, the right half will end up with the same 2×2 pattern after the operation — the only difference is that the original colors on the right are replaced by one new color.</example>\n</note2>\n<note3>\n<description>Use the rightmost non-dividing column as the anchor for alignment: that column’s color in the input often determines which color should be used to fill the right half. In other words, the target fill color is taken from the last column that is not the full-color divider. This keeps the mapping consistent across examples.</description>\n<example>Suppose the divider is in the middle and the rightmost non-divider column is color X; after copying the left half to the right, replace every cell on the right with color X, preserving the positions of the copied pattern.</example>\n</note3>\n<note4>\n<description>Do not alter the left half itself — the operation is a copy-and-substitute applied only to the right half. Also do not include the divider column in the final output; the output grid should contain exactly the two blocks that were compared. This preserves the original left pattern while producing the transformed right pattern.</description>\n<example>If the left half contains several distinct colors and the right half is mostly background, the output will keep the left half as is and show the right half as the left half’s pattern recolored to the chosen target color, with the divider removed.</example>\n</note4>\n<note5>\n<description>Be careful with edge cases: if the divider is not centered, the two halves may be unequal in width; still align them by the divider column and copy the corresponding cells. Also ensure you pick the target color from the rightmost non-divider column (not from the divider or the other half). A common pitfall is accidentally including the divider when building the final grid.</description>\n<example>For example, if the divider is at column 4 and the right half is two columns wide, copy column 4+1 and 4+2 from the left into the right half and fill them with the rightmost non-divider color; the output will then be the two blocks aligned by the divider, with the divider excluded.</example>\n</note5>","<note1>\n<description>Look for a full-length row or column made of a single color that runs uninterrupted across the grid; this line usually acts as a divider. The divider is not part of the pattern to transform — it simply separates two regions.</description>\n<example>Imagine a 7×7 grid where row 4 is entirely color X; treat row 4 as a boundary and ignore it when deciding which block to change. In many tasks such a uniform row/column appears exactly once and is the natural split point.</example>\n</note1>\n\n<note2>\n<description>Partition the grid into two rectangular blocks on either side of the divider: one block is the area above the divider, the other is the area below it. Use the divider’s position to determine which block corresponds to each example output.</description>\n<example>If the divider is a horizontal line, the top block is all rows above it and the bottom block is all rows below it; if the divider is vertical, take the left and right blocks accordingly. The output will match the block on the same side as the examples show.</example>\n</note2>\n\n<note3>\n<description>Ignore the divider’s color and any other uniform bands that may lie on the opposite side; the transformation targets only the block on the side that contains the varied pattern (the colored pixels). Treat the divider and its color as irrelevant for the pixel-level edits.</description>\n<example>When one side is a solid stripe of color Y and the other side contains scattered colors, focus on the stripe side’s pattern. Do not include the stripe itself or other uniform regions when deciding which pixels to change.</example>\n</note3>\n\n<note4>\n<description>Within the chosen block, replace every non-background (non-zero) pixel with a single uniform output color while leaving background pixels (zeros) unchanged. The operation is a global recoloring of all pattern pixels in that block to one consistent color.</description>\n<example>For a block containing several colors scattered across it, change every colored pixel to the same new color (e.g., all non-zero cells become color Z) and keep zeros as zeros. The shapes and positions of the pixels remain identical — only their colors are standardized.</example>\n</note4>\n\n<note5>\n<description>After recoloring, return the transformed block as the final output (same dimensions as the chosen block). If there are multiple uniform rows/columns, prefer the one that cleanly splits the grid into two non-empty blocks and matches the examples’ orientation.</description>\n<example>If the divider splits the grid into two equal parts, output the recolored top block (or bottom, if the examples point to the opposite side). As a check, ensure the output grid size equals the chosen block and that only non-background pixels were changed to the single output color.</example>\n</note5>","<note1>\n<description>Look for a horizontal divider: a full row made entirely of one non-background color that runs across the entire width. That row usually separates two distinct regions and is not part of the pattern you should transform.</description>\n<example>Imagine a grid where every cell in row 6 is color X while rows above and below contain varied colors. Treat row 6 as a divider: do not include it when comparing or copying regions above and below.</example>\n</note1>\n\n<note2>\n<description>Partition the grid into two regions by the divider: everything strictly above the divider and everything strictly below it. These two regions typically have the same number of columns and are the areas you will compare.</description>\n<example>If the divider is at row 4, you get a top block of rows 1–3 and a bottom block of rows 5–end. Compare cell-by-cell across the same column indices for those two blocks.</example>\n</note2>\n\n<note3>\n<description>For each column, align the top and bottom cells and compare them. If the two aligned cells are the same color, keep that color in the output; if they differ, use the background color (0) for that position.</description>\n<example>For a given column, if the top cell is color A and the bottom cell is color A, place A in the output. If the top is A and the bottom is B (A ≠ B), place 0 in the output for that column.</example>\n</note3>\n\n<note4>\n<description>Preserve the original column order and the number of columns from the top block when constructing the output; do not transpose or change widths. The output will therefore have the same number of rows as the top block and the same number of columns as the top block.</description>\n<example>If the top block has 5 rows and 7 columns, your output should also have 5 rows and 7 columns, with each output row corresponding to one row of the top block.</example>\n</note4>\n\n<note5>\n<description>Be careful with edge cases: a divider may be a single color that also appears in the top or bottom block, and you must ignore the divider row itself. Also watch for columns where the top and bottom both contain background (0) — those should remain 0 in the output.</description>\n<example>If a color X appears both above and below the divider, it still functions as a divider and should be excluded from alignment; if a column has 0 above and 0 below, keep 0 in the output. A common pitfall is accidentally including the divider row in the comparison.</example>\n</note5>","<note1>\n<description>Look for a full-length uniform row or a full-length uniform column that acts as a divider. These complete lines are not part of the pattern to transform; they split the grid into two separate subgrids that should be handled independently.</description>\n<example>Imagine a 7×7 grid where row 4 is entirely color X; that row separates the top 3 rows from the bottom 3 rows. Treat the top and bottom as two separate 3×7 subgrids and do not include the X row itself when comparing or transforming.</example>\n</note1>\n\n<note2>\n<description>Decide which side to keep by comparing the two halves: the side with the larger number of non-background (non-zero) cells is the one to preserve. Counting only non-zero pixels avoids being misled by repeated background values.</description>\n<example>If the left half contains 20 non-zero pixels and the right half contains 10, choose the left half. If both counts are equal, use a consistent tie-breaker such as the half with more non-zero pixels in a particular column or the top half.</example>\n</note2>\n\n<note3>\n<description>Within the chosen half, compress repeated rows: collapse any two adjacent rows that are identical into a single row. This preserves vertical order but removes vertical redundancy while keeping the same number of columns.</description>\n<example>Given rows A, A, B, A in a 4-row half, compressing yields A, B, A (the two A's become one A). Do this for every contiguous sequence of identical rows across the half.</example>\n</note3>\n\n<note4>\n<description>Convert every non-background color in the compressed half to a single target color (the examples use 3), while leaving background zeros unchanged. This normalizes the pattern so only the shape and relative positions remain meaningful.</description>\n<example>If a compressed half contains colors {2,4,0}, replace 2→3 and 4→3 so the half becomes {3,3,0}. After this step, only the original 0s and the new 3s remain, preserving the original spatial layout.</example>\n</note4>\n\n<note5>\n<description>Return the final compressed half as the output grid with the same width and the number of rows equal to the compressed height. The output should reflect only the chosen half’s compressed, normalized pattern.</description>\n<example>If the chosen half was 6 rows by 8 columns and you collapsed it to 4 rows, produce a 4×8 output whose entries are either 0 or 3, showing the normalized compressed pattern.</example>\n</note5>","<note1>\n<description>Look for a single row or column that is entirely one color; that line usually acts as a divider separating two distinct regions. When you find such a uniform line, treat the grid as two independent subgrids (one on each side) and analyze them separately.</description>\n<example>Imagine a 7×7 grid where row 4 is all zeros; this row clearly splits the grid into a top 3×7 block and a bottom 3×7 block. You should ignore the uniform row and work on the two 3×7 blocks as two separate pieces to compare.</example>\n</note1>\n\n<note2>\n<description>Compare the two subgrids cell-by-cell using the same coordinates (top-left aligned). The transformation depends on whether a cell in the top block and the corresponding cell in the bottom block are the same color or not, so alignment is crucial.</description>\n<example>With two 3×4 blocks, check top(1,1) vs bottom(1,1), top(1,2) vs bottom(1,2), and so on across rows and columns. If top(1,2) and bottom(1,2) are both blue, they match; if one is blue and the other is black, they do not match.</example>\n</note2>\n\n<note3>\n<description>Use a simple binary rule: if the two corresponding cells are the same color, mark that position as “match” (often represented by one color); if they differ, mark it as “no match” (often represented by another color). This produces a compact binary mask of the comparison.</description>\n<example>For a 2×3 comparison, if top row is [A,B,A] and bottom row is [A,C,A], the comparison yields [match, no-match, match]. Converting those to two distinct colors gives the output pattern for that row.</example>\n</note3>\n\n<note4>\n<description>Choose the output size to match one of the subgrids (the same number of rows and columns). The output is not a merged or enlarged grid but a direct representation of the pairwise comparison at the same spatial resolution.</description>\n<example>If the divider splits the grid into two 4×6 blocks, your output should also be 4×6. Each output cell corresponds to one pair of cells in the two blocks, so you do not add or remove rows/columns.</example>\n</note4>\n\n<note5>\n<description>Handle edge cases consistently: ignore the divider row/column itself, and when comparing treat background (usually 0) as a color that can match or not match. Use a consistent tie-break (e.g., “same” when both are background) and pick two distinct output colors for match vs. no-match so the result is unambiguous.</description>\n<example>If the top and bottom both have a black pixel at the same position, that is a match (black = black). If one side has black and the other has a different color, it is a mismatch. Pick two output colors (e.g., one for match, one for mismatch) and apply them uniformly.</example>\n</note5>","<note1>\n<description>Look for a full row or full column made of a single color that runs uninterrupted from one edge to the opposite edge; such a uniform line usually acts as a divider. This divider cleanly separates the grid into two subgrids of equal size and should be ignored when comparing the two sides.</description>\n<example>Imagine a 10×10 grid where row 5 is entirely color X; that row splits the grid into a 4×10 top and a 4×10 bottom. Treat those two blocks as independent pieces to compare rather than treating the divider as part of the pattern.</example>\n</note1>\n\n<note2>\n<description>Compare the two subgrids cell-by-cell (aligned by their original positions). The transformation is based on whether each cell in the top matches the corresponding cell in the bottom: if they match, the output keeps the top cell; if they differ, the output uses a single contrasting color.</description>\n<example>For a 3×3 top and a 3×3 bottom, compare top(1,1) with bottom(1,1), top(1,2) with bottom(1,2), etc. If top(1,1) equals bottom(1,1), place top(1,1) in the output; otherwise place the special contrasting color there.</example>\n</note2>\n\n<note3>\n<description>Use the same contrasting color for every differing cell and keep the original color for every matching cell. The result is a compact binary-like map of matches vs. mismatches, preserving the top subgrid's shape and orientation.</description>\n<example>Suppose top is [[A,B],[C,D]] and bottom is [[A,E],[F,G]]. Using a contrasting color X, the output becomes [[A,X],[X,D]] because top(1,1) and top(2,2) matched, while top(1,2) and top(2,1) did not.</example>\n</note3>\n\n<note4>\n<description>When you find the divider, crop it out and work with the two equal-size subgrids; do not include the divider in either comparison or the final output. The output dimensions are exactly the size of one subgrid.</description>\n<example>If the divider is a horizontal line at index h, your top is rows 0..h-1 and bottom is rows h+1..end, and the output will have the same number of rows and columns as that top/bottom block.</example>\n</note4>\n\n<note5>\n<description>Watch for edge cases: ensure the divider truly spans the entire row/column (no gaps), and that both halves have the same dimensions. If the divider is not present or the halves are unequal, the pattern of comparison won't hold.</description>\n<example>If a candidate divider has a single different cell or the top and bottom have different heights, re-check for a true full-line divider before applying the match/difference rule—otherwise the comparison will be inconsistent.</example>\n</note5>","<note1>\n<description>Look for a full row or full column that is uniformly one color and spans the entire grid. That uniform stripe is a deliberate divider and should be treated as a boundary between two regions rather than part of either region's pattern.</description>\n<example>Imagine a 7×7 grid where row 4 is entirely color X from column 1 to column 7. That whole row clearly separates the grid into an upper 3×7 block and a lower 3×7 block; you should not include row 4 when deciding which block to keep.</example>\n</note1>\n\n<note2>\n<description>Decide which side of the divider to use by checking the examples: the chosen side is the one that contains the non-background (non-zero) pixels that form the pattern you need to preserve. Ignore the divider color and any other uniform stripe colors when making this choice.</description>\n<example>If the top block contains several colored pixels while the bottom block is mostly zeros, the top block is the region to keep. Conversely, if the bottom block contains the patterned pixels and the top is mostly zeros, keep the bottom block.</example>\n</note2>\n\n<note3>\n<description>Once you have selected a block, keep its exact size and orientation (same number of rows and columns). The output grid dimensions are simply the dimensions of that chosen block.</description>\n<example>If you chose the top block in a 7×7 grid, the output will be 3×7; if you chose the bottom block, the output will be 3×7 as well (same orientation and shape).</example>\n</note3>\n\n<note4>\n<description>Within the chosen block, map every non-background pixel to a single target color (commonly color 3 in these tasks) and leave every background (zero) pixel unchanged. Do not alter the relative arrangement of pixels inside the block.</description>\n<example>For a 3×3 block that originally had colored pixels at (1,1) and (3,2), recolor those two cells to the target color while leaving zeros as zeros; the two non-zero cells remain in the same relative positions.</example>\n</note4>\n\n<note5>\n<description>Watch for multiple uniform rows/columns and common pitfalls: prefer the divider that is continuous across the whole grid, and avoid confusing a uniform row/column that is part of the pattern with the separating stripe. If more than one full row/column exists, use the one that cleanly splits the grid into two meaningful regions.</description>\n<example>If you see two full rows of different uniform colors, pick the one that separates the patterned block from the mostly-empty block; do not include that divider when cropping. Also, do not recolor the divider itself — it should be discarded when forming the output.</example>\n</note5>","<note1>\n<description>Look for a single continuous row or column made of one color that runs the full length of the grid; that line usually marks a clear divider. When present, it cleanly separates the grid into two equal regions and indicates which half is the target for the output.</description>\n<example>Imagine a grid where row 5 is entirely color X while the rows above and below are different. That full row of X is a natural boundary: treat it as the divider and split the grid into the two blocks above and below it.</example>\n</note1>\n\n<note2>\n<description>After locating the divider, choose the region that is not the divider itself and not a uniform background. Typically this is the half that contains multiple colors or distinct objects; that half is the one you will transform.</description>\n<example>If the top half contains many colored pixels and the bottom half is mostly a single color, pick the top half as the source. If the left half contains several colors and the right half is uniform, pick the left half instead.</example>\n</note2>\n\n<note3>\n<description>Within the chosen region, collapse all non-background colors into one uniform color while keeping the same arrangement of pixels. In other words, replace every non-zero cell by a single target color and leave zero cells unchanged.</description>\n<example>Suppose the chosen region has colors A, B and C with background 0; convert every A, B and C to color Y so the pattern of non-zero positions stays the same but all colored pixels become the same color.</example>\n</note3>\n\n<note4>\n<description>Keep the original size and orientation of the chosen region: the output should be a grid with the same number of rows and columns as that region. Do not rotate, flip, or otherwise alter the layout of the region when producing the result.</description>\n<example>If you selected the left half of a 6×10 grid (3 columns wide), your output should be a 6×3 grid with the same row order and column order as that half.</example>\n</note4>\n\n<note5>\n<description>Use a single consistent replacement color for all non-background cells in the chosen region (do not use the divider’s color). Choose a color not present in the input (or use a color distinct from the divider) so the transformed region is visually distinct from the original background and divider.</description>\n<example>If the input uses colors {0,2,4} and the divider uses color 5, pick a color not in {0,2,4,5} (for example, color 3) and fill every non-zero cell of the chosen region with that one color while leaving zeros as background.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Look for a single column or row that is entirely one color and runs across the whole grid; that uniform stripe usually acts as a clear separator. When you find it, treat the grid as two parts on either side and use that stripe as the boundary between the two regions to compare.</description>\\n<example>Imagine a grid where column 5 is every cell the same color from top to bottom. That column cleanly divides the grid into a left block and a right block; you should ignore the stripe itself and compare the left and right blocks as separate pieces.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the two blocks cell-by-cell at the same coordinates relative to the dividing line: for each position, check whether the left-side and right-side cells are equal. This simple equality test reveals where the two halves agree and where they disagree.</description>\\n<example>For a 4×4 example with a vertical divider, check (0,0) vs (0,0) on the other side, (1,0) vs (1,0) on the other side, and so on. If both sides have the same color at that position, record a match; if they differ, record a mismatch.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide which color to use as the output color: the examples consistently use a single non-background color for matches and the background color for mismatches. In other words, the output is a binary mask of agreement (one color) versus disagreement (background).</description>\\n<example>If the two halves agree at many positions and disagree at others, create an output grid the same size where each cell is the chosen highlight color when the halves match, and the background color when they do not match.</example>\\n</note3>\\n\\n<note4>\\n<description>When the divider is horizontal, apply the same pairwise comparison to rows (left column vs right column) instead of columns. The orientation only changes which axis you compare; the rest of the logic remains identical.</description>\\n<example>For a horizontal stripe, compare column 0 of the top block with column 0 of the bottom block, column 1 with column 1, etc. The result will be a mask showing where the top and bottom agree or disagree.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful with the background and edge cases: treat the divider as the boundary (do not include its cells in the comparison), and do not confuse a single-pixel stripe with a full separator. Also confirm which color is background before using it as the mismatch color.</description>\\n<example>If the divider is a full column of one color, exclude that column when comparing halves; if the divider is only a single pixel, re-check whether a full uniform stripe exists first. If you accidentally include the stripe cells in the comparison, you will misclassify many positions.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a full row or full column that is a single repeated color; that line usually acts as a divider. When present, it cleanly splits the grid into two subgrids and you should treat those two halves separately.</description>\\n<example>Imagine a grid where row 5 is entirely blue; that blue row separates the grid into a top block (rows 1–4) and a bottom block (rows 6–end). Ignore the blue row itself and work with the two blocks independently.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide which block to keep by checking the examples: the kept block is the one whose rows are more varied (contain non-background colors) compared to the other block. The chosen block is the one that shows the meaningful pattern to preserve.</description>\\n<example>If the top block contains many colored pixels forming shapes while the bottom block is mostly background, then the top block is the meaningful half and you should keep that half; conversely, if the bottom block has many colored pixels, keep the bottom.</example>\\n</note2>\\n\\n<note3>\\n<description>After selecting the half, remove the divider and any completely background rows/columns from that half so the final grid is the minimal bounding rectangle that contains the pattern. This yields the output dimensions and preserves the pattern's relative layout.</description>\\n<example>If you keep the top half but the first and last rows are all background, drop them; the remaining rows form a compact rectangle that exactly captures the pattern you need to output.</example>\\n</note3>\\n\\n<note4>\\n<description>Inside the selected rectangle, convert every cell that is not the background color into a single uniform marker color (the examples use a single new color for all non-background pixels). This normalizes the pattern so only shape and position matter.</description>\\n<example>Suppose the chosen rectangle has several red and green pixels; replace all red and green with one chosen color (e.g., 3) so the output shows the same shapes but in a single consistent color.</example>\\n</note4>\\n\\n<note5>\\n<description>Finally, check that the output size matches the kept half and that no divider or stray rows/columns remain. If the kept block is not rectangular (e.g., two disconnected halves), apply the same removal rules to make it a compact rectangle before recoloring.</description>\\n<example>If the kept block originally had extra empty rows/columns or was split into two parts, trim away empty rows/columns and merge the parts into one rectangle; then recolor non-background cells and confirm the dimensions and pattern match the examples.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a horizontal divider: a row made entirely of one color that separates two blocks. This row is not part of the pattern and marks the boundary between two regions you should analyze separately.</description>\\n<example>Imagine a grid where row 5 is every cell equal to color X; treat rows 1–4 and rows 6–end as two independent blocks. Ignore that full row when deciding which block to transform.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide which block to transform by comparing block heights: choose the block that is narrower (fewer rows). In many tasks the output keeps the smaller block’s row count and mirrors the pattern from the larger block.</description>\\n<example>If the top block has 5 rows and the bottom block has 11 rows, keep the top block as the output canvas and derive its pattern from the bottom block. If the bottom block is narrower, keep the bottom block as the canvas.</example>\\n</note2>\\n\\n<note3>\\n<description>When mapping the larger block’s pixels into the smaller canvas, preserve the column indices (left-to-right) but compress rows: place each non-background pixel of the larger block into the corresponding column of the smaller block, stacking them vertically in order.</description>\\n<example>For a 2×4 larger block and a 3×4 smaller block, take the first non-background pixel in the larger block’s first row and put it into the smaller block’s first column; the next pixel (same column) goes into the second column, and so on. If the larger block has more rows than the smaller canvas, continue stacking the same column until the canvas is filled.</example>\\n</note3>\\n\\n<note4>\\n<description>Use a single, consistent color for all mapped non-background pixels in the output and treat background pixels (zeros) as blanks. The mapping should not change the relative horizontal arrangement—only the vertical stacking is compressed.</description>\\n<example>If the larger block uses colors A and B, convert every mapped non-background cell to one chosen output color (e.g., 3). Leave cells that were background in the larger block as zeros in the smaller canvas.</example>\\n</note4>\\n\\n<note5>\\n<description>Check alignment and avoid common pitfalls: do not shift columns horizontally, do not rotate or mirror the pattern, and do not copy the divider row. If two blocks are equal in height, the examples typically use the bottom block as the source.</description>\\n<example>After compressing, scan columns left-to-right and top-to-bottom to confirm each column’s non-zero cells are in the same vertical order as the source block. If a column in the source is entirely background, the output column should remain background.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a full row or full column made of a single color that divides the grid into two rectangular regions. This divider is the key landmark that tells you which half to extract and transform.</description>\\n<example>Imagine a grid where every cell in row 4 is color X. That row is a clear horizontal divider: the rows above it form one rectangle and the rows below form another. If instead you see a column of X, treat that as a vertical divider and split left vs. right.</example>\\n</note1>\\n\\n<note2>\\n<description>Choose the rectangle that contains the non-background objects (the pattern to transform). The other rectangle is usually a uniform background and is not altered by the transformation.</description>\\n<example>If the left side has many colored pixels and the right side is mostly background, pick the left rectangle. If the top block contains scattered shapes and the bottom block is uniform, pick the top block. The chosen rectangle is the one you will operate on.</example>\\n</note2>\\n\\n<note3>\\n<description>Inside the chosen rectangle, map every non-zero (non-background) pixel to a single consistent marker color and every zero pixel to the background color. This converts the pattern into a two-color image while preserving shape and position.</description>\\n<example>For instance, if the rectangle contains colors A, B and background 0, replace A and B by the same marker color M and leave 0 as background. The result is a binary mask (M vs 0) that shows the original pattern without its original hues.</example>\\n</note3>\\n\\n<note4>\\n<description>Do not alter the divider row/column or the other rectangle: keep them exactly as they were and preserve their orientation when you output the transformed rectangle. The output should be the transformed rectangle only, not the whole grid.</description>\\n<example>If the divider was a horizontal line, the output should be the rectangle on one side of that line (without including the divider). If the divider was vertical, the output should be the left/right rectangle. Do not paste or rotate the divider into the output.</example>\\n</note4>\\n\\n<note5>\\n<description>When there are several candidate uniform rows/columns, prefer the one that is fully one color and that separates two distinct regions. If you are unsure which side contains the pattern, count non-background pixels on each side to decide.</description>\\n<example>If you see two uniform rows but only the top uniform row separates a region with many colored pixels from a uniform background, choose that top row as the divider. If counts are close, use the divider that cleanly partitions the grid into two meaningful halves.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a full row or column made of a single color that separates the grid into two equal-sized subgrids. That uniform line is the divider; everything above or below it belongs to one side and everything left or right belongs to the other side.</description>\\n<example>Imagine a grid where column 6 is entirely color A. That column splits the grid into a left block (columns 1–5) and a right block (columns 7–11). You should treat each side independently rather than mixing pixels across the divider.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide which subgrid to keep by comparing the two halves: choose the side that contains more non-background (non-zero) pixels. The side with the greater count of colored pixels is the one that will become the output grid.</description>\\n<example>Suppose the left half has 20 colored pixels and the right half has 10; keep the left half because it is the richer side. If both halves are equally rich, consult the examples to see which side the training outputs prefer (often the side with the more complex shape).</example>\\n</note2>\\n\\n<note3>\\n<description>When you keep a half, preserve the same internal arrangement of colors and positions—do not rotate, reflect, or recolor pixels. The output grid should match the kept half exactly (same cell values and coordinates).</description>\\n<example>If the kept half contains a small cluster of color B at certain coordinates, those same coordinates and values remain in the output; only the background (zeros) may be treated differently in the final step.</example>\\n</note3>\\n\\n<note4>\\n<description>After selecting the kept half, replace every background (zero) pixel inside that half with a single, uniform marker color (the same marker everywhere). This highlights the background while keeping the original colored pixels unchanged.</description>\\n<example>In a kept half where zeros represent empty space, change every zero to a single color M so the empty areas are consistent and easy to see; leave any non-zero pixels as they were.</example>\\n</note4>\\n\\n<note5>\\n<description>Do not alter the shape or dimensions of the kept half—output exactly that subgrid with the marker applied. Also ensure you do not accidentally copy or merge pixels across the divider line.</description>\\n<example>If the kept half is 6 rows by 9 columns, produce a 6×9 output with the marker applied to zeros; do not include the divider row/column or swap halves.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single full row or a single full column made of one non-background color; this continuous stripe usually acts as a deliberate divider. When you find such a stripe, it cleanly separates the grid into two rectangular regions (above/below or left/right) that are handled independently.</description>\\n<example>Imagine a grid where one row is entirely color X while the rest vary. That row is not part of either side's pattern — it splits the grid into a top block and a bottom block. Treat those two blocks as separate canvases for the next steps.</example>\\n</note1>\\n\\n<note2>\\n<description>Choose the block on the side that contains the non-background pattern (i.e., the block with many colored pixels). Ignore the stripe and any block that is uniformly background; the chosen block is the one you will transform.</description>\\n<example>If the top block has scattered colored pixels while the bottom block is mostly zeros, pick the top block as the active region. If instead the left block contains a pattern and the right is empty, pick the left block. The chosen block is the one that contains meaningful structure.</example>\\n</note2>\\n\\n<note3>\\n<description>Within the chosen block, compress repeated rows by merging identical consecutive rows into a single representative row. This preserves vertical structure but removes redundant repetition and often makes the pattern more compact and easier to reason about.</description>\\n<example>For instance, three identical rows can be replaced by one identical row; two rows that differ become two rows. Apply this to every consecutive run of identical rows so that each distinct vertical pattern appears once.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the same row-compression to the other block (the one on the opposite side of the stripe) but do not alter the stripe itself. After both blocks are compressed, the two compressed blocks will be the same size and ready for comparison.</description>\\n<example>If the left block compresses to 4 rows and the right block compresses to 4 rows, you now have two 4×N grids to align and compare. Keep the stripe as a divider — do not include it in the final output grid.</example>\\n</note4>\\n\\n<note5>\\n<description>Compare the two compressed blocks cell-by-cell and choose a simple binary rule to produce the final grid: one side is usually the pattern to keep (e.g., the side that contains the original non-background color) and the other side is converted to background. The output grid’s dimensions equal the compressed block size.</description>\\n<example>If the top compressed block contains meaningful colored pixels and the bottom compressed block is mostly zeros, keep the top block’s colored pixels and replace the bottom block’s pixels with background (zeros). If the left block is the patterned side, keep the left block and convert the right block to background. A common rule is: keep the block that originally contained the non-background color and set the other block to background.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a full row or full column that is a single color and spans the entire grid; such a continuous stripe usually acts as a deliberate divider that separates the image into two regions. This stripe is a reliable marker because it is uniform across the whole row/column and is distinct from scattered pixels.</description>\\n<example>Imagine a 7×7 grid where column 4 is entirely blue while other columns contain mixed colors. That blue column is a clear divider: it cleanly separates left and right blocks and should be ignored when deciding which block to work with.</example>\\n</note1>\\n\\n<note2>\\n<description>After locating the divider, determine which side contains the meaningful pattern: the side with varied colors (shapes, blobs, or sparse pixels) is the one to keep; the other side is typically uniform background and can be discarded. This reduces the problem to a single rectangular block of interest.</description>\\n<example>For instance, if the left block contains many colored pixels forming shapes and the right block is a solid background, choose the left block as the target region and ignore the solid block when producing the output.</example>\\n</note2>\\n\\n<note3>\\n<description>Extract the target rectangle exactly as it appears (same dimensions and internal arrangement) and preserve all original colors inside it—do not rotate, flip, or recolor it. The task is to present the pattern as-is, but with a single consistent color applied uniformly to the non-background cells.</description>\\n<example>If the chosen rectangle is 5 rows by 4 columns with colored pixels and zeros, keep those 5×4 cells in the same positions and keep the zeros as background; you are not altering their arrangement or numeric values.</example>\\n</note3>\\n\\n<note4>\\n<description>Within the extracted rectangle, replace every non-background (non-zero) cell with one uniform accent color so the pattern becomes visible while leaving zeros untouched. The accent color is chosen so it is consistent across the output and different from the background and any original accent colors used.</description>\\n<example>Suppose the rectangle contains several colored blobs and some zeros. Convert each colored cell to the same new color (for example, all non-zero cells become blue) and leave zeros as black; this makes the shapes easy to see without changing their layout.</example>\\n</note4>\\n\\n<note5>\\n<description>Do not include the divider itself in the output and do not attempt to merge or combine information from both sides. If there are multiple candidate stripes, prefer the full stripe that cleanly splits the grid; if the divider is ambiguous, choose the stripe that yields two clearly different blocks.</description>\\n<example>If you find two uniform rows but only one cleanly separates a varied block from a uniform background, use that one. The final output should be the extracted rectangle with its internal pattern recolored uniformly and nothing else added.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a full row or full column that is a single color and runs across the entire grid; that continuous line usually acts as a divider and splits the grid into two rectangular regions. This divider is not part of the pattern to keep — it separates the two areas you will compare.</description>\\n<example>Imagine a 7×9 grid where column 4 is entirely color X; that column cleanly separates a left 3×9 block from a right 4×9 block. Treat those two blocks as the two halves to be processed, rather than treating the X column itself as a patterned region.</example>\\n</note1>\\n\\n<note2>\\n<description>After removing the divider, compare the two resulting rectangles cell-by-cell. The intended transformation is a one-to-one mapping between the two halves: each cell in one half corresponds to the cell in the same position in the other half.</description>\\n<example>With a left 3×4 and a right 3×4 block, pair up (row 0, col 0) with (row 0, col 0), and so on. You should expect the same number of rows and columns in both halves so every position has a direct partner.</example>\\n</note2>\\n\\n<note3>\\n<description>Identify which half is the \\\"source\\\" and which is the \\\"target\\\" by looking for a clear, repeated, non-background shape or color on one side. The source is typically the half that contains the distinctive pattern; the target is the half that is mostly background or contains a different color.</description>\\n<example>If the left half has many colored pixels arranged in a recognizable shape while the right half is mostly zeros, treat the left half as the source and the right half as the target. The distinctive shape on the source half indicates where to look for the rule.</example>\\n</note3>\\n\\n<note4>\\n<description>The core operation is to copy the source half into the target half: for each position, use the source's color if it is not the background color, otherwise use the target's background color. In short, propagate the source's non-background pixels into the target, leaving any target background cells unchanged.</description>\\n<example>Suppose the source cell at (r,c) is color A (non-background) and the target cell at (r,c) is 0; the output cell becomes A. If the source cell is 0, the output cell stays 0. This preserves the shape of the source while filling the target accordingly.</example>\\n</note4>\\n\\n<note5>\\n<description>Keep the grid orientation and dimensions of the target half when producing the output; do not rotate, reflect, or change the size of the result. Also be careful to ignore the divider color when pairing cells — it should not be treated as a source or target cell.</description>\\n<example>If the target half is 4 rows by 5 columns, your final output should be 4×5 and should be produced by mapping the source's values into the corresponding positions of that target half. A common pitfall is to accidentally include the divider in the mapping or to transpose the halves instead of copying them in place.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single column that is entirely one color; that column is a deliberate divider and should not be part of the region you analyze. It cleanly separates the grid into two independent subgrids. Treat that column as a boundary rather than as content to be copied.</description>\\n<example>Imagine a 6×6 grid where column 3 is filled entirely with a single color; that column splits the grid into a 6×2 block on the left and a 6×2 block on the right. When solving, ignore that full column and consider the two halves separately.</example>\\n</note1>\\n<note2>\\n<description>Compare the two halves cell-by-cell: the transformation often copies the left half onto the right half, but with a color substitution. That is, each cell on the right is set to the same position as the corresponding cell on the left, but its color is changed to a single target color. The spatial pattern (which cells are filled and which are empty) is preserved, only the color is mapped.</description>\\n<example>For instance, if the left half has a 2×2 pattern of colored pixels and the right half is blank, the right half will end up with the same 2×2 pattern after the operation — the only difference is that the original colors on the right are replaced by one new color.</example>\\n</note2>\\n<note3>\\n<description>Use the rightmost non-dividing column as the anchor for alignment: that column’s color in the input often determines which color should be used to fill the right half. In other words, the target fill color is taken from the last column that is not the full-color divider. This keeps the mapping consistent across examples.</description>\\n<example>Suppose the divider is in the middle and the rightmost non-divider column is color X; after copying the left half to the right, replace every cell on the right with color X, preserving the positions of the copied pattern.</example>\\n</note3>\\n<note4>\\n<description>Do not alter the left half itself — the operation is a copy-and-substitute applied only to the right half. Also do not include the divider column in the final output; the output grid should contain exactly the two blocks that were compared. This preserves the original left pattern while producing the transformed right pattern.</description>\\n<example>If the left half contains several distinct colors and the right half is mostly background, the output will keep the left half as is and show the right half as the left half’s pattern recolored to the chosen target color, with the divider removed.</example>\\n</note4>\\n<note5>\\n<description>Be careful with edge cases: if the divider is not centered, the two halves may be unequal in width; still align them by the divider column and copy the corresponding cells. Also ensure you pick the target color from the rightmost non-divider column (not from the divider or the other half). A common pitfall is accidentally including the divider when building the final grid.</description>\\n<example>For example, if the divider is at column 4 and the right half is two columns wide, copy column 4+1 and 4+2 from the left into the right half and fill them with the rightmost non-divider color; the output will then be the two blocks aligned by the divider, with the divider excluded.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a full-length row or column made of a single color that runs uninterrupted across the grid; this line usually acts as a divider. The divider is not part of the pattern to transform — it simply separates two regions.</description>\\n<example>Imagine a 7×7 grid where row 4 is entirely color X; treat row 4 as a boundary and ignore it when deciding which block to change. In many tasks such a uniform row/column appears exactly once and is the natural split point.</example>\\n</note1>\\n\\n<note2>\\n<description>Partition the grid into two rectangular blocks on either side of the divider: one block is the area above the divider, the other is the area below it. Use the divider’s position to determine which block corresponds to each example output.</description>\\n<example>If the divider is a horizontal line, the top block is all rows above it and the bottom block is all rows below it; if the divider is vertical, take the left and right blocks accordingly. The output will match the block on the same side as the examples show.</example>\\n</note2>\\n\\n<note3>\\n<description>Ignore the divider’s color and any other uniform bands that may lie on the opposite side; the transformation targets only the block on the side that contains the varied pattern (the colored pixels). Treat the divider and its color as irrelevant for the pixel-level edits.</description>\\n<example>When one side is a solid stripe of color Y and the other side contains scattered colors, focus on the stripe side’s pattern. Do not include the stripe itself or other uniform regions when deciding which pixels to change.</example>\\n</note3>\\n\\n<note4>\\n<description>Within the chosen block, replace every non-background (non-zero) pixel with a single uniform output color while leaving background pixels (zeros) unchanged. The operation is a global recoloring of all pattern pixels in that block to one consistent color.</description>\\n<example>For a block containing several colors scattered across it, change every colored pixel to the same new color (e.g., all non-zero cells become color Z) and keep zeros as zeros. The shapes and positions of the pixels remain identical — only their colors are standardized.</example>\\n</note4>\\n\\n<note5>\\n<description>After recoloring, return the transformed block as the final output (same dimensions as the chosen block). If there are multiple uniform rows/columns, prefer the one that cleanly splits the grid into two non-empty blocks and matches the examples’ orientation.</description>\\n<example>If the divider splits the grid into two equal parts, output the recolored top block (or bottom, if the examples point to the opposite side). As a check, ensure the output grid size equals the chosen block and that only non-background pixels were changed to the single output color.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a horizontal divider: a full row made entirely of one non-background color that runs across the entire width. That row usually separates two distinct regions and is not part of the pattern you should transform.</description>\\n<example>Imagine a grid where every cell in row 6 is color X while rows above and below contain varied colors. Treat row 6 as a divider: do not include it when comparing or copying regions above and below.</example>\\n</note1>\\n\\n<note2>\\n<description>Partition the grid into two regions by the divider: everything strictly above the divider and everything strictly below it. These two regions typically have the same number of columns and are the areas you will compare.</description>\\n<example>If the divider is at row 4, you get a top block of rows 1–3 and a bottom block of rows 5–end. Compare cell-by-cell across the same column indices for those two blocks.</example>\\n</note2>\\n\\n<note3>\\n<description>For each column, align the top and bottom cells and compare them. If the two aligned cells are the same color, keep that color in the output; if they differ, use the background color (0) for that position.</description>\\n<example>For a given column, if the top cell is color A and the bottom cell is color A, place A in the output. If the top is A and the bottom is B (A ≠ B), place 0 in the output for that column.</example>\\n</note3>\\n\\n<note4>\\n<description>Preserve the original column order and the number of columns from the top block when constructing the output; do not transpose or change widths. The output will therefore have the same number of rows as the top block and the same number of columns as the top block.</description>\\n<example>If the top block has 5 rows and 7 columns, your output should also have 5 rows and 7 columns, with each output row corresponding to one row of the top block.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful with edge cases: a divider may be a single color that also appears in the top or bottom block, and you must ignore the divider row itself. Also watch for columns where the top and bottom both contain background (0) — those should remain 0 in the output.</description>\\n<example>If a color X appears both above and below the divider, it still functions as a divider and should be excluded from alignment; if a column has 0 above and 0 below, keep 0 in the output. A common pitfall is accidentally including the divider row in the comparison.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a full-length uniform row or a full-length uniform column that acts as a divider. These complete lines are not part of the pattern to transform; they split the grid into two separate subgrids that should be handled independently.</description>\\n<example>Imagine a 7×7 grid where row 4 is entirely color X; that row separates the top 3 rows from the bottom 3 rows. Treat the top and bottom as two separate 3×7 subgrids and do not include the X row itself when comparing or transforming.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide which side to keep by comparing the two halves: the side with the larger number of non-background (non-zero) cells is the one to preserve. Counting only non-zero pixels avoids being misled by repeated background values.</description>\\n<example>If the left half contains 20 non-zero pixels and the right half contains 10, choose the left half. If both counts are equal, use a consistent tie-breaker such as the half with more non-zero pixels in a particular column or the top half.</example>\\n</note2>\\n\\n<note3>\\n<description>Within the chosen half, compress repeated rows: collapse any two adjacent rows that are identical into a single row. This preserves vertical order but removes vertical redundancy while keeping the same number of columns.</description>\\n<example>Given rows A, A, B, A in a 4-row half, compressing yields A, B, A (the two A's become one A). Do this for every contiguous sequence of identical rows across the half.</example>\\n</note3>\\n\\n<note4>\\n<description>Convert every non-background color in the compressed half to a single target color (the examples use 3), while leaving background zeros unchanged. This normalizes the pattern so only the shape and relative positions remain meaningful.</description>\\n<example>If a compressed half contains colors {2,4,0}, replace 2→3 and 4→3 so the half becomes {3,3,0}. After this step, only the original 0s and the new 3s remain, preserving the original spatial layout.</example>\\n</note4>\\n\\n<note5>\\n<description>Return the final compressed half as the output grid with the same width and the number of rows equal to the compressed height. The output should reflect only the chosen half’s compressed, normalized pattern.</description>\\n<example>If the chosen half was 6 rows by 8 columns and you collapsed it to 4 rows, produce a 4×8 output whose entries are either 0 or 3, showing the normalized compressed pattern.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single row or column that is entirely one color; that line usually acts as a divider separating two distinct regions. When you find such a uniform line, treat the grid as two independent subgrids (one on each side) and analyze them separately.</description>\\n<example>Imagine a 7×7 grid where row 4 is all zeros; this row clearly splits the grid into a top 3×7 block and a bottom 3×7 block. You should ignore the uniform row and work on the two 3×7 blocks as two separate pieces to compare.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the two subgrids cell-by-cell using the same coordinates (top-left aligned). The transformation depends on whether a cell in the top block and the corresponding cell in the bottom block are the same color or not, so alignment is crucial.</description>\\n<example>With two 3×4 blocks, check top(1,1) vs bottom(1,1), top(1,2) vs bottom(1,2), and so on across rows and columns. If top(1,2) and bottom(1,2) are both blue, they match; if one is blue and the other is black, they do not match.</example>\\n</note2>\\n\\n<note3>\\n<description>Use a simple binary rule: if the two corresponding cells are the same color, mark that position as “match” (often represented by one color); if they differ, mark it as “no match” (often represented by another color). This produces a compact binary mask of the comparison.</description>\\n<example>For a 2×3 comparison, if top row is [A,B,A] and bottom row is [A,C,A], the comparison yields [match, no-match, match]. Converting those to two distinct colors gives the output pattern for that row.</example>\\n</note3>\\n\\n<note4>\\n<description>Choose the output size to match one of the subgrids (the same number of rows and columns). The output is not a merged or enlarged grid but a direct representation of the pairwise comparison at the same spatial resolution.</description>\\n<example>If the divider splits the grid into two 4×6 blocks, your output should also be 4×6. Each output cell corresponds to one pair of cells in the two blocks, so you do not add or remove rows/columns.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle edge cases consistently: ignore the divider row/column itself, and when comparing treat background (usually 0) as a color that can match or not match. Use a consistent tie-break (e.g., “same” when both are background) and pick two distinct output colors for match vs. no-match so the result is unambiguous.</description>\\n<example>If the top and bottom both have a black pixel at the same position, that is a match (black = black). If one side has black and the other has a different color, it is a mismatch. Pick two output colors (e.g., one for match, one for mismatch) and apply them uniformly.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a full row or full column made of a single color that runs uninterrupted from one edge to the opposite edge; such a uniform line usually acts as a divider. This divider cleanly separates the grid into two subgrids of equal size and should be ignored when comparing the two sides.</description>\\n<example>Imagine a 10×10 grid where row 5 is entirely color X; that row splits the grid into a 4×10 top and a 4×10 bottom. Treat those two blocks as independent pieces to compare rather than treating the divider as part of the pattern.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the two subgrids cell-by-cell (aligned by their original positions). The transformation is based on whether each cell in the top matches the corresponding cell in the bottom: if they match, the output keeps the top cell; if they differ, the output uses a single contrasting color.</description>\\n<example>For a 3×3 top and a 3×3 bottom, compare top(1,1) with bottom(1,1), top(1,2) with bottom(1,2), etc. If top(1,1) equals bottom(1,1), place top(1,1) in the output; otherwise place the special contrasting color there.</example>\\n</note2>\\n\\n<note3>\\n<description>Use the same contrasting color for every differing cell and keep the original color for every matching cell. The result is a compact binary-like map of matches vs. mismatches, preserving the top subgrid's shape and orientation.</description>\\n<example>Suppose top is [[A,B],[C,D]] and bottom is [[A,E],[F,G]]. Using a contrasting color X, the output becomes [[A,X],[X,D]] because top(1,1) and top(2,2) matched, while top(1,2) and top(2,1) did not.</example>\\n</note3>\\n\\n<note4>\\n<description>When you find the divider, crop it out and work with the two equal-size subgrids; do not include the divider in either comparison or the final output. The output dimensions are exactly the size of one subgrid.</description>\\n<example>If the divider is a horizontal line at index h, your top is rows 0..h-1 and bottom is rows h+1..end, and the output will have the same number of rows and columns as that top/bottom block.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for edge cases: ensure the divider truly spans the entire row/column (no gaps), and that both halves have the same dimensions. If the divider is not present or the halves are unequal, the pattern of comparison won't hold.</description>\\n<example>If a candidate divider has a single different cell or the top and bottom have different heights, re-check for a true full-line divider before applying the match/difference rule—otherwise the comparison will be inconsistent.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a full row or full column that is uniformly one color and spans the entire grid. That uniform stripe is a deliberate divider and should be treated as a boundary between two regions rather than part of either region's pattern.</description>\\n<example>Imagine a 7×7 grid where row 4 is entirely color X from column 1 to column 7. That whole row clearly separates the grid into an upper 3×7 block and a lower 3×7 block; you should not include row 4 when deciding which block to keep.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide which side of the divider to use by checking the examples: the chosen side is the one that contains the non-background (non-zero) pixels that form the pattern you need to preserve. Ignore the divider color and any other uniform stripe colors when making this choice.</description>\\n<example>If the top block contains several colored pixels while the bottom block is mostly zeros, the top block is the region to keep. Conversely, if the bottom block contains the patterned pixels and the top is mostly zeros, keep the bottom block.</example>\\n</note2>\\n\\n<note3>\\n<description>Once you have selected a block, keep its exact size and orientation (same number of rows and columns). The output grid dimensions are simply the dimensions of that chosen block.</description>\\n<example>If you chose the top block in a 7×7 grid, the output will be 3×7; if you chose the bottom block, the output will be 3×7 as well (same orientation and shape).</example>\\n</note3>\\n\\n<note4>\\n<description>Within the chosen block, map every non-background pixel to a single target color (commonly color 3 in these tasks) and leave every background (zero) pixel unchanged. Do not alter the relative arrangement of pixels inside the block.</description>\\n<example>For a 3×3 block that originally had colored pixels at (1,1) and (3,2), recolor those two cells to the target color while leaving zeros as zeros; the two non-zero cells remain in the same relative positions.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for multiple uniform rows/columns and common pitfalls: prefer the divider that is continuous across the whole grid, and avoid confusing a uniform row/column that is part of the pattern with the separating stripe. If more than one full row/column exists, use the one that cleanly splits the grid into two meaningful regions.</description>\\n<example>If you see two full rows of different uniform colors, pick the one that separates the patterned block from the mostly-empty block; do not include that divider when cropping. Also, do not recolor the divider itself — it should be discarded when forming the output.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single continuous row or column made of one color that runs the full length of the grid; that line usually marks a clear divider. When present, it cleanly separates the grid into two equal regions and indicates which half is the target for the output.</description>\\n<example>Imagine a grid where row 5 is entirely color X while the rows above and below are different. That full row of X is a natural boundary: treat it as the divider and split the grid into the two blocks above and below it.</example>\\n</note1>\\n\\n<note2>\\n<description>After locating the divider, choose the region that is not the divider itself and not a uniform background. Typically this is the half that contains multiple colors or distinct objects; that half is the one you will transform.</description>\\n<example>If the top half contains many colored pixels and the bottom half is mostly a single color, pick the top half as the source. If the left half contains several colors and the right half is uniform, pick the left half instead.</example>\\n</note2>\\n\\n<note3>\\n<description>Within the chosen region, collapse all non-background colors into one uniform color while keeping the same arrangement of pixels. In other words, replace every non-zero cell by a single target color and leave zero cells unchanged.</description>\\n<example>Suppose the chosen region has colors A, B and C with background 0; convert every A, B and C to color Y so the pattern of non-zero positions stays the same but all colored pixels become the same color.</example>\\n</note3>\\n\\n<note4>\\n<description>Keep the original size and orientation of the chosen region: the output should be a grid with the same number of rows and columns as that region. Do not rotate, flip, or otherwise alter the layout of the region when producing the result.</description>\\n<example>If you selected the left half of a 6×10 grid (3 columns wide), your output should be a 6×3 grid with the same row order and column order as that half.</example>\\n</note4>\\n\\n<note5>\\n<description>Use a single consistent replacement color for all non-background cells in the chosen region (do not use the divider’s color). Choose a color not present in the input (or use a color distinct from the divider) so the transformed region is visually distinct from the original background and divider.</description>\\n<example>If the input uses colors {0,2,4} and the divider uses color 5, pick a color not in {0,2,4,5} (for example, color 3) and fill every non-zero cell of the chosen region with that one color while leaving zeros as background.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[8, 0, 8, 8, 0, 8, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 8, 8, 8], [0, 0, 8, 8, 8, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 8, 8, 8], [8, 0, 8, 8, 8, 8, 0, 8, 8, 8, 8, 0, 0, 8, 8, 8, 8, 8, 8, 8, 0], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 8, 8, 8, 8, 8, 8, 8], [8, 0, 8, 8, 8, 8, 8, 8, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 8], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0], [0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], \"output\": [[3, 0, 3, 3, 0, 3, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3], [0, 0, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3], [3, 0, 0, 3, 3, 3, 0, 3, 3, 3, 3, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0], [3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3], [3, 0, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 3]]}, {\"input\": [[2, 2, 2, 2, 1, 4, 4, 4, 4], [2, 0, 0, 0, 1, 4, 0, 0, 4], [0, 0, 0, 2, 1, 4, 4, 4, 0], [0, 0, 2, 0, 1, 4, 4, 4, 0], [0, 0, 0, 0, 1, 4, 0, 0, 0], [2, 2, 0, 2, 1, 0, 0, 4, 4], [0, 2, 2, 0, 1, 0, 4, 0, 4], [0, 0, 2, 0, 1, 0, 4, 4, 4], [2, 0, 0, 2, 1, 0, 4, 4, 4], [0, 0, 0, 0, 1, 0, 0, 4, 4], [2, 2, 2, 0, 1, 0, 4, 4, 0], [0, 0, 0, 0, 1, 4, 0, 4, 4], [2, 0, 2, 2, 1, 4, 4, 4, 0], [2, 2, 0, 2, 1, 4, 4, 4, 4], [0, 2, 0, 0, 1, 0, 4, 4, 0], [0, 0, 0, 0, 1, 4, 0, 4, 0], [0, 2, 0, 2, 1, 4, 4, 0, 4], [0, 0, 2, 0, 1, 4, 4, 4, 4]], \"output\": [[0, 0, 0, 0], [0, 0, 0, 3], [3, 3, 3, 3], [3, 3, 0, 0], [3, 0, 0, 0], [3, 3, 3, 0], [0, 0, 3, 3], [0, 3, 0, 3], [3, 3, 3, 0], [0, 0, 3, 3], [3, 0, 0, 0], [3, 0, 3, 3], [0, 3, 0, 3], [0, 0, 3, 0], [0, 0, 3, 0], [3, 0, 3, 0], [3, 0, 0, 0], [3, 3, 0, 3]]}, {\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 5], [0, 0, 0, 0, 0, 0, 5, 0, 0], [5, 5, 0, 5, 5, 0, 0, 5, 0], [0, 0, 0, 5, 5, 5, 5, 0, 5], [0, 0, 5, 5, 5, 0, 5, 0, 0], [0, 5, 5, 0, 0, 0, 0, 0, 0], [5, 5, 0, 5, 5, 0, 0, 5, 5], [0, 5, 0, 5, 0, 0, 5, 5, 5], [1, 1, 1, 1, 1, 1, 1, 1, 1], [4, 4, 4, 4, 4, 4, 4, 4, 0], [4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 0, 0, 0, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 0, 4, 4, 4, 4, 4, 0], [4, 4, 4, 4, 4, 4, 0, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4]], \"output\": [[3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 0, 3, 3], [0, 0, 0, 3, 3, 3, 3, 0, 3], [3, 3, 3, 0, 0, 0, 0, 3, 0], [3, 3, 3, 0, 0, 3, 0, 3, 0], [3, 0, 0, 3, 3, 3, 0, 3, 3], [0, 0, 3, 0, 0, 3, 3, 0, 0], [3, 0, 3, 0, 3, 3, 0, 0, 0]]}]"},"test":{"kind":"string","value":"[{\"input\": [[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0], [0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0], [0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0], [0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1], [1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0], [1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6], [0, 0, 0, 6, 0, 0, 6, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0], [0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 3, 0, 3, 0], [0, 3, 3, 3, 3, 0, 0, 0, 0, 3, 0], [0, 0, 0, 3, 0, 3, 0, 3, 0, 3, 0], [0, 0, 3, 0, 3, 3, 3, 3, 0, 3, 0], [0, 3, 0, 3, 3, 3, 3, 3, 0, 3, 3], [3, 0, 0, 3, 0, 3, 0, 0, 0, 3, 0], [3, 0, 3, 0, 3, 3, 0, 0, 3, 0, 0]]}]"},"source":{"kind":"string","value":"rearc"},"prompt":{"kind":"string","value":"You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n8 0 8 8 0 8 0 0 8 8 8 8 8 8 8 8 8 0 8 8 8\n0 0 8 8 8 0 8 8 8 8 8 8 8 8 8 8 0 0 8 8 8\n8 0 8 8 8 8 0 8 8 8 8 0 0 8 8 8 8 8 8 8 0\n8 8 8 8 8 8 8 8 8 8 8 8 8 0 8 8 8 8 8 8 8\n8 0 8 8 8 8 8 8 0 8 8 8 8 8 8 8 8 8 0 0 8\n5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 0 0 0\n0 0 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6 0\n0 0 0 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n3 0 3 3 0 3 0 0 3 3 3 3 3 3 3 3 3 0 3 3 3\n0 0 3 3 3 0 3 3 3 3 3 3 3 3 3 3 0 3 3 3 3\n3 0 0 3 3 3 0 3 3 3 3 0 0 3 3 3 3 3 3 0 0\n3 3 3 3 3 3 3 3 3 0 3 3 3 0 3 3 3 3 3 3 3\n3 0 3 3 3 3 3 3 0 3 3 3 3 3 3 3 3 3 0 0 3\n```\n\n## Example 2\nInput:\n```\n2 2 2 2 1 4 4 4 4\n2 0 0 0 1 4 0 0 4\n0 0 0 2 1 4 4 4 0\n0 0 2 0 1 4 4 4 0\n0 0 0 0 1 4 0 0 0\n2 2 0 2 1 0 0 4 4\n0 2 2 0 1 0 4 0 4\n0 0 2 0 1 0 4 4 4\n2 0 0 2 1 0 4 4 4\n0 0 0 0 1 0 0 4 4\n2 2 2 0 1 0 4 4 0\n0 0 0 0 1 4 0 4 4\n2 0 2 2 1 4 4 4 0\n2 2 0 2 1 4 4 4 4\n0 2 0 0 1 0 4 4 0\n0 0 0 0 1 4 0 4 0\n0 2 0 2 1 4 4 0 4\n0 0 2 0 1 4 4 4 4\n```\n\nOutput:\n```\n0 0 0 0\n0 0 0 3\n3 3 3 3\n3 3 0 0\n3 0 0 0\n3 3 3 0\n0 0 3 3\n0 3 0 3\n3 3 3 0\n0 0 3 3\n3 0 0 0\n3 0 3 3\n0 3 0 3\n0 0 3 0\n0 0 3 0\n3 0 3 0\n3 0 0 0\n3 3 0 3\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 5\n0 0 0 0 0 0 5 0 0\n5 5 0 5 5 0 0 5 0\n0 0 0 5 5 5 5 0 5\n0 0 5 5 5 0 5 0 0\n0 5 5 0 0 0 0 0 0\n5 5 0 5 5 0 0 5 5\n0 5 0 5 0 0 5 5 5\n1 1 1 1 1 1 1 1 1\n4 4 4 4 4 4 4 4 0\n4 4 4 4 4 4 4 4 4\n4 4 0 0 0 4 4 4 4\n4 4 4 4 4 4 4 4 4\n4 4 0 4 4 4 4 4 0\n4 4 4 4 4 4 0 4 4\n4 4 4 4 4 4 4 4 4\n4 4 4 4 4 4 4 4 4\n```\n\nOutput:\n```\n3 3 3 3 3 3 3 3 3\n3 3 3 3 3 3 0 3 3\n0 0 0 3 3 3 3 0 3\n3 3 3 0 0 0 0 3 0\n3 3 3 0 0 3 0 3 0\n3 0 0 3 3 3 0 3 3\n0 0 3 0 0 3 3 0 0\n3 0 3 0 3 3 0 0 0\n```\n\n# Test Problem:\n```\n0 0 0 0 0 0 0 1 0 1 0\n0 1 1 1 1 0 0 0 0 1 1\n0 0 0 0 0 1 1 1 0 1 0\n0 0 1 0 1 1 1 1 0 1 0\n0 1 0 1 1 1 1 1 0 0 1\n1 0 0 1 1 1 0 0 0 1 0\n1 0 1 0 1 0 0 0 1 0 0\n5 5 5 5 5 5 5 5 5 5 5\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 6\n0 0 0 6 0 0 6 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 6 0\n0 0 0 0 6 0 0 0 0 0 0\n0 0 0 0 0 6 0 0 0 0 0\n```"},"answer":{"kind":"string","value":"```\n0 0 0 0 0 0 0 3 0 3 0\n0 3 3 3 3 0 0 0 0 3 0\n0 0 0 3 0 3 0 3 0 3 0\n0 0 3 0 3 3 3 3 0 3 0\n0 3 0 3 3 3 3 3 0 3 3\n3 0 0 3 0 3 0 0 0 3 0\n3 0 3 0 3 3 0 0 3 0 0\n```"},"num_tokens":{"kind":"number","value":2186,"string":"2,186"}}},{"rowIdx":97,"cells":{"abstraction_prompt":{"kind":"string","value":"<|im_start|>user\nDeveloper: # ARC HINT GENERATOR\n\n## Role & Goal\nYou are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that helps the user discover the core transformation principle for themselves without revealing the answer.\n\nBegin with a concise checklist (3-7 bullets) of what you will do; keep items conceptual, not implementation-level.\n\n---\n\n## Hint Generation Strategy\n1. **Compare** the input and output grids for each example. Identify the shared transformation pattern that allows the input grid to be converted into the output grid.\n2. **Identify the Core Principle**: Review the problem description and ground-truth solution to fully discern the key transformation rule. Break it down into its essential operations (e.g., object completion, pattern repetition, symmetry, gravity), paying close attention to properties such as object count, shapes, colors, sizes, symmetry, repetition, relative positioning, and broader grid-level patterns.\n3. **Craft a Targeted Hint**: Generate a hint that guides the user toward the core insight needed to solve the problem. The hint should assist the user during their attempt without revealing the solution.\n4. Structure each note using the template below:\n - **Description** (up to 3 sentences): Explain the concept, when and why it applies, and why it is effective. Include any relevant general formula or principle in its most general form.\n - **Example** (up to 6 sentences): Present a worked example covering all aspects of the description, using a simplified yet representative scenario (not necessarily from the current problem).\n - Optionally, include **Heuristics** or **Pitfalls** in the note where relevant.\n - Focus on methodologies and core principles over specific calculations or problem details.\n - Ensure each hint applies broadly—at least 80% of analogous problems.\n\nAfter generating a hint, verify that no specifics of the solution are revealed, and that the hint remains at the level of guiding the approach.\n\n### Output Format\nProduce a **sequence of 5** notes in the structure:\n<note1>\n<description>...</description>\n<example>...</example>\n</note1>\n<note2>\n<description>...</description>\n<example>...</example>\n</note2>\n...\n\n### Design Guidelines\n- Clarity: Use precise language and correct sentence structure.\n- Atomicity: Each note addresses one recognizable sub-problem.\n- Self-containment: All information needed to understand the idea and its application is within the note.\n- Generalizability: Avoid problem-specific details or variables.\n- Transferability: Notes should apply across a class of problems.\n- Distinctness: Each note addresses a distinct principle.\n\n---\n\n## Guidelines\n- **Guide, Don't Solve**: Illuminate the approach, not the answer. Emphasize what to observe or consider.\n- **Specific yet Abstract**: Use concrete grid details (e.g., \"note the relationship between the blue and red pixels\") to ground abstract patterns (e.g., \"think about one color containing another\").\n\nValidate your generated hint: confirm it is self-contained, actionable, and nondirective. If any aspect is too revealing, revise before finalizing.\n\n---\n\n## Inputs\n### Problem Description\nA full ARC problem, including input/output pairs for training and testing.\n\nYou will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n8 0 0 0 0 0\n0 0 0 0 0 0\n0 0 0 0 0 0\n0 0 0 0 0 0\n0 0 0 0 0 0\n0 0 0 0 0 0\n```\n\nOutput:\n```\n8 8\n8 8\n```\n\n## Example 2\nInput:\n```\n0 7 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n```\n\nOutput:\n```\n7 7\n7 7\n```\n\n## Example 3\nInput:\n```\n5 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n```\n\nOutput:\n```\n5 5\n5 5\n```\n\n# Test Problem:\n```\n5 5 0 0 0 0 0\n0 5 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n```\n\n---\n\n\n# Generated Hint<|im_end|>\n<|im_start|>assistant\n"},"abstraction_prompt_length":{"kind":"number","value":1312,"string":"1,312"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>Start by locating the single non-background color in the input and record its color value; this color is the candidate that determines the output. When there is exactly one such color across the whole grid, it usually serves as the key attribute for the transformation.</description>\n<example>Imagine a grid that is mostly black except for one blue pixel; treat \"blue\" as the important color to track. If the grid contained several different colored pixels, you would need to look for a different selection rule instead.</example>\n</note1>\n\n<note2>\n<description>Count how many cells hold that chosen color in the input (i.e., the total number of occurrences). The count is a numeric quantity that often determines the size or shape of the output.</description>\n<example>For example, if the chosen color appears three times in the input, that count (3) is a simple numeric parameter you can use to decide how big the output should be.</example>\n</note2>\n\n<note3>\n<description>Check whether the output preserves the original color by filling an entire square (or rectangle) with that color. Many tasks convert the count into a compact square block whose side length is derived from the count.</description>\n<example>If the count is 4, a natural output shape is a 4×4 square filled with the chosen color; if the count is 2, a 2×2 filled square would be the corresponding compact representation.</example>\n</note3>\n\n<note4>\n<description>Decide how the square size is computed from the count: try simple numeric relationships such as using the count directly, using the count minus a fixed offset, or using a different mapping (e.g., square root, ceiling, floor). Test which numeric mapping fits the example pairs before applying it to the test.</description>\n<example>For instance, if counts in the examples are 2 and 4 and the outputs are 2×2 and 4×4, the mapping is \"use the count as the side length.\" If you instead saw counts 1 and 3 and outputs 1×1 and 3×3, the same simple mapping holds.</example>\n</note4>\n\n<note5>\n<description>After forming a hypothesis, apply it to the test input: identify the non-background color, compute the side length from its count using your chosen numeric rule, and produce a filled square of that size in the chosen color. Finally, verify consistency with the examples and adjust the numeric rule if necessary.</description>\n<example>So, for a test grid where a color appears twice, use your chosen rule (for example, \"the side length equals the count\") to build a 2×2 filled square with that color; if that reproduces the pattern seen in the training examples, the rule is likely correct.</example>\n</note5>","<note1>\n<description>Start by locating the non-background color(s) in the input. If exactly one color appears, that color is usually the anchor for the transformation and will be used to fill the output.</description>\n<example>Imagine a grid that contains only zeros except for a single red pixel. The red pixel is the only colored element, so it is the natural candidate to drive any change in the output.</example>\n</note1>\n\n<note2>\n<description>Compare the output dimensions to the input dimensions to detect a consistent scaling factor. If the output is a fixed fraction of the input in both directions, that fraction is likely the scaling applied.</description>\n<example>For example, if an input of size 6×6 produces an output of size 3×3, the output is half the input in each dimension; if a 5×5 input becomes 2×2, the factor is 2/5. Noting that factor helps you predict the output size for other inputs.</example>\n</note2>\n\n<note3>\n<description>Examine the arrangement of the output: does it form a compact filled region (a square, filled rectangle, or a small motif)? Many tasks compress the input into a single, uniformly filled block.</description>\n<example>If the output shows a small, solid block (every cell the same color), then the transformation is likely to “collapse” the input into a compact filled region rather than preserving its original shape or scattered pixels.</example>\n</note3>\n\n<note4>\n<description>Check whether the output preserves the original color(s) or replaces them. If outputs always use the same color(s) as the input’s non-background pixels, the rule is to keep those colors and not introduce new ones.</description>\n<example>If the input has one blue pixel and the output is a solid blue block, the rule is “use the input’s colored pixels to color the compressed block.” This keeps the identity of the color consistent across examples.</example>\n</note4>\n\n<note5>\n<description>Use the training pairs to infer the exact mapping (which input pixels are selected, how they are arranged, and how the grid size changes) and then apply that same mapping to the test input. Avoid assuming extra rules—only add complexity if examples require it.</description>\n<example>With a few examples showing how a single colored pixel becomes a compact block of the same color at a consistent scale, you can apply that same mapping to a new input that contains multiple pixels of the same color: pick the pixels, compress them to the same block size, and color the block consistently with the input.</example>\n</note5>","<note1>\n<description>Look for the single non-background color that is present in the input. When one color appears only once or in a small, consistent set of pixels across examples, it is usually the element being transformed.</description>\n<example>Imagine a mostly black grid with one red pixel. That red pixel is the likely focus of the transformation because it is the only color that differs from the background and appears consistently in the examples.</example>\n</note1>\n\n<note2>\n<description>Check whether the non-background color is preserved across the transformation: if its value and shape remain the same but its placement changes, the rule is a relocation or recoloring of the object rather than a change of color or shape.</description>\n<example>If the input has a blue dot and the output shows a blue dot in a different position but still blue, then the operation is moving the blue dot (or copying it) rather than converting it to another color.</example>\n</note2>\n\n<note3>\n<description>Compare the sizes of input and output grids to detect a consistent scaling factor. A repeated change in the overall dimensions (for example, the output being a smaller, square grid) suggests a uniform scale applied to the whole grid.</description>\n<example>If every input is larger than the corresponding output and the outputs are square, try dividing the output’s side by the input’s side to see whether the same integer factor explains all examples.</example>\n</note3>\n\n<note4>\n<description>Decide how the transformed object is placed inside the new grid: is it centered, aligned to a corner, or tiled? The placement rule (centered vs. corner-aligned) is a separate step from the scaling and must be applied consistently.</description>\n<example>After computing a smaller square from the input, check whether the preserved object appears at the grid center or at a particular corner in the outputs; that tells you whether to center or align the object when building the test output.</example>\n</note4>\n\n<note5>\n<description>Combine the observations into a simple pipeline: identify the object color, apply the discovered scale, and place the object according to the observed alignment rule. Apply this pipeline to the test input to produce the output.</description>\n<example>First, locate the unique color in the test input. Then compute the smaller square size from the scale factor you inferred. Finally, place that color according to the center/corner rule you observed in the examples and fill the rest of the smaller square with the background color.</example>\n</note5>","<note1>\n<description>Look for the single non-background color and treat it as the \"seed\" for the transformation. This color is usually the only one that changes between input and output and determines the new object's color.</description>\n<example>Imagine a grid with one blue pixel and a sea of zeros; the output will reuse that blue as the color of the new shape. Identifying the seed avoids confusing background noise with the meaningful element.</example>\n</note1>\n\n<note2>\n<description>Check the spatial relationship between the seed and the rest of the grid: if the seed is near a corner or edge, the transformation often preserves that corner/edge placement. The output's position is usually aligned with the seed's relative location.</description>\n<example>If the seed sits in the top-left corner, expect the output to be placed in a corner of the output grid rather than shifted elsewhere. This keeps the transformation consistent across examples.</example>\n</note2>\n\n<note3>\n<description>Observe the size of the output object: many tasks replace a sparse input with a small uniform block (commonly a 2×2 square). The block is filled with the seed color and is compact, so treat it as a single filled tile.</description>\n<example>Given a scattered set of colored pixels, the output may be a single filled 2×2 square of the same color. This indicates the solver is collapsing the input into one small, uniform patch.</example>\n</note3>\n\n<note4>\n<description>Decide whether the transformation is applied to the whole grid or only to the seed's color by checking whether other colors are preserved in the outputs. If only one color changes, the rule is color-based rather than spatial.</description>\n<example>If every training output contains only the seed color and nothing else, then the rule is to replace the grid with a block of that color. That tells you not to expect new shapes or other colors in the result.</example>\n</note4>\n\n<note5>\n<description>Form a minimal hypothesis (identify seed color, keep corner/edge placement, replace by a small uniform block) and apply it to the test input; then validate it against the examples. If it reproduces the example outputs, apply the same steps to the test grid.</description>\n<example>Take the seed color, place a small uniform block at the seed's corner/edge, and fill it with that color. If that matches the example outputs' behavior, the same procedure will produce the test output.</example>\n</note5>","<note1>\n<description>Look for the unique non-background color(s) in the input and treat them as the elements that drive the transformation. This is effective because many ARC tasks compress or repeat the information carried by a small set of colored pixels while discarding the surrounding background.</description>\n<example>Imagine a grid where only one color appears and it sits near a corner; that single color is the element you should track. If you see several distinct colors, still focus on the non-background ones as the source of the rule rather than the empty space.</example>\n</note1>\n\n<note2>\n<description>Compute the minimal bounding rectangle that contains all non-background pixels (the smallest axis-aligned box that covers every colored cell). This isolates the pattern to transform and removes irrelevant empty rows and columns.</description>\n<example>If colored pixels appear at coordinates (0,0),(0,2),(1,1) then the bounding rectangle spans rows 0..1 and columns 0..2, so you should consider only that 2×3 subgrid as the pattern to analyze.</example>\n</note2>\n\n<note3>\n<description>Inside that rectangle, check whether the pattern is uniform (every cell in the box is the same color) or contains multiple colors. The transformation typically depends on whether the rectangle is uniform or not.</description>\n<example>For a 2×2 rectangle where all four cells are color A, the rectangle is uniform; for a 2×2 rectangle with two A's and two B's, the rectangle is non-uniform. Treat these two cases differently when inferring the next step.</example>\n</note3>\n\n<note4>\n<description>When the bounding rectangle is uniform, the intended operation is often to compress it into a smaller uniform square (for example, 2×2) while preserving the single color. Think of this as \"compress the uniform block into a single, smaller uniform block.\"</description>\n<example>If the bounding rectangle is a 3×3 block of color X, a common transformation is to replace that 3×3 with a 2×2 block of X, so the information is kept but in a smaller uniform square.</example>\n</note4>\n\n<note5>\n<description>If the rectangle is not uniform, the examples usually show a different, simple operation (for instance, a single-cell output). In that case, choose a single representative cell (often the top-left cell of the rectangle) and map it to the output grid.</description>\n<example>For a non-uniform 2×2 rectangle with values [A B; C D], many ARC rules would produce a single-cell output whose color is taken from the rectangle's top-left cell (A). This is a quick way to reduce a non-uniform pattern to one cell.</example>\n</note5>","<note1>\n<description>Find the unique non-background color that appears in the input. When a grid has exactly one non-background color, that color is the likely candidate to drive the transformation.</description>\n<example>Imagine a grid with one pixel of color A on a black background; A is the only non-background element, so it is the natural focus for any transformation that depends on foreground color.</example>\n</note1>\n\n<note2>\n<description>Look for a consistent change in the spatial arrangement of that color across examples: does its location move, its shape change, or is it repeated in a new pattern? A consistent spatial rule (for example, relocation to a corner) indicates a positional transformation.</description>\n<example>If every example shows the single colored pixel in the top-left of the output while the input had it elsewhere, that suggests a relocation rule that places the color consistently in a corner.</example>\n</note2>\n\n<note3>\n<description>Consider whether the transformation preserves shape and color but changes size or density: a common operation is to replace a single pixel with a filled square block of the same color. This increases the foreground's prominence while keeping its color constant.</description>\n<example>For instance, replacing a solitary red pixel with a 2×2 red block keeps red as the color but makes the red area four times larger and more visually dominant.</example>\n</note3>\n\n<note4>\n<description>Check how the output grid size relates to the input: sometimes the output is a fixed small square regardless of input dimensions. If so, the transformation normalizes the canvas size before applying the shape change.</description>\n<example>If several different-sized inputs all become the same small square in the outputs, that indicates a resizing step that makes the output canvas uniform before further operations.</example>\n</note4>\n\n<note5>\n<description>Combine the observations into a concise procedure: normalize the canvas, identify the unique foreground color, then apply the spatial rule (e.g., move the color to a corner) and the shape rule (e.g., fill a square). This sequence explains how a varied set of inputs can map to a consistent output.</description>\n<example>Take a 7×7 input with one colored pixel: first shrink/normalize the canvas, then move that color to the chosen corner, and finally fill it with the same color in a square to produce the final pattern.</example>\n</note5>","<note1>\n<description>Scan the input for any non-background pixels and record their color and coordinates. The transformation usually acts on the smallest set of pixels that is non-background, so identifying that set is the first step.</description>\n<example>Imagine a grid that is all black except for two pixels, both colored red. Mark those two red pixels and note they are the only non-background elements; that small set is what you will transform.</example>\n</note1>\n\n<note2>\n<description>Check whether the output preserves the original color(s). If the output contains only the same colors as the input (and no new colors), the rule is likely a geometric operation that moves or repeats existing pixels rather than recoloring them.</description>\n<example>If the input has blue pixels and the output has only blue pixels (no green or other colors), then you can focus on how the blue pixels were repositioned or repeated rather than worrying about color changes.</example>\n</note2>\n\n<note3>\n<description>Look for a uniform scaling or tiling of the input pattern: many tasks replace the whole input by a single, smaller copy of the pattern. If the output size is a simple multiple of the input, test whether the output equals that scaled copy of the input pattern.</description>\n<example>For instance, if the input is 3×2 and the output is 2×2, check whether the output is exactly one copy of the input pattern (possibly after a uniform reduction or cropping) rather than a new arrangement.</example>\n</note3>\n\n<note4>\n<description>When a candidate rule fails, try simple geometric transforms: horizontal/vertical reflections, 90° rotations, or a 180° flip. These transforms preserve colors and pixel counts but change orientation, so test them to see if they explain the mapping between input and output.</description>\n<example>If a single colored pixel appears in a different quadrant in the output, that suggests a 90° rotation or reflection; apply that transform mentally to the input to see if it matches the output.</example>\n</note4>\n\n<note5>\n<description>After you identify the operation, validate it by applying it to every training example and confirming it reproduces each output exactly. If any example fails, adjust whether you are using a copy, a transform, or a different reduction rule.</description>\n<example>Take your hypothesized rule and run it on each training pair; if every output matches, the rule is consistent; if one example doesn’t match, try a different small transform or a different selection of pixels to test.</example>\n</note5>","<note1>\n<description>Look for the single non-background color that appears in the input; that color is the one being transformed. When a grid contains only one non-background color, the transformation is typically about how that color is arranged rather than about other colors.</description>\n<example>Imagine a grid with a single red pixel somewhere inside a larger black background. The red pixel is the only color of interest, so focus on how red is handled in the outputs rather than on black or any other colors.</example>\n</note1>\n\n<note2>\n<description>Check whether the transformation preserves the original color value. Many ARC tasks recolor objects consistently, so the color used in the output should match the color found in the input.</description>\n<example>If the input has a blue pixel, the output will usually be filled with blue as well; you should treat color identity as invariant when inferring the rule.</example>\n</note2>\n\n<note3>\n<description>Compare the sizes of input and output grids to detect a consistent scaling factor. A uniform factor across examples (often an integer) tells you whether the transformation is a uniform scaling or cropping of the original pattern.</description>\n<example>If every example’s output is smaller in both dimensions by the same factor, you can infer a uniform scaling; use that factor to predict the output size for the test case.</example>\n</note3>\n\n<note4>\n<description>Examine how the colored pixels are repositioned inside the transformed region: are they preserved at the same relative coordinates, or are they shifted to a fixed corner or center? This reveals whether the transformation is a pure resize, a crop, or a translation.</description>\n<example>For instance, if colored pixels remain at the same relative positions after the change, the rule is a resize; if they move to the top-left corner, the rule includes a translation in addition to resizing.</example>\n</note4>\n\n<note5>\n<description>Use simple invariants to validate your hypothesis: count the colored pixels and check that the output grid contains the same number of them (possibly arranged differently). If counts and positions are preserved under your inferred rule, it is likely correct.</description>\n<example>Suppose the input has three colored pixels and your candidate rule produces a smaller grid that still contains three colored pixels arranged the same way; that consistency supports the rule and helps avoid overfitting to a single example.</example>\n</note5>","<note1>\n<description>Start by finding the single non-background color that is unique across the input examples. When one color stands out from the uniform background, that color is usually the one the task is about.</description>\n<example>Imagine a grid of zeros with exactly one pixel colored red. Because every example uses a single distinct color, treat that red as the salient color and ignore the zeros for the transformation.</example>\n</note1>\n\n<note2>\n<description>Decide whether the transformation moves or copies the salient color: check whether the color appears in the same position or in a different location in the outputs. If the examples preserve the color’s location, the operation is a copy; if they move it, the operation is a relocation.</description>\n<example>If the single colored pixel in the input remains in the same spot in the output (but the output shows more of that color), the rule is a local replication rather than a translation of the pixel.</example>\n</note2>\n\n<note3>\n<description>Look for a fixed local pattern that the salient color is being placed into. Many tasks replace a small, identical block (for example a 2×2 square) with copies of the salient color, so the output’s shape is a small uniform block rather than a scattered or irregular shape.</description>\n<example>When you see the same color repeated in a compact square in the outputs, that suggests the rule is “fill a fixed 2×2 block” rather than “draw an irregular shape” or “move pixels around.”</example>\n</note3>\n\n<note4>\n<description>Confirm that the transformation does not alter the color value or introduce other colors; the replacement block should be uniformly the salient color. This helps you know which color to use when constructing the output.</description>\n<example>If the colored pixel in the input is blue and the output shows only blue in the filled block, then the rule preserves color identity and does not add or change colors.</example>\n</note4>\n\n<note5>\n<description>Use simple consistency checks: count the non-background pixels in the input and compare to the number of colored cells in the output, and ensure every output cell has the same color. These checks quickly reveal whether the rule is a fixed-size fill or a more complex operation.</description>\n<example>If the input has one colored pixel and the output shows four identical colored cells arranged in a small square, that is strong evidence the task copies the color into a fixed local block rather than transforming the pixel’s shape or position.</example>\n</note5>","<note1>\n<description>Find the seed color by locating the color that appears in the input but is absent from the output; this color is the element being propagated. When one non-background color is the only one that changes, it usually acts as the source for the transformation.</description>\n<example>Imagine an input with a single red pixel and a black background, and the output contains only red. The red pixel is the seed: it is the color that the output is built from. Identifying this seed first narrows down the possible operations (copy, fill, repeat, etc.).</example>\n</note1>\n\n<note2>\n<description>Check whether the output is a single-color block (all cells share the same color). A uniform output suggests the transformation is a replication or filling of the seed color rather than a rearrangement of different colors.</description>\n<example>For instance, if an input has one green pixel and the output shows every cell green, the operation is simply “make every cell the seed color.” This tells you to focus on how many cells to create, not on moving or recoloring existing shapes.</example>\n</note2>\n\n<note3>\n<description>Look for a small, fixed square tile (commonly 2×2) as the output shape across examples; many ARC tasks use the same compact square size for the result. Use the examples to infer the tile size before applying it to the test case.</description>\n<example>If each example’s output is a 2×2 block of one color, then the intended output shape is a 2×2 square. Treat that square as the canvas to fill with the seed color when solving the test case.</example>\n</note3>\n\n<note4>\n<description>Decide whether the seed’s position in the input matters: if the seed is unique and the output is uniform, the rule may ignore spatial location and only use the color. If multiple seeds exist, consider whether the rule preserves their arrangement or reduces them to a single color.</description>\n<example>When there is exactly one non-background pixel, its exact coordinates often do not influence the final output; the important fact is “which color appears.” If multiple colored pixels appear, ask whether they are merged into one color or kept separate in the output.</example>\n</note4>\n\n<note5>\n<description>After inferring the seed color and the fixed square size, construct the output by filling that square entirely with the seed color and leaving all other cells unchanged. This final step confirms the transformation is a uniform block replication.</description>\n<example>Given a determined seed color and a 2×2 target, produce a 2×2 grid where every cell equals the seed color; the rest of the grid remains as in the input. This yields a compact, consistent output that matches the pattern seen in the examples.</example>\n</note5>","<note1>\n<description>Look for the single non-background color that is present in the input. If exactly one color appears (besides the background), that color is the candidate to be propagated into the output.</description>\n<example>Imagine a grid where every cell is background except one red pixel; that red is the only meaningful element and should be the color you consider for the output. If several colors appear, you must instead look for a secondary, consistent pattern (e.g., repeated pixels of a single color) rather than the background.</example>\n</note1>\n\n<note2>\n<description>Check for a compact, regular shape that repeats across the grid: many tasks use a small, repeated motif (a 2×2 block or a 2×1 bar) as the atomic unit. Identifying that motif tells you how the color should be arranged in the output.</description>\n<example>For instance, if you see identical two-cell bars in multiple places, treat each bar as an atomic tile and plan the output using that tile's dimensions. If instead you see isolated single pixels, the atomic tile may be a single cell rather than a small block.</example>\n</note2>\n\n<note3>\n<description>Count the number of such atomic tiles in the input (e.g., count occurrences of the motif or the color). That count often determines how many copies of the tile appear in the output.</description>\n<example>If the motif appears three times in the input, expect three copies of the tile in the output; if it appears once, expect one copy. Counting is straightforward when the motif is uniform and repeated; if the motif is sparse, use the color frequency as a proxy.</example>\n</note3>\n\n<note4>\n<description>Decide the spatial arrangement of the copies: they are typically placed in a compact, regular layout (often a 2×2 arrangement) and may be filled with the motif color while background cells remain background. The exact arrangement is consistent across examples.</description>\n<example>Given four copies, a common choice is a 2×2 grid of tiles; each tile filled with the motif color produces a small, uniform block. If the number of copies does not match a 2×2 arrangement, the examples will show which smaller packing (1×2, 2×1, or single-cell) is used.</example>\n</note4>\n\n<note5>\n<description>Assemble the final grid by combining the tiles: the output's dimensions equal the tile size multiplied by the number of tiles along each axis, and every tile is filled with the motif color while background cells are left as background. This yields a small, consistent output that matches the training examples.</description>\n<example>For example, if each tile is 2×2 and you need two tiles along one axis and one along the other, the output will be 4×2 with the motif color occupying the tile cells and background elsewhere. A quick sanity check: the number of motif-colored cells in the output should equal the number of tiles multiplied by the tile area.</example>\n</note5>","<note1>\n<description>Focus first on locating the object: find the color(s) that are not the background and determine the smallest rectangle that contains them. This bounding box isolates the relevant pixels and ignores surrounding empty space.</description>\n<example>Imagine a grid with a single red pixel at (row 1, col 2). The bounding box is simply that single pixel; if there are two red pixels at (1,2) and (4,5), the box spans rows 1–4 and cols 2–5. Once you have that rectangle you know which area to examine further.</example>\n</note1>\n\n<note2>\n<description>Check whether the bounding box is square: many ARC tasks that crop an object will produce a square output. A square is defined by equal height and width, so compare the box’s row-span and column-span before proceeding.</description>\n<example>If your bounding box covers 2 rows and 2 columns it is a 2×2 square; if it covers 3×3 it is a 3×3 square. If the box is rectangular (e.g., 2×3), the task may still crop to the square region inside it (the smaller of the two dimensions).</example>\n</note2>\n\n<note3>\n<description>Observe how color is treated inside the cropped square: often the object’s color is preserved and fills the entire square, while any other colors (or background) inside the box are removed. The transformation typically replaces the interior with one uniform color.</description>\n<example>For instance, if the bounding box contains a blue pixel and some black pixels, the output square will be entirely blue. If the box contains multiple colored pixels, the rule may keep the dominant object color and erase other colors.</example>\n</note3>\n\n<note4>\n<description>Pay attention to orientation and placement: the cropped square is usually placed in a consistent location (often the top-left) and the pixels inside are copied or mirrored in a predictable way. Confirm whether the crop is a direct copy or a rotated/reflected copy by checking corresponding positions across examples.</description>\n<example>If the original pixel is at the lower-right of the bounding box, the output square may show that color at the lower-right as well (indicating a direct copy), or it may show it at the upper-left (indicating a mirror or rotation). Compare the relative positions of the colored pixels in input vs output to decide which.</example>\n</note4>\n\n<note5>\n<description>Use quick heuristics to avoid mistakes: prefer the smallest enclosing rectangle that contains every non-background pixel, and if the box is rectangular crop to the square defined by the smaller side. Also, if multiple colors appear inside the box, use the color that best represents the object (often the most frequent non-background color) and ignore stray pixels.</description>\n<example>If a box spans 2 rows and 3 columns, the square crop will be 2×2 (the smaller dimension). If the box contains two red pixels and one blue pixel, choose red as the representative color and fill the square with that color, then check whether the square is placed top-left or mirrored by comparing the examples.</example>\n</note5>","<note1>\n<description>Locate the active color by scanning the grid for the smallest non-zero color (the first non-background pixel you encounter when reading left-to-right, top-to-bottom). This gives you the color to use in the transformation because the examples consistently use the earliest non-background color.</description>\n<example>Imagine a grid that contains only zeros and a single 2 in the top row; scanning finds 2 first, so that 2 is the candidate color for the output. If multiple colors appear, pick the one you would see first when moving across the grid.</example>\n</note1>\n\n<note2>\n<description>Check the spatial pattern of that color in the input: if it appears only once and in one corner, the transformation often preserves that single pixel's identity rather than moving or reshaping it. That tells you to keep the color's value and not to alter its position when forming the output.</description>\n<example>If a lone red pixel sits at the top-left of the input, expect the output to use red as the primary color while leaving the pixel's identity intact rather than creating new shapes or relocating it.</example>\n</note2>\n\n<note3>\n<description>Compare the input and output sizes to infer a scaling factor: many tasks replace the original grid with a smaller square whose side is the smallest non-zero color. This gives a direct mapping from the color value to the output dimensions.</description>\n<example>If the smallest non-zero color is 3, expect the output to be a 3×3 grid; if it is 4, expect a 4×4 grid. Use this rule to compute the output size from the color you identified.</example>\n</note3>\n\n<note4>\n<description>Form the output by filling the computed square with the identified color. The examples typically replace the entire output grid with that single color, producing a uniform square rather than mixing colors or preserving original positions.</description>\n<example>Given a color 3 and a 3×3 target, produce a grid where every cell is 3 so the output is a solid square of that color.</example>\n</note4>\n\n<note5>\n<description>Watch for common pitfalls: do not use the background color (0), do not average or blend colors, and do not try to preserve the original coordinates—transformations of this kind usually ignore input layout and produce a new uniform square. If you see multiple non-zero colors, still use the first one you encounter in reading order.</description>\n<example>If you see both a 2 and a 7 in the input but the 2 appears earlier in reading order, pick 2 and make a square whose side equals 2; do not try to keep the original arrangement or combine the two values.</example>\n</note5>","<note1>\n<description>Scan each input for the smallest contiguous block of non-background cells that contains all non-background colors. This bounding box isolates the meaningful pattern and ignores surrounding empty space.</description>\n<example>For a grid with a single colored pixel at (r,c), the bounding box is just that pixel. If two pixels are at (r,c) and (r+1,c), the bounding box is the 2×1 rectangle covering both rows and columns of those pixels.</example>\n</note1>\n\n<note2>\n<description>Reduce that bounding box to the minimal rectangle that still contains every non-background pixel; that rectangle is the candidate motif. Do not shrink it further unless the examples show such reductions.</description>\n<example>If the bounding box is 2×3 but only one row actually contains colored cells, check whether the task keeps the full rectangle or collapses to the active row. If examples always keep the full rectangle, keep it.</example>\n</note2>\n\n<note3>\n<description>When producing the output, preserve the motif's colors and their relative arrangement, but often the task expects a canonical small square (a fixed small side length) rather than the original bounding box. Use the minimal square that can accommodate the motif's width or height.</description>\n<example>A 2×1 vertical motif can be embedded into a 2×2 square by placing it in one corner and filling the remaining cells with the background color; a 1×2 horizontal motif would be placed in a 2×2 square similarly.</example>\n</note3>\n\n<note4>\n<description>Fill any cells outside the motif with the background color (typically 0) so the output is a clean, self-contained image of the motif. This makes the transformation unambiguous and consistent across examples.</description>\n<example>If the motif is 2×2, and the required output canvas is 4×4, put the 2×2 motif in one corner and set all other cells to 0 so the motif is clearly visible.</example>\n</note4>\n\n<note5>\n<description>Apply the same transformation rule to the test input: compute the minimal bounding box, reduce it to the minimal rectangle that contains all non-background pixels, place it into the required small square (or the minimal square that fits), and fill remaining cells with the background color. Verify consistency with the examples before finalizing.</description>\n<example>For a test grid with multiple colored pixels, first find their minimal rectangle; then place that rectangle into the fixed-size square (or the minimal square that fits), and fill any leftover cells with 0 to produce the output.</example>\n</note5>","<note1>\n<description>Start by locating the single non-background pixel(s) in the input and compare their coordinates to the output. If every non-background pixel appears in the same relative position in the output, the transformation is a translation (shift) rather than a reshape or recoloring.</description>\n<example>For instance, if an input has a colored pixel at (row 0, column 1) and the output shows that same color at (row 0, column 0), you can infer a leftward translation. Repeating this check for all colored pixels confirms whether a uniform shift is being applied.</example>\n</note1>\n\n<note2>\n<description>Check how many colored pixels become a single contiguous block in the output. If the output contains several adjacent colored cells that were not present in the input, the rule likely groups or collapses multiple input pixels into one connected region.</description>\n<example>Imagine an input with two isolated colored pixels and the output showing one contiguous block of the same color; this indicates the solver combined or merged those pixels into a single object rather than leaving them separate.</example>\n</note2>\n\n<note3>\n<description>Look for a fixed size for the resulting block: many ARC tasks produce a small, consistent square or rectangle. Determining whether the output is always square (same width and height) helps you predict the output dimensions.</description>\n<example>If every example output is a 2×2 block of the same color, then the transformation consistently produces a 2×2 square, so you should expect a 2×2 output for a new input as well.</example>\n</note3>\n\n<note4>\n<description>Decide whether the output is filled with a single color or whether multiple colors are preserved. If the input has several different colors but the output uses only one, the rule collapses colors; if multiple colors remain, they are likely preserved in the same relative arrangement.</description>\n<example>For example, if an input contains red and blue pixels but the output shows only red in a compact block, that indicates a color-selection or collapse step. Conversely, if blue appears in the output in the same relative position as in the input, colors are being preserved rather than discarded.</example>\n</note4>\n\n<note5>\n<description>Combine the observations into a concise hypothesis: a uniform translation of colored pixels, followed by a consistent grouping into a small square block. Use that hypothesis to predict the output size and the block’s placement and color.</description>\n<example>So, if you observe a consistent shift direction and a consistent square block size across examples, apply the same shift and block-size rule to the test input: move the colored pixels by the inferred amount and place them into the predicted small square, preserving the block color.</example>\n</note5>","<note1>\n<description>Locate the single non-background pixel(s) and treat its color as the key property to reproduce. When the grid contains one colored cell and the rest is background, that color is usually the element the transformation emphasizes.</description>\n<example>Imagine a 7×7 grid with a single green cell at some location and black everywhere else. The natural first step is to record that green color as the candidate to be used in the output rather than trying to reconstruct the whole original pattern.</example>\n</note1>\n\n<note2>\n<description>Check whether the output is a uniform square tile made from that color. Many ARC tasks compress the input into a small, consistent square whose every cell is the same as the chosen color.</description>\n<example>For instance, if the chosen color is blue, expect an output that is a small square (e.g., 2×2) where every cell is blue. This indicates the transformation is about producing a compact, uniform representation of the color rather than copying the original shape or position.</example>\n</note2>\n\n<note3>\n<description>Decide how the square size is chosen from the input. A common rule is to base the side length on the input's row or column count (for example, the smaller of the two dimensions), which yields a fixed square size for a given grid.</description>\n<example>Given an input that is 6 rows by 6 columns, a typical selection is a square whose side equals the smaller dimension (6). That gives a predictable square size you can apply to other inputs with the same property.</example>\n</note3>\n\n<note4>\n<description>Verify that the color is preserved exactly and that background cells are ignored in the output. The transformation often copies the color value unchanged and does not alter its hue or value when forming the new square.</description>\n<example>If the chosen color is orange, the resulting square should be filled with orange and not remapped to another color. Confirm by checking that the output's color matches the input's colored cell rather than some derived color.</example>\n</note4>\n\n<note5>\n<description>Use a simple validation procedure: pick the non-background color, compute the square side from the input dimensions, and produce a filled square of that color. If this reproduces the example outputs, apply the same procedure to the test case.</description>\n<example>As a quick check, take an input with one colored cell and a uniform background; compute the square side from the grid size, create an n×n square filled with the colored cell's value, and compare it to the example outputs to confirm the rule.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Start by locating the single non-background color in the input and record its color value; this color is the candidate that determines the output. When there is exactly one such color across the whole grid, it usually serves as the key attribute for the transformation.</description>\\n<example>Imagine a grid that is mostly black except for one blue pixel; treat \\\"blue\\\" as the important color to track. If the grid contained several different colored pixels, you would need to look for a different selection rule instead.</example>\\n</note1>\\n\\n<note2>\\n<description>Count how many cells hold that chosen color in the input (i.e., the total number of occurrences). The count is a numeric quantity that often determines the size or shape of the output.</description>\\n<example>For example, if the chosen color appears three times in the input, that count (3) is a simple numeric parameter you can use to decide how big the output should be.</example>\\n</note2>\\n\\n<note3>\\n<description>Check whether the output preserves the original color by filling an entire square (or rectangle) with that color. Many tasks convert the count into a compact square block whose side length is derived from the count.</description>\\n<example>If the count is 4, a natural output shape is a 4×4 square filled with the chosen color; if the count is 2, a 2×2 filled square would be the corresponding compact representation.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide how the square size is computed from the count: try simple numeric relationships such as using the count directly, using the count minus a fixed offset, or using a different mapping (e.g., square root, ceiling, floor). Test which numeric mapping fits the example pairs before applying it to the test.</description>\\n<example>For instance, if counts in the examples are 2 and 4 and the outputs are 2×2 and 4×4, the mapping is \\\"use the count as the side length.\\\" If you instead saw counts 1 and 3 and outputs 1×1 and 3×3, the same simple mapping holds.</example>\\n</note4>\\n\\n<note5>\\n<description>After forming a hypothesis, apply it to the test input: identify the non-background color, compute the side length from its count using your chosen numeric rule, and produce a filled square of that size in the chosen color. Finally, verify consistency with the examples and adjust the numeric rule if necessary.</description>\\n<example>So, for a test grid where a color appears twice, use your chosen rule (for example, \\\"the side length equals the count\\\") to build a 2×2 filled square with that color; if that reproduces the pattern seen in the training examples, the rule is likely correct.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by locating the non-background color(s) in the input. If exactly one color appears, that color is usually the anchor for the transformation and will be used to fill the output.</description>\\n<example>Imagine a grid that contains only zeros except for a single red pixel. The red pixel is the only colored element, so it is the natural candidate to drive any change in the output.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the output dimensions to the input dimensions to detect a consistent scaling factor. If the output is a fixed fraction of the input in both directions, that fraction is likely the scaling applied.</description>\\n<example>For example, if an input of size 6×6 produces an output of size 3×3, the output is half the input in each dimension; if a 5×5 input becomes 2×2, the factor is 2/5. Noting that factor helps you predict the output size for other inputs.</example>\\n</note2>\\n\\n<note3>\\n<description>Examine the arrangement of the output: does it form a compact filled region (a square, filled rectangle, or a small motif)? Many tasks compress the input into a single, uniformly filled block.</description>\\n<example>If the output shows a small, solid block (every cell the same color), then the transformation is likely to “collapse” the input into a compact filled region rather than preserving its original shape or scattered pixels.</example>\\n</note3>\\n\\n<note4>\\n<description>Check whether the output preserves the original color(s) or replaces them. If outputs always use the same color(s) as the input’s non-background pixels, the rule is to keep those colors and not introduce new ones.</description>\\n<example>If the input has one blue pixel and the output is a solid blue block, the rule is “use the input’s colored pixels to color the compressed block.” This keeps the identity of the color consistent across examples.</example>\\n</note4>\\n\\n<note5>\\n<description>Use the training pairs to infer the exact mapping (which input pixels are selected, how they are arranged, and how the grid size changes) and then apply that same mapping to the test input. Avoid assuming extra rules—only add complexity if examples require it.</description>\\n<example>With a few examples showing how a single colored pixel becomes a compact block of the same color at a consistent scale, you can apply that same mapping to a new input that contains multiple pixels of the same color: pick the pixels, compress them to the same block size, and color the block consistently with the input.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the single non-background color that is present in the input. When one color appears only once or in a small, consistent set of pixels across examples, it is usually the element being transformed.</description>\\n<example>Imagine a mostly black grid with one red pixel. That red pixel is the likely focus of the transformation because it is the only color that differs from the background and appears consistently in the examples.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the non-background color is preserved across the transformation: if its value and shape remain the same but its placement changes, the rule is a relocation or recoloring of the object rather than a change of color or shape.</description>\\n<example>If the input has a blue dot and the output shows a blue dot in a different position but still blue, then the operation is moving the blue dot (or copying it) rather than converting it to another color.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare the sizes of input and output grids to detect a consistent scaling factor. A repeated change in the overall dimensions (for example, the output being a smaller, square grid) suggests a uniform scale applied to the whole grid.</description>\\n<example>If every input is larger than the corresponding output and the outputs are square, try dividing the output’s side by the input’s side to see whether the same integer factor explains all examples.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide how the transformed object is placed inside the new grid: is it centered, aligned to a corner, or tiled? The placement rule (centered vs. corner-aligned) is a separate step from the scaling and must be applied consistently.</description>\\n<example>After computing a smaller square from the input, check whether the preserved object appears at the grid center or at a particular corner in the outputs; that tells you whether to center or align the object when building the test output.</example>\\n</note4>\\n\\n<note5>\\n<description>Combine the observations into a simple pipeline: identify the object color, apply the discovered scale, and place the object according to the observed alignment rule. Apply this pipeline to the test input to produce the output.</description>\\n<example>First, locate the unique color in the test input. Then compute the smaller square size from the scale factor you inferred. Finally, place that color according to the center/corner rule you observed in the examples and fill the rest of the smaller square with the background color.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the single non-background color and treat it as the \\\"seed\\\" for the transformation. This color is usually the only one that changes between input and output and determines the new object's color.</description>\\n<example>Imagine a grid with one blue pixel and a sea of zeros; the output will reuse that blue as the color of the new shape. Identifying the seed avoids confusing background noise with the meaningful element.</example>\\n</note1>\\n\\n<note2>\\n<description>Check the spatial relationship between the seed and the rest of the grid: if the seed is near a corner or edge, the transformation often preserves that corner/edge placement. The output's position is usually aligned with the seed's relative location.</description>\\n<example>If the seed sits in the top-left corner, expect the output to be placed in a corner of the output grid rather than shifted elsewhere. This keeps the transformation consistent across examples.</example>\\n</note2>\\n\\n<note3>\\n<description>Observe the size of the output object: many tasks replace a sparse input with a small uniform block (commonly a 2×2 square). The block is filled with the seed color and is compact, so treat it as a single filled tile.</description>\\n<example>Given a scattered set of colored pixels, the output may be a single filled 2×2 square of the same color. This indicates the solver is collapsing the input into one small, uniform patch.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide whether the transformation is applied to the whole grid or only to the seed's color by checking whether other colors are preserved in the outputs. If only one color changes, the rule is color-based rather than spatial.</description>\\n<example>If every training output contains only the seed color and nothing else, then the rule is to replace the grid with a block of that color. That tells you not to expect new shapes or other colors in the result.</example>\\n</note4>\\n\\n<note5>\\n<description>Form a minimal hypothesis (identify seed color, keep corner/edge placement, replace by a small uniform block) and apply it to the test input; then validate it against the examples. If it reproduces the example outputs, apply the same steps to the test grid.</description>\\n<example>Take the seed color, place a small uniform block at the seed's corner/edge, and fill it with that color. If that matches the example outputs' behavior, the same procedure will produce the test output.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the unique non-background color(s) in the input and treat them as the elements that drive the transformation. This is effective because many ARC tasks compress or repeat the information carried by a small set of colored pixels while discarding the surrounding background.</description>\\n<example>Imagine a grid where only one color appears and it sits near a corner; that single color is the element you should track. If you see several distinct colors, still focus on the non-background ones as the source of the rule rather than the empty space.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the minimal bounding rectangle that contains all non-background pixels (the smallest axis-aligned box that covers every colored cell). This isolates the pattern to transform and removes irrelevant empty rows and columns.</description>\\n<example>If colored pixels appear at coordinates (0,0),(0,2),(1,1) then the bounding rectangle spans rows 0..1 and columns 0..2, so you should consider only that 2×3 subgrid as the pattern to analyze.</example>\\n</note2>\\n\\n<note3>\\n<description>Inside that rectangle, check whether the pattern is uniform (every cell in the box is the same color) or contains multiple colors. The transformation typically depends on whether the rectangle is uniform or not.</description>\\n<example>For a 2×2 rectangle where all four cells are color A, the rectangle is uniform; for a 2×2 rectangle with two A's and two B's, the rectangle is non-uniform. Treat these two cases differently when inferring the next step.</example>\\n</note3>\\n\\n<note4>\\n<description>When the bounding rectangle is uniform, the intended operation is often to compress it into a smaller uniform square (for example, 2×2) while preserving the single color. Think of this as \\\"compress the uniform block into a single, smaller uniform block.\\\"</description>\\n<example>If the bounding rectangle is a 3×3 block of color X, a common transformation is to replace that 3×3 with a 2×2 block of X, so the information is kept but in a smaller uniform square.</example>\\n</note4>\\n\\n<note5>\\n<description>If the rectangle is not uniform, the examples usually show a different, simple operation (for instance, a single-cell output). In that case, choose a single representative cell (often the top-left cell of the rectangle) and map it to the output grid.</description>\\n<example>For a non-uniform 2×2 rectangle with values [A B; C D], many ARC rules would produce a single-cell output whose color is taken from the rectangle's top-left cell (A). This is a quick way to reduce a non-uniform pattern to one cell.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the unique non-background color that appears in the input. When a grid has exactly one non-background color, that color is the likely candidate to drive the transformation.</description>\\n<example>Imagine a grid with one pixel of color A on a black background; A is the only non-background element, so it is the natural focus for any transformation that depends on foreground color.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a consistent change in the spatial arrangement of that color across examples: does its location move, its shape change, or is it repeated in a new pattern? A consistent spatial rule (for example, relocation to a corner) indicates a positional transformation.</description>\\n<example>If every example shows the single colored pixel in the top-left of the output while the input had it elsewhere, that suggests a relocation rule that places the color consistently in a corner.</example>\\n</note2>\\n\\n<note3>\\n<description>Consider whether the transformation preserves shape and color but changes size or density: a common operation is to replace a single pixel with a filled square block of the same color. This increases the foreground's prominence while keeping its color constant.</description>\\n<example>For instance, replacing a solitary red pixel with a 2×2 red block keeps red as the color but makes the red area four times larger and more visually dominant.</example>\\n</note3>\\n\\n<note4>\\n<description>Check how the output grid size relates to the input: sometimes the output is a fixed small square regardless of input dimensions. If so, the transformation normalizes the canvas size before applying the shape change.</description>\\n<example>If several different-sized inputs all become the same small square in the outputs, that indicates a resizing step that makes the output canvas uniform before further operations.</example>\\n</note4>\\n\\n<note5>\\n<description>Combine the observations into a concise procedure: normalize the canvas, identify the unique foreground color, then apply the spatial rule (e.g., move the color to a corner) and the shape rule (e.g., fill a square). This sequence explains how a varied set of inputs can map to a consistent output.</description>\\n<example>Take a 7×7 input with one colored pixel: first shrink/normalize the canvas, then move that color to the chosen corner, and finally fill it with the same color in a square to produce the final pattern.</example>\\n</note5>\",\n \"<note1>\\n<description>Scan the input for any non-background pixels and record their color and coordinates. The transformation usually acts on the smallest set of pixels that is non-background, so identifying that set is the first step.</description>\\n<example>Imagine a grid that is all black except for two pixels, both colored red. Mark those two red pixels and note they are the only non-background elements; that small set is what you will transform.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the output preserves the original color(s). If the output contains only the same colors as the input (and no new colors), the rule is likely a geometric operation that moves or repeats existing pixels rather than recoloring them.</description>\\n<example>If the input has blue pixels and the output has only blue pixels (no green or other colors), then you can focus on how the blue pixels were repositioned or repeated rather than worrying about color changes.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a uniform scaling or tiling of the input pattern: many tasks replace the whole input by a single, smaller copy of the pattern. If the output size is a simple multiple of the input, test whether the output equals that scaled copy of the input pattern.</description>\\n<example>For instance, if the input is 3×2 and the output is 2×2, check whether the output is exactly one copy of the input pattern (possibly after a uniform reduction or cropping) rather than a new arrangement.</example>\\n</note3>\\n\\n<note4>\\n<description>When a candidate rule fails, try simple geometric transforms: horizontal/vertical reflections, 90° rotations, or a 180° flip. These transforms preserve colors and pixel counts but change orientation, so test them to see if they explain the mapping between input and output.</description>\\n<example>If a single colored pixel appears in a different quadrant in the output, that suggests a 90° rotation or reflection; apply that transform mentally to the input to see if it matches the output.</example>\\n</note4>\\n\\n<note5>\\n<description>After you identify the operation, validate it by applying it to every training example and confirming it reproduces each output exactly. If any example fails, adjust whether you are using a copy, a transform, or a different reduction rule.</description>\\n<example>Take your hypothesized rule and run it on each training pair; if every output matches, the rule is consistent; if one example doesn’t match, try a different small transform or a different selection of pixels to test.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the single non-background color that appears in the input; that color is the one being transformed. When a grid contains only one non-background color, the transformation is typically about how that color is arranged rather than about other colors.</description>\\n<example>Imagine a grid with a single red pixel somewhere inside a larger black background. The red pixel is the only color of interest, so focus on how red is handled in the outputs rather than on black or any other colors.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the transformation preserves the original color value. Many ARC tasks recolor objects consistently, so the color used in the output should match the color found in the input.</description>\\n<example>If the input has a blue pixel, the output will usually be filled with blue as well; you should treat color identity as invariant when inferring the rule.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare the sizes of input and output grids to detect a consistent scaling factor. A uniform factor across examples (often an integer) tells you whether the transformation is a uniform scaling or cropping of the original pattern.</description>\\n<example>If every example’s output is smaller in both dimensions by the same factor, you can infer a uniform scaling; use that factor to predict the output size for the test case.</example>\\n</note3>\\n\\n<note4>\\n<description>Examine how the colored pixels are repositioned inside the transformed region: are they preserved at the same relative coordinates, or are they shifted to a fixed corner or center? This reveals whether the transformation is a pure resize, a crop, or a translation.</description>\\n<example>For instance, if colored pixels remain at the same relative positions after the change, the rule is a resize; if they move to the top-left corner, the rule includes a translation in addition to resizing.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple invariants to validate your hypothesis: count the colored pixels and check that the output grid contains the same number of them (possibly arranged differently). If counts and positions are preserved under your inferred rule, it is likely correct.</description>\\n<example>Suppose the input has three colored pixels and your candidate rule produces a smaller grid that still contains three colored pixels arranged the same way; that consistency supports the rule and helps avoid overfitting to a single example.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by finding the single non-background color that is unique across the input examples. When one color stands out from the uniform background, that color is usually the one the task is about.</description>\\n<example>Imagine a grid of zeros with exactly one pixel colored red. Because every example uses a single distinct color, treat that red as the salient color and ignore the zeros for the transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide whether the transformation moves or copies the salient color: check whether the color appears in the same position or in a different location in the outputs. If the examples preserve the color’s location, the operation is a copy; if they move it, the operation is a relocation.</description>\\n<example>If the single colored pixel in the input remains in the same spot in the output (but the output shows more of that color), the rule is a local replication rather than a translation of the pixel.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a fixed local pattern that the salient color is being placed into. Many tasks replace a small, identical block (for example a 2×2 square) with copies of the salient color, so the output’s shape is a small uniform block rather than a scattered or irregular shape.</description>\\n<example>When you see the same color repeated in a compact square in the outputs, that suggests the rule is “fill a fixed 2×2 block” rather than “draw an irregular shape” or “move pixels around.”</example>\\n</note3>\\n\\n<note4>\\n<description>Confirm that the transformation does not alter the color value or introduce other colors; the replacement block should be uniformly the salient color. This helps you know which color to use when constructing the output.</description>\\n<example>If the colored pixel in the input is blue and the output shows only blue in the filled block, then the rule preserves color identity and does not add or change colors.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple consistency checks: count the non-background pixels in the input and compare to the number of colored cells in the output, and ensure every output cell has the same color. These checks quickly reveal whether the rule is a fixed-size fill or a more complex operation.</description>\\n<example>If the input has one colored pixel and the output shows four identical colored cells arranged in a small square, that is strong evidence the task copies the color into a fixed local block rather than transforming the pixel’s shape or position.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the seed color by locating the color that appears in the input but is absent from the output; this color is the element being propagated. When one non-background color is the only one that changes, it usually acts as the source for the transformation.</description>\\n<example>Imagine an input with a single red pixel and a black background, and the output contains only red. The red pixel is the seed: it is the color that the output is built from. Identifying this seed first narrows down the possible operations (copy, fill, repeat, etc.).</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the output is a single-color block (all cells share the same color). A uniform output suggests the transformation is a replication or filling of the seed color rather than a rearrangement of different colors.</description>\\n<example>For instance, if an input has one green pixel and the output shows every cell green, the operation is simply “make every cell the seed color.” This tells you to focus on how many cells to create, not on moving or recoloring existing shapes.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a small, fixed square tile (commonly 2×2) as the output shape across examples; many ARC tasks use the same compact square size for the result. Use the examples to infer the tile size before applying it to the test case.</description>\\n<example>If each example’s output is a 2×2 block of one color, then the intended output shape is a 2×2 square. Treat that square as the canvas to fill with the seed color when solving the test case.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide whether the seed’s position in the input matters: if the seed is unique and the output is uniform, the rule may ignore spatial location and only use the color. If multiple seeds exist, consider whether the rule preserves their arrangement or reduces them to a single color.</description>\\n<example>When there is exactly one non-background pixel, its exact coordinates often do not influence the final output; the important fact is “which color appears.” If multiple colored pixels appear, ask whether they are merged into one color or kept separate in the output.</example>\\n</note4>\\n\\n<note5>\\n<description>After inferring the seed color and the fixed square size, construct the output by filling that square entirely with the seed color and leaving all other cells unchanged. This final step confirms the transformation is a uniform block replication.</description>\\n<example>Given a determined seed color and a 2×2 target, produce a 2×2 grid where every cell equals the seed color; the rest of the grid remains as in the input. This yields a compact, consistent output that matches the pattern seen in the examples.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the single non-background color that is present in the input. If exactly one color appears (besides the background), that color is the candidate to be propagated into the output.</description>\\n<example>Imagine a grid where every cell is background except one red pixel; that red is the only meaningful element and should be the color you consider for the output. If several colors appear, you must instead look for a secondary, consistent pattern (e.g., repeated pixels of a single color) rather than the background.</example>\\n</note1>\\n\\n<note2>\\n<description>Check for a compact, regular shape that repeats across the grid: many tasks use a small, repeated motif (a 2×2 block or a 2×1 bar) as the atomic unit. Identifying that motif tells you how the color should be arranged in the output.</description>\\n<example>For instance, if you see identical two-cell bars in multiple places, treat each bar as an atomic tile and plan the output using that tile's dimensions. If instead you see isolated single pixels, the atomic tile may be a single cell rather than a small block.</example>\\n</note2>\\n\\n<note3>\\n<description>Count the number of such atomic tiles in the input (e.g., count occurrences of the motif or the color). That count often determines how many copies of the tile appear in the output.</description>\\n<example>If the motif appears three times in the input, expect three copies of the tile in the output; if it appears once, expect one copy. Counting is straightforward when the motif is uniform and repeated; if the motif is sparse, use the color frequency as a proxy.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide the spatial arrangement of the copies: they are typically placed in a compact, regular layout (often a 2×2 arrangement) and may be filled with the motif color while background cells remain background. The exact arrangement is consistent across examples.</description>\\n<example>Given four copies, a common choice is a 2×2 grid of tiles; each tile filled with the motif color produces a small, uniform block. If the number of copies does not match a 2×2 arrangement, the examples will show which smaller packing (1×2, 2×1, or single-cell) is used.</example>\\n</note4>\\n\\n<note5>\\n<description>Assemble the final grid by combining the tiles: the output's dimensions equal the tile size multiplied by the number of tiles along each axis, and every tile is filled with the motif color while background cells are left as background. This yields a small, consistent output that matches the training examples.</description>\\n<example>For example, if each tile is 2×2 and you need two tiles along one axis and one along the other, the output will be 4×2 with the motif color occupying the tile cells and background elsewhere. A quick sanity check: the number of motif-colored cells in the output should equal the number of tiles multiplied by the tile area.</example>\\n</note5>\",\n \"<note1>\\n<description>Focus first on locating the object: find the color(s) that are not the background and determine the smallest rectangle that contains them. This bounding box isolates the relevant pixels and ignores surrounding empty space.</description>\\n<example>Imagine a grid with a single red pixel at (row 1, col 2). The bounding box is simply that single pixel; if there are two red pixels at (1,2) and (4,5), the box spans rows 1–4 and cols 2–5. Once you have that rectangle you know which area to examine further.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the bounding box is square: many ARC tasks that crop an object will produce a square output. A square is defined by equal height and width, so compare the box’s row-span and column-span before proceeding.</description>\\n<example>If your bounding box covers 2 rows and 2 columns it is a 2×2 square; if it covers 3×3 it is a 3×3 square. If the box is rectangular (e.g., 2×3), the task may still crop to the square region inside it (the smaller of the two dimensions).</example>\\n</note2>\\n\\n<note3>\\n<description>Observe how color is treated inside the cropped square: often the object’s color is preserved and fills the entire square, while any other colors (or background) inside the box are removed. The transformation typically replaces the interior with one uniform color.</description>\\n<example>For instance, if the bounding box contains a blue pixel and some black pixels, the output square will be entirely blue. If the box contains multiple colored pixels, the rule may keep the dominant object color and erase other colors.</example>\\n</note3>\\n\\n<note4>\\n<description>Pay attention to orientation and placement: the cropped square is usually placed in a consistent location (often the top-left) and the pixels inside are copied or mirrored in a predictable way. Confirm whether the crop is a direct copy or a rotated/reflected copy by checking corresponding positions across examples.</description>\\n<example>If the original pixel is at the lower-right of the bounding box, the output square may show that color at the lower-right as well (indicating a direct copy), or it may show it at the upper-left (indicating a mirror or rotation). Compare the relative positions of the colored pixels in input vs output to decide which.</example>\\n</note4>\\n\\n<note5>\\n<description>Use quick heuristics to avoid mistakes: prefer the smallest enclosing rectangle that contains every non-background pixel, and if the box is rectangular crop to the square defined by the smaller side. Also, if multiple colors appear inside the box, use the color that best represents the object (often the most frequent non-background color) and ignore stray pixels.</description>\\n<example>If a box spans 2 rows and 3 columns, the square crop will be 2×2 (the smaller dimension). If the box contains two red pixels and one blue pixel, choose red as the representative color and fill the square with that color, then check whether the square is placed top-left or mirrored by comparing the examples.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the active color by scanning the grid for the smallest non-zero color (the first non-background pixel you encounter when reading left-to-right, top-to-bottom). This gives you the color to use in the transformation because the examples consistently use the earliest non-background color.</description>\\n<example>Imagine a grid that contains only zeros and a single 2 in the top row; scanning finds 2 first, so that 2 is the candidate color for the output. If multiple colors appear, pick the one you would see first when moving across the grid.</example>\\n</note1>\\n\\n<note2>\\n<description>Check the spatial pattern of that color in the input: if it appears only once and in one corner, the transformation often preserves that single pixel's identity rather than moving or reshaping it. That tells you to keep the color's value and not to alter its position when forming the output.</description>\\n<example>If a lone red pixel sits at the top-left of the input, expect the output to use red as the primary color while leaving the pixel's identity intact rather than creating new shapes or relocating it.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare the input and output sizes to infer a scaling factor: many tasks replace the original grid with a smaller square whose side is the smallest non-zero color. This gives a direct mapping from the color value to the output dimensions.</description>\\n<example>If the smallest non-zero color is 3, expect the output to be a 3×3 grid; if it is 4, expect a 4×4 grid. Use this rule to compute the output size from the color you identified.</example>\\n</note3>\\n\\n<note4>\\n<description>Form the output by filling the computed square with the identified color. The examples typically replace the entire output grid with that single color, producing a uniform square rather than mixing colors or preserving original positions.</description>\\n<example>Given a color 3 and a 3×3 target, produce a grid where every cell is 3 so the output is a solid square of that color.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for common pitfalls: do not use the background color (0), do not average or blend colors, and do not try to preserve the original coordinates—transformations of this kind usually ignore input layout and produce a new uniform square. If you see multiple non-zero colors, still use the first one you encounter in reading order.</description>\\n<example>If you see both a 2 and a 7 in the input but the 2 appears earlier in reading order, pick 2 and make a square whose side equals 2; do not try to keep the original arrangement or combine the two values.</example>\\n</note5>\",\n \"<note1>\\n<description>Scan each input for the smallest contiguous block of non-background cells that contains all non-background colors. This bounding box isolates the meaningful pattern and ignores surrounding empty space.</description>\\n<example>For a grid with a single colored pixel at (r,c), the bounding box is just that pixel. If two pixels are at (r,c) and (r+1,c), the bounding box is the 2×1 rectangle covering both rows and columns of those pixels.</example>\\n</note1>\\n\\n<note2>\\n<description>Reduce that bounding box to the minimal rectangle that still contains every non-background pixel; that rectangle is the candidate motif. Do not shrink it further unless the examples show such reductions.</description>\\n<example>If the bounding box is 2×3 but only one row actually contains colored cells, check whether the task keeps the full rectangle or collapses to the active row. If examples always keep the full rectangle, keep it.</example>\\n</note2>\\n\\n<note3>\\n<description>When producing the output, preserve the motif's colors and their relative arrangement, but often the task expects a canonical small square (a fixed small side length) rather than the original bounding box. Use the minimal square that can accommodate the motif's width or height.</description>\\n<example>A 2×1 vertical motif can be embedded into a 2×2 square by placing it in one corner and filling the remaining cells with the background color; a 1×2 horizontal motif would be placed in a 2×2 square similarly.</example>\\n</note3>\\n\\n<note4>\\n<description>Fill any cells outside the motif with the background color (typically 0) so the output is a clean, self-contained image of the motif. This makes the transformation unambiguous and consistent across examples.</description>\\n<example>If the motif is 2×2, and the required output canvas is 4×4, put the 2×2 motif in one corner and set all other cells to 0 so the motif is clearly visible.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the same transformation rule to the test input: compute the minimal bounding box, reduce it to the minimal rectangle that contains all non-background pixels, place it into the required small square (or the minimal square that fits), and fill remaining cells with the background color. Verify consistency with the examples before finalizing.</description>\\n<example>For a test grid with multiple colored pixels, first find their minimal rectangle; then place that rectangle into the fixed-size square (or the minimal square that fits), and fill any leftover cells with 0 to produce the output.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by locating the single non-background pixel(s) in the input and compare their coordinates to the output. If every non-background pixel appears in the same relative position in the output, the transformation is a translation (shift) rather than a reshape or recoloring.</description>\\n<example>For instance, if an input has a colored pixel at (row 0, column 1) and the output shows that same color at (row 0, column 0), you can infer a leftward translation. Repeating this check for all colored pixels confirms whether a uniform shift is being applied.</example>\\n</note1>\\n\\n<note2>\\n<description>Check how many colored pixels become a single contiguous block in the output. If the output contains several adjacent colored cells that were not present in the input, the rule likely groups or collapses multiple input pixels into one connected region.</description>\\n<example>Imagine an input with two isolated colored pixels and the output showing one contiguous block of the same color; this indicates the solver combined or merged those pixels into a single object rather than leaving them separate.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a fixed size for the resulting block: many ARC tasks produce a small, consistent square or rectangle. Determining whether the output is always square (same width and height) helps you predict the output dimensions.</description>\\n<example>If every example output is a 2×2 block of the same color, then the transformation consistently produces a 2×2 square, so you should expect a 2×2 output for a new input as well.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide whether the output is filled with a single color or whether multiple colors are preserved. If the input has several different colors but the output uses only one, the rule collapses colors; if multiple colors remain, they are likely preserved in the same relative arrangement.</description>\\n<example>For example, if an input contains red and blue pixels but the output shows only red in a compact block, that indicates a color-selection or collapse step. Conversely, if blue appears in the output in the same relative position as in the input, colors are being preserved rather than discarded.</example>\\n</note4>\\n\\n<note5>\\n<description>Combine the observations into a concise hypothesis: a uniform translation of colored pixels, followed by a consistent grouping into a small square block. Use that hypothesis to predict the output size and the block’s placement and color.</description>\\n<example>So, if you observe a consistent shift direction and a consistent square block size across examples, apply the same shift and block-size rule to the test input: move the colored pixels by the inferred amount and place them into the predicted small square, preserving the block color.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the single non-background pixel(s) and treat its color as the key property to reproduce. When the grid contains one colored cell and the rest is background, that color is usually the element the transformation emphasizes.</description>\\n<example>Imagine a 7×7 grid with a single green cell at some location and black everywhere else. The natural first step is to record that green color as the candidate to be used in the output rather than trying to reconstruct the whole original pattern.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the output is a uniform square tile made from that color. Many ARC tasks compress the input into a small, consistent square whose every cell is the same as the chosen color.</description>\\n<example>For instance, if the chosen color is blue, expect an output that is a small square (e.g., 2×2) where every cell is blue. This indicates the transformation is about producing a compact, uniform representation of the color rather than copying the original shape or position.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide how the square size is chosen from the input. A common rule is to base the side length on the input's row or column count (for example, the smaller of the two dimensions), which yields a fixed square size for a given grid.</description>\\n<example>Given an input that is 6 rows by 6 columns, a typical selection is a square whose side equals the smaller dimension (6). That gives a predictable square size you can apply to other inputs with the same property.</example>\\n</note3>\\n\\n<note4>\\n<description>Verify that the color is preserved exactly and that background cells are ignored in the output. The transformation often copies the color value unchanged and does not alter its hue or value when forming the new square.</description>\\n<example>If the chosen color is orange, the resulting square should be filled with orange and not remapped to another color. Confirm by checking that the output's color matches the input's colored cell rather than some derived color.</example>\\n</note4>\\n\\n<note5>\\n<description>Use a simple validation procedure: pick the non-background color, compute the square side from the input dimensions, and produce a filled square of that color. If this reproduces the example outputs, apply the same procedure to the test case.</description>\\n<example>As a quick check, take an input with one colored cell and a uniform background; compute the square side from the grid size, create an n×n square filled with the colored cell's value, and compare it to the example outputs to confirm the rule.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[8, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]], \"output\": [[8, 8], [8, 8]]}, {\"input\": [[0, 7, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]], \"output\": [[7, 7], [7, 7]]}, {\"input\": [[5, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]], \"output\": [[5, 5], [5, 5]]}]"},"test":{"kind":"string","value":"[{\"input\": [[5, 5, 0, 0, 0, 0, 0], [0, 5, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]], \"output\": [[0, 0, 5, 5], [0, 0, 5, 5], [5, 5, 5, 5], [5, 5, 5, 5]]}]"},"source":{"kind":"string","value":"barc_heavy"},"prompt":{"kind":"string","value":"You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n8 0 0 0 0 0\n0 0 0 0 0 0\n0 0 0 0 0 0\n0 0 0 0 0 0\n0 0 0 0 0 0\n0 0 0 0 0 0\n```\n\nOutput:\n```\n8 8\n8 8\n```\n\n## Example 2\nInput:\n```\n0 7 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n```\n\nOutput:\n```\n7 7\n7 7\n```\n\n## Example 3\nInput:\n```\n5 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n```\n\nOutput:\n```\n5 5\n5 5\n```\n\n# Test Problem:\n```\n5 5 0 0 0 0 0\n0 5 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n```"},"answer":{"kind":"string","value":"```\n0 0 5 5\n0 0 5 5\n5 5 5 5\n5 5 5 5\n```"},"num_tokens":{"kind":"number","value":608,"string":"608"}}},{"rowIdx":98,"cells":{"abstraction_prompt":{"kind":"string","value":"<|im_start|>user\nDeveloper: # ARC HINT GENERATOR\n\n## Role & Goal\nYou are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that helps the user discover the core transformation principle for themselves without revealing the answer.\n\nBegin with a concise checklist (3-7 bullets) of what you will do; keep items conceptual, not implementation-level.\n\n---\n\n## Hint Generation Strategy\n1. **Compare** the input and output grids for each example. Identify the shared transformation pattern that allows the input grid to be converted into the output grid.\n2. **Identify the Core Principle**: Review the problem description and ground-truth solution to fully discern the key transformation rule. Break it down into its essential operations (e.g., object completion, pattern repetition, symmetry, gravity), paying close attention to properties such as object count, shapes, colors, sizes, symmetry, repetition, relative positioning, and broader grid-level patterns.\n3. **Craft a Targeted Hint**: Generate a hint that guides the user toward the core insight needed to solve the problem. The hint should assist the user during their attempt without revealing the solution.\n4. Structure each note using the template below:\n - **Description** (up to 3 sentences): Explain the concept, when and why it applies, and why it is effective. Include any relevant general formula or principle in its most general form.\n - **Example** (up to 6 sentences): Present a worked example covering all aspects of the description, using a simplified yet representative scenario (not necessarily from the current problem).\n - Optionally, include **Heuristics** or **Pitfalls** in the note where relevant.\n - Focus on methodologies and core principles over specific calculations or problem details.\n - Ensure each hint applies broadly—at least 80% of analogous problems.\n\nAfter generating a hint, verify that no specifics of the solution are revealed, and that the hint remains at the level of guiding the approach.\n\n### Output Format\nProduce a **sequence of 5** notes in the structure:\n<note1>\n<description>...</description>\n<example>...</example>\n</note1>\n<note2>\n<description>...</description>\n<example>...</example>\n</note2>\n...\n\n### Design Guidelines\n- Clarity: Use precise language and correct sentence structure.\n- Atomicity: Each note addresses one recognizable sub-problem.\n- Self-containment: All information needed to understand the idea and its application is within the note.\n- Generalizability: Avoid problem-specific details or variables.\n- Transferability: Notes should apply across a class of problems.\n- Distinctness: Each note addresses a distinct principle.\n\n---\n\n## Guidelines\n- **Guide, Don't Solve**: Illuminate the approach, not the answer. Emphasize what to observe or consider.\n- **Specific yet Abstract**: Use concrete grid details (e.g., \"note the relationship between the blue and red pixels\") to ground abstract patterns (e.g., \"think about one color containing another\").\n\nValidate your generated hint: confirm it is self-contained, actionable, and nondirective. If any aspect is too revealing, revise before finalizing.\n\n---\n\n## Inputs\n### Problem Description\nA full ARC problem, including input/output pairs for training and testing.\n\nYou will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n6 1 6 6\n9 1 9 9\n6 1 6 6\n6 1 6 6\n2 1 2 2\n6 1 6 6\n6 1 6 6\n6 1 6 6\n1 1 1 1\n6 1 6 6\n1 1 1 1\n6 1 6 6\n4 1 4 4\n6 1 6 6\n6 1 6 6\n1 1 1 1\n6 1 6 6\n6 1 6 6\n6 1 6 6\n6 1 6 6\n0 1 0 0\n6 1 6 6\n```\n\nOutput:\n```\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n```\n\n## Example 2\nInput:\n```\n6 9 6\n1 9 1\n6 9 6\n6 9 6\n6 9 6\n3 9 3\n6 9 6\n6 9 6\n6 9 6\n6 9 6\n2 9 2\n6 9 6\n5 9 5\n6 9 6\n7 9 7\n6 9 6\n6 9 6\n6 9 6\n6 9 6\n9 9 9\n6 9 6\n9 9 9\n6 9 6\n```\n\nOutput:\n```\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 4 0 7 0 1 0 8 0 8 0 0\n5 5 5 5 4 5 7 5 1 5 8 5 8 5 5\n0 0 0 0 4 0 7 0 1 0 8 0 8 0 0\n0 0 0 0 4 0 7 0 1 0 8 0 8 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0\n0 0 0 0 0 0\n```\n\n# Test Problem:\n```\n3 3 3 3 2 3 3 2 3 3\n3 3 3 3 2 3 3 2 3 3\n2 2 2 2 2 2 2 2 2 2\n3 3 3 3 2 3 3 2 3 3\n5 5 5 5 2 5 5 2 5 5\n3 3 3 3 2 3 3 2 3 3\n3 3 3 3 2 3 3 2 3 3\n4 4 4 4 2 4 4 2 4 4\n3 3 3 3 2 3 3 2 3 3\n```\n\n---\n\n\n# Generated Hint<|im_end|>\n<|im_start|>assistant\n"},"abstraction_prompt_length":{"kind":"number","value":1672,"string":"1,672"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>Look first for a continuous, uniform stripe that runs across an entire row or an entire column. Such a stripe is usually the structural divider that splits the grid into repeated blocks.</description>\n<example>Imagine a grid where every cell in row 3 is the same color while other rows vary. That full row is a natural horizontal divider; a similar vertical divider would be a column where every cell is the same color.</example>\n</note1>\n\n<note2>\n<description>Once you identify the divider, treat the grid as a tiled mosaic of blocks bounded by that stripe. The divider itself is not part of the blocks but separates them.</description>\n<example>If a vertical stripe runs down the middle, the grid becomes two vertical bands (left and right) of equal width; each band can then be seen as a block to inspect further.</example>\n</note2>\n\n<note3>\n<description>Compare corresponding cells inside each block (same row and same column within a block). If those corresponding positions consistently show the same color across blocks, that color is the block motif.</description>\n<example>For two identical-size blocks, check position (1,1) of both blocks, then (1,2), (2,1), etc. If every corresponding cell is the same color, you have found the repeating motif to extract.</example>\n</note3>\n\n<note4>\n<description>Form the output by taking one representative block (often the top-left) and producing a grid whose size equals that block's dimensions. This isolates the repeating unit without the divider.</description>\n<example>If the divider splits the image into four equal quadrants and each quadrant contains the same small pattern, extract the top-left quadrant as the output; its shape is the same as one quadrant.</example>\n</note4>\n\n<note5>\n<description>Be careful about ambiguous cases: confirm the stripe truly spans the whole row/column and that blocks are aligned and uniform. Also check for multiple candidate dividers before committing to one.</description>\n<example>If a row is mostly one color but has a few differing pixels, that row is unlikely to be the divider; prefer a stripe that is continuous across every cell. If several candidate dividers exist, verify which one yields identical block patterns across the grid.</example>\n</note5>","<note1>\n<description>Look for a vertical stripe of one color that occupies the same column(s) across many rows; that column often acts as a divider and separates the grid into left and right regions. Treat that column as a structural boundary rather than as part of the pattern you must preserve.</description>\n<example>Imagine a grid where every row has a single column filled with color A while the rest of the row varies. That column is a strong candidate for a vertical divider: it is consistent across rows and can be used to split the grid into two subgrids.</example>\n</note1>\n\n<note2>\n<description>After locating the divider, split the grid into the left and right subgrids and compare them side-by-side. Many puzzles use the same arrangement of colors on both sides, so the left and right halves become two candidate outputs.</description>\n<example>For instance, if the left half contains a repeating 3×3 motif and the right half has the same 3×3 motif in the same relative positions, then the left half is a natural candidate to extract and return.</example>\n</note2>\n\n<note3>\n<description>Choose the subgrid that is visually consistent across rows (i.e., the one that shows a repeated motif or a stable internal pattern) rather than the one that varies row by row. Consistency across rows is a strong signal of the intended output region.</description>\n<example>If the right half changes color in each row while the left half always shows the same arrangement of colors, prefer the left half because it is the more stable, repeating region.</example>\n</note3>\n\n<note4>\n<description>When producing the final output, keep the subgrid's original dimensions and use the subgrid's dominant color as the fill color. If the subgrid is uniform, the output should be a solid block of that color; if it contains multiple colors, use the most frequent color as the fill.</description>\n<example>For example, if the chosen subgrid is 4×5 and its most common color is B, create a 4×5 grid filled entirely with B so the output matches the subgrid's dominant appearance.</example>\n</note4>\n\n<note5>\n<description>Use simple checks to decide which side to extract: test for a single-column divider, for repetition of the same arrangement across rows, and for a majority color in the subgrid. Avoid choosing a side that is entirely the divider color or one that changes unpredictably.</description>\n<example>Quick heuristics: if one column is identical across all rows, split there and compare halves; if one half repeats the same pattern down the rows, that half is likely the intended output; if a half is mostly one color, use that color to fill the output.</example>\n</note5>","<note1>\n<description>Look for a single column or row that is uniformly one color across the whole grid; such a column/row usually acts as a divider that splits the image into repeated blocks. This is effective because a full-color stripe is an obvious structural feature that separates independent sub-images.</description>\n<example>Imagine a grid where column 4 is entirely green while the rest of the grid shows different patterns on each side. That green column is the divider: treat it as a boundary and ignore it when grouping cells into repeating blocks.</example>\n</note1>\n\n<note2>\n<description>After finding the divider, partition the grid into equal rectangular tiles on each side (for example, split width and height into n×n blocks). The divider itself should not be included in any tile; the tiles are the repeating sub-images that were separated by the stripe.</description>\n<example>If you have a 12×8 grid with a uniform column in the middle, split into two 6×8 halves. If the same uniform stripe appears again later, split again so you end up with a set of identical-size tiles (for example, four 3×4 tiles).</example>\n</note2>\n\n<note3>\n<description>Within each tile, find the most frequent color (the dominant color) and use that color as the tile's representative. This reduces each tile to a single color while preserving the tile's spatial arrangement.</description>\n<example>Suppose a 3×3 tile contains 8 blue cells and 1 red cell; the tile's representative color is blue. Do this for every tile so each tile becomes a single-color pixel in the output.</example>\n</note3>\n\n<note4>\n<description>Assemble the output by placing each tile's representative color in the same relative position as the tile in the input, preserving the original order and layout (top-to-bottom, left-to-right). The output grid dimensions equal the number of tiles in each direction.</description>\n<example>If you split the input into a 2×3 array of tiles, the output will be 2 rows by 3 columns where each output cell holds the dominant color of the corresponding input tile.</example>\n</note4>\n\n<note5>\n<description>Validate your result: the output should show a regular pattern of tile colors that matches the spatial arrangement of the tiles and should not contain the divider color. If the output is uniform, check that every tile had the same dominant color; if it is varied, confirm you split at the correct divider(s).</description>\n<example>If your output is a uniform grid of one color, re-check whether you split at the correct uniform column/row and whether every tile really contained that color as the majority. If any tile had a different dominant color, you likely split incorrectly or missed a stripe.</example>\n</note5>","<note1>\n<description>Look for a single color that appears as a complete, unbroken line across every row and column (a full-height and full-width stripe). That color is usually the background and is not part of the repeated objects you should extract.</description>\n<example>Imagine a 6×6 grid where column 3 and row 4 are entirely color X while every other cell is a different color. Column 3 and row 4 are the full stripes; color X is the background and should be removed before finding the repeating pattern.</example>\n</note1>\n\n<note2>\n<description>After removing the full stripes, the remaining area typically reveals a small tile (often 2×2) that repeats in a regular grid. Treat that tile as the unit of repetition rather than individual pixels.</description>\n<example>With stripes removed you might see a 4×4 region composed of four identical 2×2 blocks; each 2×2 block is the repeating tile. Work with that tile size when reasoning about what to extract.</example>\n</note2>\n\n<note3>\n<description>Within each tile, identify the dominant color (the one that fills most of the tile) and treat that as the representative color for the tile. Do not pick a color that only appears on the edges or as a minority inside the tile.</description>\n<example>If a 2×2 tile contains three cells of color A and one cell of color B, choose A as the tile’s representative. If a tile is uniform, its representative is simply that uniform color.</example>\n</note3>\n\n<note4>\n<description>Build the output by selecting one representative color per tile and arranging those representatives in the same order as the tiles (left-to-right, then top-to-bottom). The output’s dimensions equal the number of tiles across by the number of tiles down.</description>\n<example>If you find three tiles across and two down, create a 2×3 output whose cells are the chosen colors from the corresponding tiles. The relative order of tiles determines the arrangement of representatives.</example>\n</note4>\n\n<note5>\n<description>Watch for common pitfalls: stripes can be horizontal or vertical, and the tile may be 2×2 but the whole pattern can be larger. Also check that the representative color truly dominates the tile (not just adjacent to it).</description>\n<example>If stripes run vertically, remove them first before extracting tiles; if a tile has a single differing pixel, still prefer the majority color as the representative. If the tile is 2×2 but the full pattern is 4×4, you will produce a 2×2 output — so always base your tile count on the full pattern after removing stripes.</example>\n</note5>","<note1>\n<description>Look for a full-height stripe that is uniform across every row: a single column whose every cell is the same color. This column often acts as a divider separating distinct repeated regions.</description>\n<example>Imagine a grid where column 3 is entirely green while the other columns vary by row. That green column is a strong candidate for a vertical divider because it repeats in every row and is not part of any larger mixed region.</example>\n</note1>\n\n<note2>\n<description>Use that divider to split the grid into two vertical regions (left and right). Treat the left and right regions as the two halves you will compare.</description>\n<example>For instance, if you detect a vertical divider at column 2, split the grid into columns 1–2 and 3–end. Work with those two subgrids as the left and right halves for the next steps.</example>\n</note2>\n\n<note3>\n<description>Compare the two halves row-by-row: for each row, check whether the left half's cell equals the right half's cell at the same row position. This reveals which rows are consistent between the two halves.</description>\n<example>Take a row [A,B,C,D] split into left [A,B] and right [C,D]. If A==C and B==D the row is consistent; otherwise it is not. Do this independently for every row.</example>\n</note3>\n\n<note4>\n<description>Form the final grid by including only the rows that are consistent between the two halves; keep the original left-to-right ordering of those rows. The output's number of columns equals the width of one half.</description>\n<example>If only rows 2 and 5 match across both halves, your output will contain those two rows in the same order, with each output row composed of the left-half cells (or equivalently the matching right-half cells).</example>\n</note4>\n\n<note5>\n<description>Validate your choice: ensure the divider you used is truly uniform and that you used the correct split (left vs right). If the halves are not aligned or the divider is not uniform, re-evaluate which column is the true separator.</description>\n<example>Suppose several columns look similar but only one column is identical in every row; that column is the divider to use. If two candidates appear, prefer the one that cleanly separates two repeating blocks and yields many matching rows when tested.</example>\n</note5>","<note1>\n<description>Look for a single color that appears as a continuous vertical stripe down the grid (the same column or columns in many rows). When one color fills an entire column and that column is repeated, it usually acts as a divider that separates the grid into two regions.</description>\n<example>Imagine a grid where column 3 is entirely green while the rest of the columns vary. Treat that green column as a divider: it splits the grid into a left block and a right block. Identifying that divider is the first step toward partitioning the image.</example>\n</note1>\n\n<note2>\n<description>Once you have the divider, split the grid into the block immediately to its left and the block immediately to its right. The transformation often uses one of these blocks as the source pattern to reproduce.</description>\n<example>If the divider is a single column at position k, take the columns [1..k-1] as the left block and [k+1..end] as the right block. In many tasks the left block is the one used to generate the final output.</example>\n</note2>\n\n<note3>\n<description>Within the chosen block, determine the dominant color (the color that occupies the majority of cells). That color is typically the one to be propagated across the output.</description>\n<example>For a 3×4 block containing mostly blue pixels and a few other colors, blue is the dominant color. The output is then built using that dominant color rather than the block's original arrangement.</example>\n</note3>\n\n<note4>\n<description>Replace the chosen block with a uniform square of that dominant color whose side length equals the block's height. The output grid is therefore a square whose side equals the number of rows in the chosen block.</description>\n<example>If the chosen block is 5 rows high and the dominant color is blue, produce a 5×5 square filled with blue. This reduces the original partitioned block into a single uniform square.</example>\n</note4>\n\n<note5>\n<description>Decide which side to use by checking the examples: if the divider is a single column, compare the left block's dominant color with the right block's dominant color and use the side that matches the pattern seen in the training outputs. Be careful to exclude the divider color when computing dominance.</description>\n<example>When both sides contain several colors, count occurrences in each side (ignoring the divider color) and pick the side whose dominant color appears in the outputs. A common pitfall is accidentally counting the divider color—exclude it when determining dominance.</example>\n</note5>","<note1>\n<description>Look for a single column or row that is entirely one color and runs uninterrupted from top to bottom or left to right. Such a uniform line is often a deliberate divider that splits the grid into two regular regions.</description>\n<example>Imagine a 6×5 grid where column 3 is all blue from row 1 to row 6. That blue column cleanly separates the left 2 columns from the right 2 columns; spotting this continuous uniform line tells you where the grid is partitioned.</example>\n</note1>\n\n<note2>\n<description>Once a divider is found, treat the grid as two subgrids: the block(s) to the left and the block(s) to the right (or above and below, if the divider is horizontal). Work with those blocks independently rather than the whole grid.</description>\n<example>If a vertical divider splits a 10×4 grid into two 10×2 blocks, analyze each 10×2 block on its own. You can then compare their internal structure to see whether they are identical or follow a repeating pattern.</example>\n</note2>\n\n<note3>\n<description>Compare corresponding cells between the two halves (same row and same column inside each half). If every pair of compared cells is the same color, the halves are identical and can be collapsed to a single representative half.</description>\n<example>For a 4×4 grid where the left half is [[1,2],[3,4]] and the right half is [[1,2],[3,4]], comparing (1,1),(1,2),(2,1),(2,2) shows all pairs match. That indicates the two halves are duplicates and you should produce one copy of that half.</example>\n</note3>\n\n<note4>\n<description>If the halves are not identical, look for a consistent positional mapping (a translation or reflection) that makes them match. Often the halves are related by a small shift—check whether one half’s rows or columns align with the other’s after a single-step move.</description>\n<example>Suppose the left half is [[1,2],[3,4]] and the right half is [[3,4],[1,2]]: shifting the left half by one column makes it match the right half. Detecting that one-step alignment lets you align and compare corresponding cells across halves.</example>\n</note4>\n\n<note5>\n<description>When halves are identical or align consistently, produce the output by taking one representative half (usually the left/top half) and keeping its original shape and orientation. If the halves are different but you still detect a single dominant color, use that color to fill the output block.</description>\n<example>Given two identical 3×3 halves, the output is simply one 3×3 copy of that half. If the halves contain different colors but one color dominates both halves, a consistent choice (e.g., choose the color that appears most often across both halves) can be used to fill the representative block.</example>\n</note5>","<note1>\n<description>Look for a full-height column that is uniform across all rows — such a column often acts as a deliberate separator or frame. Treat that column as a boundary rather than part of the interior pattern when you extract the meaningful region.</description>\n<example>Imagine a 5×7 grid where column 4 is entirely blue in every row; that blue column splits the grid into a left block and a right block. Instead of analyzing the whole grid, focus on the two blocks created by that blue column.</example>\n</note1>\n\n<note2>\n<description>Within each side of the separator, scan for a single color that appears as a contiguous band (a rectangle or a large contiguous area). That repeated color is the interior motif you should preserve.</description>\n<example>For instance, if the left block has a 3×4 rectangle of green pixels and the right block has a 3×4 rectangle of green pixels, green is the repeated interior motif. Ignore the separator color and other incidental colors when identifying this motif.</example>\n</note2>\n\n<note3>\n<description>Compare the two interior rectangles: if they are identical in color and shape, the transformation reduces the problem to a single copy of that rectangle. If they differ, look for the common color across both sides (the one present in both rectangles) and use that instead.</description>\n<example>Two 3×4 rectangles of different colors on opposite sides indicate a mismatch; instead, find the color that appears in both rectangles and treat that color as the motif to use. This resolves ambiguous cases where the two sides are not exactly the same.</example>\n</note3>\n\n<note4>\n<description>Construct the output by cropping to the interior rectangle (the same dimensions as each side’s rectangle) and filling every cell of that crop with the chosen motif color. The output dimensions equal the interior rectangle’s height and width.</description>\n<example>If the interior rectangles are 3 rows by 4 columns and the chosen color is green, produce a 3×4 output where every cell is green. Do not include the separator column or any other colors in the output.</example>\n</note4>\n\n<note5>\n<description>Validate your choice by checking that the chosen color truly forms the consistent interior motif across examples (it may be the only color that repeats in both sides). Avoid selecting colors that appear only as isolated pixels or in the separator.</description>\n<example>When you find multiple candidate colors, prefer the one that forms a contiguous rectangle on both sides (or the one present in both sides when sides differ). Pitfall: do not mistake a full-width uniform column for the interior motif — treat it as a separator.</example>\n</note5>","<note1>\n<description>Look for a vertical divider: a column whose cells are all the same color and that repeats in every row. This full-height column usually separates the grid into two equal-width regions that are treated independently. Identifying that divider is the first step because it tells you where to split the grid.</description>\n<example>Imagine a grid where column 4 is entirely blue while other columns vary. That blue column is a vertical divider; you can split the grid into the left block (columns 1–3) and the right block (columns 5–end) and analyze each block separately.</example>\n</note1>\n\n<note2>\n<description>After splitting, check whether the left and right blocks are mirror images (each cell in the left block corresponds to the same cell in the right block). If they match exactly, the right block is redundant and can be ignored when forming the output. This symmetry is a strong signal to collapse one side.</description>\n<example>For example, if the left block is [[A,B],[C,D]] and the right block is [[A,B],[C,D]] in the same positions, the two blocks are identical and you should treat the right block as a duplicate to be dropped.</example>\n</note2>\n\n<note3>\n<description>If the left and right blocks are not identical, choose the block that is consistently uniform (every cell in that block is the same color) as the representative. Uniform blocks are simpler and often serve as the output because they capture the dominant pattern. If both sides are uniform but different, prefer the side that appears more often or is more consistent across examples.</description>\n<example>Suppose the left block is all color X and the right block is all color Y; the left block is the consistent uniform side and should be used as the representative. If both sides are uniform but the left side repeats across training examples, choose the left side as the representative.</example>\n</note3>\n\n<note4>\n<description>Form the output by taking the representative block and making it square: if the representative has N columns, make an N×N grid filled with that block’s single color. The output size is determined solely by the width of the chosen block. This preserves the representative color in a compact square representation.</description>\n<example>If the chosen block is 4 columns wide, produce a 4×4 grid where every cell is the block’s color; if the block were 3 columns wide, produce a 3×3 grid with the same color repeated.</example>\n</note4>\n\n<note5>\n<description>Watch for pitfalls: confirm the divider truly spans every row (it may be a full-height column), check that the chosen block is the consistent one across examples, and decide a tie-breaker when both sides are uniform. If multiple full-height columns exist, prefer the one that cleanly splits the grid into equal-width regions.</description>\n<example>If two columns look uniform but only one splits the grid into two equal blocks, use that one. If both blocks are uniform but one side appears more consistently in the examples, choose that side as the representative to avoid an ambiguous output.</example>\n</note5>","<note1>\n<description>Look for a single column that is entirely one color and appears in every row; this column is usually a divider that splits the grid into repeated blocks. Recognizing that column reduces the problem from a large grid to a smaller repeated pattern. Treat that column as a separator rather than part of the content to be transformed.</description>\n<example>Imagine a 7×6 grid where column 3 is all blue in every row. That blue column separates left and right areas; you can ignore that column when reasoning about the repeated structure and instead focus on the left and right pieces.</example>\n</note1>\n\n<note2>\n<description>After removing the divider, partition the remaining columns into equal-width blocks (the number of blocks equals the number of repeated patterns). Each block should have the same width and the same internal arrangement of colors. Working with these blocks makes it easier to compare corresponding cells across rows. </description>\n<example>If you remove a single divider from a 12-column grid you get two 5-column blocks; treat those two 5-column blocks as the left and right halves to compare across rows.</example>\n</note2>\n\n<note3>\n<description>Within each block, identify the background color by frequency: the color that fills most cells of that block is typically the background and is preserved across rows. Use that dominant color as the base for the output rather than rare or accent colors. This isolates the repeating structure from incidental noise. </description>\n<example>For a block like [A A A B A A A], A is the background because it appears most often; B is a minority color and should be treated as an accent or marker rather than the main content.</example>\n</note3>\n\n<note4>\n<description>Construct the output by taking one representative row from the input (commonly the topmost or the row that best shows the repeated pattern). For each block, replace all non-background colors with the background color and keep the background color unchanged; the row’s order is preserved. This yields a compact representation of the repeated block pattern. </description>\n<example>If the representative row is [X X Y X X] and Y is an accent color while X is the background, the processed row becomes [X X X X X]. If there are two blocks, the output row will show the same background value for each block.</example>\n</note4>\n\n<note5>\n<description>Finally, convert the processed representative row into a full output grid by repeating it the number of rows that originally existed before removing the divider. This preserves the vertical repetition of the block while compressing horizontal variation. </description>\n<example>If the original grid had 9 rows and you removed one divider column, take the processed representative row and write it 9 times vertically to form the final 9×(block width) output.</example>\n</note5>","<note1>\n<description>Look first for a single column or row whose color never changes from top to bottom or left to right; such a uniform column/row usually acts as a divider that splits the grid into two regions. This divider is a strong clue because it often separates a repeating block pattern from a background or filler region.</description>\n<example>Imagine a grid where column 3 is entirely blue while the other columns vary; treat column 3 as a divider. It cleanly separates the left and right regions so you can analyze each side independently rather than the whole grid at once.</example>\n</note1>\n\n<note2>\n<description>After identifying the divider, extract the block on one side (for example the side that contains a consistent repeating pattern). Check whether that block repeats across rows or columns: many tasks encode information by repeating the same small tile in a regular grid.</description>\n<example>If you see a 2×2 tile A repeated many times across rows and columns, treat that 2×2 tile as the unit to examine. You will typically find that the same arrangement of colors appears repeatedly, so focus on that repeating tile rather than individual rows or columns.</example>\n</note2>\n\n<note3>\n<description>Within the repeating block, look for a color that appears most often and is used consistently across occurrences (this is the background or filler). That color is usually the one you should propagate when producing the output.</description>\n<example>Suppose a 2×2 tile contains colors [A,B; B,A] and A appears more often than B; A is the filler. In many tasks you will need to output only that filler color rather than the patterned colors.</example>\n</note3>\n\n<note4>\n<description>Use the size of the repeating tile as the output dimensions: the output should be a square whose side equals the tile's width (or height, if the tile is square). This converts the repeated tiling into a compact representation.</description>\n<example>If the repeating tile is 3 columns wide and you found the filler color, the output should be a 3×3 grid filled with that filler. If the tile is 4×4, produce a 4×4 output with the filler color.</example>\n</note4>\n\n<note5>\n<description>Before finalizing, validate the divider and the chosen filler by checking invariants across the examples: the divider should be uniform, the repeating tile should be consistent, and the filler should be the most frequent color inside that tile. If any of these fail, re-evaluate which column/row is the divider or which block is the tile.</description>\n<example>Count colors in the candidate tile and confirm the divider is truly constant. If the divider isn’t uniform or the tile doesn’t repeat, try the other side or a different candidate divider until you find a consistent pattern that matches the examples.</example>\n</note5>","<note1>\n<description>Look for a single column that is uniform across every row and acts as a vertical divider. Such a column usually separates the grid into two equal-width regions and is not part of the repeated structure you should extract.</description>\n<example>Imagine a 6×5 grid where column 3 is all the same color from top to bottom while the other columns vary. That single constant column is a clear divider: it splits the grid into two equal blocks and should be ignored when you search for the repeating pattern.</example>\n</note1>\n<note2>\n<description>After locating the divider, treat the left and right blocks independently: each block will typically contain the same repeated pattern of colors but may be offset by a small horizontal shift. Work with one block (left or right) to find the repeating unit.</description>\n<example>For example, if the left block is [A B A B A] and the right block is [B A B A B], they are horizontally shifted versions of the same pattern. Extracting either block reveals the motif you need to reconstruct.</example>\n</note2>\n<note3>\n<description>Within a block, find the minimal repeating unit by scanning for contiguous runs of identical columns (or by using the least common divisor of the block width and the number of distinct columns). The unit is the smallest set of consecutive columns that, when repeated, reproduces the block.</description>\n<example>If a block width is 4 and you see columns [X,Y,X,Y], the repeating unit is just [X,Y]. If the block is [A,B,A,B,A,B], the unit is [A,B] (two columns repeated three times).</example>\n</note3>\n<note4>\n<description>Decide which color to use for the output by looking at the majority of cells in the repeating unit or by checking which color occupies the unit's leftmost column in the block. The examples consistently pick one color from that unit and use it for every cell of the output.</description>\n<example>For instance, if the repeating unit is [red, blue, red] then the majority color is red and that color is the one to fill the output. Alternatively, if the leftmost column of the unit is always the chosen color in the examples, pick that column's color instead.</example>\n</note4>\n<note5>\n<description>Assemble the final output by tiling the chosen single-column pattern across the width and repeating that pattern across the height to match the original block's dimensions. The output should be the same width as the repeating unit and the same number of rows as the block you extracted.</description>\n<example>If the repeating unit is a single column of color C and the block has 4 rows, produce a 4×1 grid where every cell is C. If the block had 6 rows, you would make a 6×1 grid filled with C as well.</example>\n</note5>","<note1>\n<description>Look for a single color that occupies many cells and forms a continuous band across the grid; this color usually acts as a divider. When one color spans most rows or columns, it is the most reliable candidate to split the grid into regions.</description>\n<example>Imagine a 6×6 grid where column 3 is entirely color X while the rest of the grid contains other colors. That uniform column cleanly separates the grid into two vertical blocks; X is the divider to use for partitioning.</example>\n</note1>\n\n<note2>\n<description>Decide whether the divider is vertical or horizontal by checking its extent: if it spans the full width it is a vertical separator; if it spans the full height it is a horizontal separator. The orientation tells you how to slice the grid (left vs right, top vs bottom).</description>\n<example>For instance, if every row contains the same color in column 4, treat column 4 as a vertical divider and cut the grid into left and right halves. If instead every column contains the same color in row 5, treat row 5 as a horizontal divider and cut into top and bottom halves.</example>\n</note2>\n\n<note3>\n<description>After splitting, each half will typically be uniform in color; choose the color that is consistent across the entire half (a solid block). This chosen block color is the one you will propagate into the final output.</description>\n<example>Splitting a grid with a vertical divider might yield a left block that is entirely color A and a right block that is entirely color B; selecting A (or B) means you will make the output filled with that single color.</example>\n</note3>\n\n<note4>\n<description>Compute the output size from the partition: if the divider splits the grid into two equal halves, the output dimensions are the size of one half (half the original rows for a vertical split, half the original columns for a horizontal split). The output is therefore a smaller grid with the same orientation as the chosen half.</description>\n<example>If a vertical divider divides an original grid into two equal-width blocks, the output will be a square with side length equal to one half of the original width (e.g., if the original width was 10 the output width will be 5).</example>\n</note4>\n\n<note5>\n<description>Be careful with edge cases: if a color appears in multiple places, prefer the long continuous band; if the grid is odd-sized, verify whether the intended split is still into two equal halves or whether an extra row/column should be excluded. Always check consistency across the whole grid before choosing the divider and the block color.</description>\n<example>If color X appears in several short segments but also as a full column, pick the full column as the divider. If the grid has an odd dimension and no perfect two-way split, re-check which color forms the continuous divider and whether the examples imply excluding one row/column to make halves equal.</example>\n</note5>","<note1>\n<description>Look for a single column whose color is constant across every row; that column is likely a separator and should be removed. Treat that column as a divider rather than part of the repeating structure.</description>\n<example>Imagine a 7×5 grid where column 3 is always blue while the other columns change; if you remove that blue column you expose the repeated pattern on either side. Recognizing a column that never changes is the first clue that a vertical split exists.</example>\n</note1>\n\n<note2>\n<description>After removing the separator, check whether the remaining grid is composed of identical horizontal blocks (tiles). If so, the task is to reduce the grid to one representative tile.</description>\n<example>For instance, if the grid becomes four identical 2×2 blocks arranged side-by-side, you can think of it as four copies of the same 2×2 tile. Identical blocks across the width indicate a natural tiling.</example>\n</note2>\n\n<note3>\n<description>Choose the tile that represents the pattern: when tiles are identical pick any tile (they are interchangeable), and when tiles differ, pick the tile that matches the examples’ choice (commonly the leftmost or topmost tile). Consistency across examples is the deciding factor.</description>\n<example>If you see three identical 3×3 tiles and one different 3×3 tile, the correct representative is one of the identical tiles (not the different one). If all tiles are identical, any of them is a valid representative.</example>\n</note3>\n\n<note4>\n<description>Decide the output size by the tile dimensions: the output should be exactly one tile (same height and width as each tile). Preserve the tile’s internal arrangement when you produce the output.</description>\n<example>If each tile is 2×2, the output must be 2×2; if each tile is 3×3, the output must be 3×3. The output is a single copy of the chosen tile, not a larger composite.</example>\n</note4>\n\n<note5>\n<description>Watch for pitfalls: don’t confuse a separator with a regular tile color, and confirm that the remaining columns truly form repeating tiles before selecting one. Also verify the chosen tile matches the examples’ behavior (for example, the leftmost tile is often used).</description>\n<example>If the grid looks like four identical columns but one column is a constant divider, remove the divider first and then pick a tile. If tiles are not identical, check the examples to see which tile they selected and follow that convention.</example>\n</note5>","<note1>\n<description>Look for a single color that appears as a full-height column in every row. Such a color is a candidate divider because it spans every row and is therefore easy to detect across the whole grid.</description>\n<example>Imagine a grid where column 3 is blue in every row while other columns vary. That blue column is a vertical divider: it consistently separates left and right regions and is a natural candidate to remove when extracting a repeating pattern.</example>\n</note1>\n\n<note2>\n<description>Check the remaining columns for a repeated structure: the same color often fills the left block of cells and the same color fills the right block of cells, producing a mirrored (palindromic) arrangement. This indicates the pattern is composed of two identical halves.</description>\n<example>For instance, if the left half of columns is all green and the right half is also all green (with the divider between them), you can treat the left and right halves as identical halves of a repeating unit.</example>\n</note2>\n\n<note3>\n<description>When both halves are identical, the meaningful information is contained in one half. Remove the divider and keep either half to produce the minimal representation that preserves the repeating structure.</description>\n<example>If you have a grid with a blue divider and both sides are green, discarding the blue column and keeping the left (or right) green block yields a compact grid that still shows the repeating pattern.</example>\n</note3>\n\n<note4>\n<description>Preserve the original ordering and orientation of the kept half: do not rotate, mirror, or reorder columns. The task is to compress the grid by removing the divider, not to rearrange the pattern.</description>\n<example>If the left half is [A A A | B B B | C C C], keep that same left-to-right sequence after removing the divider; do not swap A with B or reverse the order.</example>\n</note4>\n\n<note5>\n<description>Use simple checks to confirm your choice: the divider should be present in every row, the halves should be identical, and the result should be a smaller grid that still shows the repeating pattern. If the halves differ, look for another consistent column or a different repeating unit.</description>\n<example>If a candidate column is the only color that appears in every row and both halves around it are identical, removing that column gives a compact output that matches the examples; if not, try other full-height columns or consider a different grouping.</example>\n</note5>","<note1>\n<description>Look for a single color that forms a continuous vertical stripe (or column) running from top to bottom across the grid. This stripe is usually the separator and is distinct from the repeating interior pattern because it occupies the same column in every row.</description>\n<example>Imagine a 5×4 grid where column 2 is entirely color X while the other columns show a repeating arrangement of other colors. That full-column of X is the vertical divider you should isolate before doing any further analysis.</example>\n</note1>\n\n<note2>\n<description>Once you have the divider, remove that column entirely and treat the remaining columns as the interior pattern to analyze. The output grid will be the same number of rows as the input but only contain the columns that were left after the divider was dropped.</description>\n<example>If the input is 7 rows by 6 columns and you remove one full column, you get 7 rows by 5 columns of interior pixels to work with.</example>\n</note2>\n\n<note3>\n<description>Within the interior, identify the dominant color by frequency: the color that fills most of the remaining cells. This majority color is the one that defines the interior’s structure and is what the output will represent.</description>\n<example>Suppose the interior 5 columns contain 20 cells of color A and 10 of other colors; A is the dominant color and is the natural choice for the interior pattern.</example>\n</note3>\n\n<note4>\n<description>Decide how many rows to keep by inspecting the interior for vertical repetition: if the interior pattern repeats every r rows, keep only one period (the minimal repeating block) so the output has fewer rows but preserves the same column layout. If no clear period exists, keep all interior rows.</description>\n<example>If the interior shows the same 3-row block repeated down the grid, compress the grid to that 3-row block; if the interior has no repeating block, leave all interior rows intact.</example>\n</note4>\n\n<note5>\n<description>Finally, produce the output by filling every cell of the reduced interior grid with the dominant color. This produces a compact representation of the interior pattern while discarding the separator and any non-repeating row information.</description>\n<example>After removing the divider and compressing to one period, fill every remaining cell with the most frequent interior color so the result is a smaller grid showing only that dominant color.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Look first for a continuous, uniform stripe that runs across an entire row or an entire column. Such a stripe is usually the structural divider that splits the grid into repeated blocks.</description>\\n<example>Imagine a grid where every cell in row 3 is the same color while other rows vary. That full row is a natural horizontal divider; a similar vertical divider would be a column where every cell is the same color.</example>\\n</note1>\\n\\n<note2>\\n<description>Once you identify the divider, treat the grid as a tiled mosaic of blocks bounded by that stripe. The divider itself is not part of the blocks but separates them.</description>\\n<example>If a vertical stripe runs down the middle, the grid becomes two vertical bands (left and right) of equal width; each band can then be seen as a block to inspect further.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare corresponding cells inside each block (same row and same column within a block). If those corresponding positions consistently show the same color across blocks, that color is the block motif.</description>\\n<example>For two identical-size blocks, check position (1,1) of both blocks, then (1,2), (2,1), etc. If every corresponding cell is the same color, you have found the repeating motif to extract.</example>\\n</note3>\\n\\n<note4>\\n<description>Form the output by taking one representative block (often the top-left) and producing a grid whose size equals that block's dimensions. This isolates the repeating unit without the divider.</description>\\n<example>If the divider splits the image into four equal quadrants and each quadrant contains the same small pattern, extract the top-left quadrant as the output; its shape is the same as one quadrant.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful about ambiguous cases: confirm the stripe truly spans the whole row/column and that blocks are aligned and uniform. Also check for multiple candidate dividers before committing to one.</description>\\n<example>If a row is mostly one color but has a few differing pixels, that row is unlikely to be the divider; prefer a stripe that is continuous across every cell. If several candidate dividers exist, verify which one yields identical block patterns across the grid.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a vertical stripe of one color that occupies the same column(s) across many rows; that column often acts as a divider and separates the grid into left and right regions. Treat that column as a structural boundary rather than as part of the pattern you must preserve.</description>\\n<example>Imagine a grid where every row has a single column filled with color A while the rest of the row varies. That column is a strong candidate for a vertical divider: it is consistent across rows and can be used to split the grid into two subgrids.</example>\\n</note1>\\n\\n<note2>\\n<description>After locating the divider, split the grid into the left and right subgrids and compare them side-by-side. Many puzzles use the same arrangement of colors on both sides, so the left and right halves become two candidate outputs.</description>\\n<example>For instance, if the left half contains a repeating 3×3 motif and the right half has the same 3×3 motif in the same relative positions, then the left half is a natural candidate to extract and return.</example>\\n</note2>\\n\\n<note3>\\n<description>Choose the subgrid that is visually consistent across rows (i.e., the one that shows a repeated motif or a stable internal pattern) rather than the one that varies row by row. Consistency across rows is a strong signal of the intended output region.</description>\\n<example>If the right half changes color in each row while the left half always shows the same arrangement of colors, prefer the left half because it is the more stable, repeating region.</example>\\n</note3>\\n\\n<note4>\\n<description>When producing the final output, keep the subgrid's original dimensions and use the subgrid's dominant color as the fill color. If the subgrid is uniform, the output should be a solid block of that color; if it contains multiple colors, use the most frequent color as the fill.</description>\\n<example>For example, if the chosen subgrid is 4×5 and its most common color is B, create a 4×5 grid filled entirely with B so the output matches the subgrid's dominant appearance.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple checks to decide which side to extract: test for a single-column divider, for repetition of the same arrangement across rows, and for a majority color in the subgrid. Avoid choosing a side that is entirely the divider color or one that changes unpredictably.</description>\\n<example>Quick heuristics: if one column is identical across all rows, split there and compare halves; if one half repeats the same pattern down the rows, that half is likely the intended output; if a half is mostly one color, use that color to fill the output.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single column or row that is uniformly one color across the whole grid; such a column/row usually acts as a divider that splits the image into repeated blocks. This is effective because a full-color stripe is an obvious structural feature that separates independent sub-images.</description>\\n<example>Imagine a grid where column 4 is entirely green while the rest of the grid shows different patterns on each side. That green column is the divider: treat it as a boundary and ignore it when grouping cells into repeating blocks.</example>\\n</note1>\\n\\n<note2>\\n<description>After finding the divider, partition the grid into equal rectangular tiles on each side (for example, split width and height into n×n blocks). The divider itself should not be included in any tile; the tiles are the repeating sub-images that were separated by the stripe.</description>\\n<example>If you have a 12×8 grid with a uniform column in the middle, split into two 6×8 halves. If the same uniform stripe appears again later, split again so you end up with a set of identical-size tiles (for example, four 3×4 tiles).</example>\\n</note2>\\n\\n<note3>\\n<description>Within each tile, find the most frequent color (the dominant color) and use that color as the tile's representative. This reduces each tile to a single color while preserving the tile's spatial arrangement.</description>\\n<example>Suppose a 3×3 tile contains 8 blue cells and 1 red cell; the tile's representative color is blue. Do this for every tile so each tile becomes a single-color pixel in the output.</example>\\n</note3>\\n\\n<note4>\\n<description>Assemble the output by placing each tile's representative color in the same relative position as the tile in the input, preserving the original order and layout (top-to-bottom, left-to-right). The output grid dimensions equal the number of tiles in each direction.</description>\\n<example>If you split the input into a 2×3 array of tiles, the output will be 2 rows by 3 columns where each output cell holds the dominant color of the corresponding input tile.</example>\\n</note4>\\n\\n<note5>\\n<description>Validate your result: the output should show a regular pattern of tile colors that matches the spatial arrangement of the tiles and should not contain the divider color. If the output is uniform, check that every tile had the same dominant color; if it is varied, confirm you split at the correct divider(s).</description>\\n<example>If your output is a uniform grid of one color, re-check whether you split at the correct uniform column/row and whether every tile really contained that color as the majority. If any tile had a different dominant color, you likely split incorrectly or missed a stripe.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single color that appears as a complete, unbroken line across every row and column (a full-height and full-width stripe). That color is usually the background and is not part of the repeated objects you should extract.</description>\\n<example>Imagine a 6×6 grid where column 3 and row 4 are entirely color X while every other cell is a different color. Column 3 and row 4 are the full stripes; color X is the background and should be removed before finding the repeating pattern.</example>\\n</note1>\\n\\n<note2>\\n<description>After removing the full stripes, the remaining area typically reveals a small tile (often 2×2) that repeats in a regular grid. Treat that tile as the unit of repetition rather than individual pixels.</description>\\n<example>With stripes removed you might see a 4×4 region composed of four identical 2×2 blocks; each 2×2 block is the repeating tile. Work with that tile size when reasoning about what to extract.</example>\\n</note2>\\n\\n<note3>\\n<description>Within each tile, identify the dominant color (the one that fills most of the tile) and treat that as the representative color for the tile. Do not pick a color that only appears on the edges or as a minority inside the tile.</description>\\n<example>If a 2×2 tile contains three cells of color A and one cell of color B, choose A as the tile’s representative. If a tile is uniform, its representative is simply that uniform color.</example>\\n</note3>\\n\\n<note4>\\n<description>Build the output by selecting one representative color per tile and arranging those representatives in the same order as the tiles (left-to-right, then top-to-bottom). The output’s dimensions equal the number of tiles across by the number of tiles down.</description>\\n<example>If you find three tiles across and two down, create a 2×3 output whose cells are the chosen colors from the corresponding tiles. The relative order of tiles determines the arrangement of representatives.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for common pitfalls: stripes can be horizontal or vertical, and the tile may be 2×2 but the whole pattern can be larger. Also check that the representative color truly dominates the tile (not just adjacent to it).</description>\\n<example>If stripes run vertically, remove them first before extracting tiles; if a tile has a single differing pixel, still prefer the majority color as the representative. If the tile is 2×2 but the full pattern is 4×4, you will produce a 2×2 output — so always base your tile count on the full pattern after removing stripes.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a full-height stripe that is uniform across every row: a single column whose every cell is the same color. This column often acts as a divider separating distinct repeated regions.</description>\\n<example>Imagine a grid where column 3 is entirely green while the other columns vary by row. That green column is a strong candidate for a vertical divider because it repeats in every row and is not part of any larger mixed region.</example>\\n</note1>\\n\\n<note2>\\n<description>Use that divider to split the grid into two vertical regions (left and right). Treat the left and right regions as the two halves you will compare.</description>\\n<example>For instance, if you detect a vertical divider at column 2, split the grid into columns 1–2 and 3–end. Work with those two subgrids as the left and right halves for the next steps.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare the two halves row-by-row: for each row, check whether the left half's cell equals the right half's cell at the same row position. This reveals which rows are consistent between the two halves.</description>\\n<example>Take a row [A,B,C,D] split into left [A,B] and right [C,D]. If A==C and B==D the row is consistent; otherwise it is not. Do this independently for every row.</example>\\n</note3>\\n\\n<note4>\\n<description>Form the final grid by including only the rows that are consistent between the two halves; keep the original left-to-right ordering of those rows. The output's number of columns equals the width of one half.</description>\\n<example>If only rows 2 and 5 match across both halves, your output will contain those two rows in the same order, with each output row composed of the left-half cells (or equivalently the matching right-half cells).</example>\\n</note4>\\n\\n<note5>\\n<description>Validate your choice: ensure the divider you used is truly uniform and that you used the correct split (left vs right). If the halves are not aligned or the divider is not uniform, re-evaluate which column is the true separator.</description>\\n<example>Suppose several columns look similar but only one column is identical in every row; that column is the divider to use. If two candidates appear, prefer the one that cleanly separates two repeating blocks and yields many matching rows when tested.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single color that appears as a continuous vertical stripe down the grid (the same column or columns in many rows). When one color fills an entire column and that column is repeated, it usually acts as a divider that separates the grid into two regions.</description>\\n<example>Imagine a grid where column 3 is entirely green while the rest of the columns vary. Treat that green column as a divider: it splits the grid into a left block and a right block. Identifying that divider is the first step toward partitioning the image.</example>\\n</note1>\\n\\n<note2>\\n<description>Once you have the divider, split the grid into the block immediately to its left and the block immediately to its right. The transformation often uses one of these blocks as the source pattern to reproduce.</description>\\n<example>If the divider is a single column at position k, take the columns [1..k-1] as the left block and [k+1..end] as the right block. In many tasks the left block is the one used to generate the final output.</example>\\n</note2>\\n\\n<note3>\\n<description>Within the chosen block, determine the dominant color (the color that occupies the majority of cells). That color is typically the one to be propagated across the output.</description>\\n<example>For a 3×4 block containing mostly blue pixels and a few other colors, blue is the dominant color. The output is then built using that dominant color rather than the block's original arrangement.</example>\\n</note3>\\n\\n<note4>\\n<description>Replace the chosen block with a uniform square of that dominant color whose side length equals the block's height. The output grid is therefore a square whose side equals the number of rows in the chosen block.</description>\\n<example>If the chosen block is 5 rows high and the dominant color is blue, produce a 5×5 square filled with blue. This reduces the original partitioned block into a single uniform square.</example>\\n</note4>\\n\\n<note5>\\n<description>Decide which side to use by checking the examples: if the divider is a single column, compare the left block's dominant color with the right block's dominant color and use the side that matches the pattern seen in the training outputs. Be careful to exclude the divider color when computing dominance.</description>\\n<example>When both sides contain several colors, count occurrences in each side (ignoring the divider color) and pick the side whose dominant color appears in the outputs. A common pitfall is accidentally counting the divider color—exclude it when determining dominance.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single column or row that is entirely one color and runs uninterrupted from top to bottom or left to right. Such a uniform line is often a deliberate divider that splits the grid into two regular regions.</description>\\n<example>Imagine a 6×5 grid where column 3 is all blue from row 1 to row 6. That blue column cleanly separates the left 2 columns from the right 2 columns; spotting this continuous uniform line tells you where the grid is partitioned.</example>\\n</note1>\\n\\n<note2>\\n<description>Once a divider is found, treat the grid as two subgrids: the block(s) to the left and the block(s) to the right (or above and below, if the divider is horizontal). Work with those blocks independently rather than the whole grid.</description>\\n<example>If a vertical divider splits a 10×4 grid into two 10×2 blocks, analyze each 10×2 block on its own. You can then compare their internal structure to see whether they are identical or follow a repeating pattern.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare corresponding cells between the two halves (same row and same column inside each half). If every pair of compared cells is the same color, the halves are identical and can be collapsed to a single representative half.</description>\\n<example>For a 4×4 grid where the left half is [[1,2],[3,4]] and the right half is [[1,2],[3,4]], comparing (1,1),(1,2),(2,1),(2,2) shows all pairs match. That indicates the two halves are duplicates and you should produce one copy of that half.</example>\\n</note3>\\n\\n<note4>\\n<description>If the halves are not identical, look for a consistent positional mapping (a translation or reflection) that makes them match. Often the halves are related by a small shift—check whether one half’s rows or columns align with the other’s after a single-step move.</description>\\n<example>Suppose the left half is [[1,2],[3,4]] and the right half is [[3,4],[1,2]]: shifting the left half by one column makes it match the right half. Detecting that one-step alignment lets you align and compare corresponding cells across halves.</example>\\n</note4>\\n\\n<note5>\\n<description>When halves are identical or align consistently, produce the output by taking one representative half (usually the left/top half) and keeping its original shape and orientation. If the halves are different but you still detect a single dominant color, use that color to fill the output block.</description>\\n<example>Given two identical 3×3 halves, the output is simply one 3×3 copy of that half. If the halves contain different colors but one color dominates both halves, a consistent choice (e.g., choose the color that appears most often across both halves) can be used to fill the representative block.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a full-height column that is uniform across all rows — such a column often acts as a deliberate separator or frame. Treat that column as a boundary rather than part of the interior pattern when you extract the meaningful region.</description>\\n<example>Imagine a 5×7 grid where column 4 is entirely blue in every row; that blue column splits the grid into a left block and a right block. Instead of analyzing the whole grid, focus on the two blocks created by that blue column.</example>\\n</note1>\\n\\n<note2>\\n<description>Within each side of the separator, scan for a single color that appears as a contiguous band (a rectangle or a large contiguous area). That repeated color is the interior motif you should preserve.</description>\\n<example>For instance, if the left block has a 3×4 rectangle of green pixels and the right block has a 3×4 rectangle of green pixels, green is the repeated interior motif. Ignore the separator color and other incidental colors when identifying this motif.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare the two interior rectangles: if they are identical in color and shape, the transformation reduces the problem to a single copy of that rectangle. If they differ, look for the common color across both sides (the one present in both rectangles) and use that instead.</description>\\n<example>Two 3×4 rectangles of different colors on opposite sides indicate a mismatch; instead, find the color that appears in both rectangles and treat that color as the motif to use. This resolves ambiguous cases where the two sides are not exactly the same.</example>\\n</note3>\\n\\n<note4>\\n<description>Construct the output by cropping to the interior rectangle (the same dimensions as each side’s rectangle) and filling every cell of that crop with the chosen motif color. The output dimensions equal the interior rectangle’s height and width.</description>\\n<example>If the interior rectangles are 3 rows by 4 columns and the chosen color is green, produce a 3×4 output where every cell is green. Do not include the separator column or any other colors in the output.</example>\\n</note4>\\n\\n<note5>\\n<description>Validate your choice by checking that the chosen color truly forms the consistent interior motif across examples (it may be the only color that repeats in both sides). Avoid selecting colors that appear only as isolated pixels or in the separator.</description>\\n<example>When you find multiple candidate colors, prefer the one that forms a contiguous rectangle on both sides (or the one present in both sides when sides differ). Pitfall: do not mistake a full-width uniform column for the interior motif — treat it as a separator.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a vertical divider: a column whose cells are all the same color and that repeats in every row. This full-height column usually separates the grid into two equal-width regions that are treated independently. Identifying that divider is the first step because it tells you where to split the grid.</description>\\n<example>Imagine a grid where column 4 is entirely blue while other columns vary. That blue column is a vertical divider; you can split the grid into the left block (columns 1–3) and the right block (columns 5–end) and analyze each block separately.</example>\\n</note1>\\n\\n<note2>\\n<description>After splitting, check whether the left and right blocks are mirror images (each cell in the left block corresponds to the same cell in the right block). If they match exactly, the right block is redundant and can be ignored when forming the output. This symmetry is a strong signal to collapse one side.</description>\\n<example>For example, if the left block is [[A,B],[C,D]] and the right block is [[A,B],[C,D]] in the same positions, the two blocks are identical and you should treat the right block as a duplicate to be dropped.</example>\\n</note2>\\n\\n<note3>\\n<description>If the left and right blocks are not identical, choose the block that is consistently uniform (every cell in that block is the same color) as the representative. Uniform blocks are simpler and often serve as the output because they capture the dominant pattern. If both sides are uniform but different, prefer the side that appears more often or is more consistent across examples.</description>\\n<example>Suppose the left block is all color X and the right block is all color Y; the left block is the consistent uniform side and should be used as the representative. If both sides are uniform but the left side repeats across training examples, choose the left side as the representative.</example>\\n</note3>\\n\\n<note4>\\n<description>Form the output by taking the representative block and making it square: if the representative has N columns, make an N×N grid filled with that block’s single color. The output size is determined solely by the width of the chosen block. This preserves the representative color in a compact square representation.</description>\\n<example>If the chosen block is 4 columns wide, produce a 4×4 grid where every cell is the block’s color; if the block were 3 columns wide, produce a 3×3 grid with the same color repeated.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for pitfalls: confirm the divider truly spans every row (it may be a full-height column), check that the chosen block is the consistent one across examples, and decide a tie-breaker when both sides are uniform. If multiple full-height columns exist, prefer the one that cleanly splits the grid into equal-width regions.</description>\\n<example>If two columns look uniform but only one splits the grid into two equal blocks, use that one. If both blocks are uniform but one side appears more consistently in the examples, choose that side as the representative to avoid an ambiguous output.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single column that is entirely one color and appears in every row; this column is usually a divider that splits the grid into repeated blocks. Recognizing that column reduces the problem from a large grid to a smaller repeated pattern. Treat that column as a separator rather than part of the content to be transformed.</description>\\n<example>Imagine a 7×6 grid where column 3 is all blue in every row. That blue column separates left and right areas; you can ignore that column when reasoning about the repeated structure and instead focus on the left and right pieces.</example>\\n</note1>\\n\\n<note2>\\n<description>After removing the divider, partition the remaining columns into equal-width blocks (the number of blocks equals the number of repeated patterns). Each block should have the same width and the same internal arrangement of colors. Working with these blocks makes it easier to compare corresponding cells across rows. </description>\\n<example>If you remove a single divider from a 12-column grid you get two 5-column blocks; treat those two 5-column blocks as the left and right halves to compare across rows.</example>\\n</note2>\\n\\n<note3>\\n<description>Within each block, identify the background color by frequency: the color that fills most cells of that block is typically the background and is preserved across rows. Use that dominant color as the base for the output rather than rare or accent colors. This isolates the repeating structure from incidental noise. </description>\\n<example>For a block like [A A A B A A A], A is the background because it appears most often; B is a minority color and should be treated as an accent or marker rather than the main content.</example>\\n</note3>\\n\\n<note4>\\n<description>Construct the output by taking one representative row from the input (commonly the topmost or the row that best shows the repeated pattern). For each block, replace all non-background colors with the background color and keep the background color unchanged; the row’s order is preserved. This yields a compact representation of the repeated block pattern. </description>\\n<example>If the representative row is [X X Y X X] and Y is an accent color while X is the background, the processed row becomes [X X X X X]. If there are two blocks, the output row will show the same background value for each block.</example>\\n</note4>\\n\\n<note5>\\n<description>Finally, convert the processed representative row into a full output grid by repeating it the number of rows that originally existed before removing the divider. This preserves the vertical repetition of the block while compressing horizontal variation. </description>\\n<example>If the original grid had 9 rows and you removed one divider column, take the processed representative row and write it 9 times vertically to form the final 9×(block width) output.</example>\\n</note5>\",\n \"<note1>\\n<description>Look first for a single column or row whose color never changes from top to bottom or left to right; such a uniform column/row usually acts as a divider that splits the grid into two regions. This divider is a strong clue because it often separates a repeating block pattern from a background or filler region.</description>\\n<example>Imagine a grid where column 3 is entirely blue while the other columns vary; treat column 3 as a divider. It cleanly separates the left and right regions so you can analyze each side independently rather than the whole grid at once.</example>\\n</note1>\\n\\n<note2>\\n<description>After identifying the divider, extract the block on one side (for example the side that contains a consistent repeating pattern). Check whether that block repeats across rows or columns: many tasks encode information by repeating the same small tile in a regular grid.</description>\\n<example>If you see a 2×2 tile A repeated many times across rows and columns, treat that 2×2 tile as the unit to examine. You will typically find that the same arrangement of colors appears repeatedly, so focus on that repeating tile rather than individual rows or columns.</example>\\n</note2>\\n\\n<note3>\\n<description>Within the repeating block, look for a color that appears most often and is used consistently across occurrences (this is the background or filler). That color is usually the one you should propagate when producing the output.</description>\\n<example>Suppose a 2×2 tile contains colors [A,B; B,A] and A appears more often than B; A is the filler. In many tasks you will need to output only that filler color rather than the patterned colors.</example>\\n</note3>\\n\\n<note4>\\n<description>Use the size of the repeating tile as the output dimensions: the output should be a square whose side equals the tile's width (or height, if the tile is square). This converts the repeated tiling into a compact representation.</description>\\n<example>If the repeating tile is 3 columns wide and you found the filler color, the output should be a 3×3 grid filled with that filler. If the tile is 4×4, produce a 4×4 output with the filler color.</example>\\n</note4>\\n\\n<note5>\\n<description>Before finalizing, validate the divider and the chosen filler by checking invariants across the examples: the divider should be uniform, the repeating tile should be consistent, and the filler should be the most frequent color inside that tile. If any of these fail, re-evaluate which column/row is the divider or which block is the tile.</description>\\n<example>Count colors in the candidate tile and confirm the divider is truly constant. If the divider isn’t uniform or the tile doesn’t repeat, try the other side or a different candidate divider until you find a consistent pattern that matches the examples.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single column that is uniform across every row and acts as a vertical divider. Such a column usually separates the grid into two equal-width regions and is not part of the repeated structure you should extract.</description>\\n<example>Imagine a 6×5 grid where column 3 is all the same color from top to bottom while the other columns vary. That single constant column is a clear divider: it splits the grid into two equal blocks and should be ignored when you search for the repeating pattern.</example>\\n</note1>\\n<note2>\\n<description>After locating the divider, treat the left and right blocks independently: each block will typically contain the same repeated pattern of colors but may be offset by a small horizontal shift. Work with one block (left or right) to find the repeating unit.</description>\\n<example>For example, if the left block is [A B A B A] and the right block is [B A B A B], they are horizontally shifted versions of the same pattern. Extracting either block reveals the motif you need to reconstruct.</example>\\n</note2>\\n<note3>\\n<description>Within a block, find the minimal repeating unit by scanning for contiguous runs of identical columns (or by using the least common divisor of the block width and the number of distinct columns). The unit is the smallest set of consecutive columns that, when repeated, reproduces the block.</description>\\n<example>If a block width is 4 and you see columns [X,Y,X,Y], the repeating unit is just [X,Y]. If the block is [A,B,A,B,A,B], the unit is [A,B] (two columns repeated three times).</example>\\n</note3>\\n<note4>\\n<description>Decide which color to use for the output by looking at the majority of cells in the repeating unit or by checking which color occupies the unit's leftmost column in the block. The examples consistently pick one color from that unit and use it for every cell of the output.</description>\\n<example>For instance, if the repeating unit is [red, blue, red] then the majority color is red and that color is the one to fill the output. Alternatively, if the leftmost column of the unit is always the chosen color in the examples, pick that column's color instead.</example>\\n</note4>\\n<note5>\\n<description>Assemble the final output by tiling the chosen single-column pattern across the width and repeating that pattern across the height to match the original block's dimensions. The output should be the same width as the repeating unit and the same number of rows as the block you extracted.</description>\\n<example>If the repeating unit is a single column of color C and the block has 4 rows, produce a 4×1 grid where every cell is C. If the block had 6 rows, you would make a 6×1 grid filled with C as well.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single color that occupies many cells and forms a continuous band across the grid; this color usually acts as a divider. When one color spans most rows or columns, it is the most reliable candidate to split the grid into regions.</description>\\n<example>Imagine a 6×6 grid where column 3 is entirely color X while the rest of the grid contains other colors. That uniform column cleanly separates the grid into two vertical blocks; X is the divider to use for partitioning.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide whether the divider is vertical or horizontal by checking its extent: if it spans the full width it is a vertical separator; if it spans the full height it is a horizontal separator. The orientation tells you how to slice the grid (left vs right, top vs bottom).</description>\\n<example>For instance, if every row contains the same color in column 4, treat column 4 as a vertical divider and cut the grid into left and right halves. If instead every column contains the same color in row 5, treat row 5 as a horizontal divider and cut into top and bottom halves.</example>\\n</note2>\\n\\n<note3>\\n<description>After splitting, each half will typically be uniform in color; choose the color that is consistent across the entire half (a solid block). This chosen block color is the one you will propagate into the final output.</description>\\n<example>Splitting a grid with a vertical divider might yield a left block that is entirely color A and a right block that is entirely color B; selecting A (or B) means you will make the output filled with that single color.</example>\\n</note3>\\n\\n<note4>\\n<description>Compute the output size from the partition: if the divider splits the grid into two equal halves, the output dimensions are the size of one half (half the original rows for a vertical split, half the original columns for a horizontal split). The output is therefore a smaller grid with the same orientation as the chosen half.</description>\\n<example>If a vertical divider divides an original grid into two equal-width blocks, the output will be a square with side length equal to one half of the original width (e.g., if the original width was 10 the output width will be 5).</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful with edge cases: if a color appears in multiple places, prefer the long continuous band; if the grid is odd-sized, verify whether the intended split is still into two equal halves or whether an extra row/column should be excluded. Always check consistency across the whole grid before choosing the divider and the block color.</description>\\n<example>If color X appears in several short segments but also as a full column, pick the full column as the divider. If the grid has an odd dimension and no perfect two-way split, re-check which color forms the continuous divider and whether the examples imply excluding one row/column to make halves equal.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single column whose color is constant across every row; that column is likely a separator and should be removed. Treat that column as a divider rather than part of the repeating structure.</description>\\n<example>Imagine a 7×5 grid where column 3 is always blue while the other columns change; if you remove that blue column you expose the repeated pattern on either side. Recognizing a column that never changes is the first clue that a vertical split exists.</example>\\n</note1>\\n\\n<note2>\\n<description>After removing the separator, check whether the remaining grid is composed of identical horizontal blocks (tiles). If so, the task is to reduce the grid to one representative tile.</description>\\n<example>For instance, if the grid becomes four identical 2×2 blocks arranged side-by-side, you can think of it as four copies of the same 2×2 tile. Identical blocks across the width indicate a natural tiling.</example>\\n</note2>\\n\\n<note3>\\n<description>Choose the tile that represents the pattern: when tiles are identical pick any tile (they are interchangeable), and when tiles differ, pick the tile that matches the examples’ choice (commonly the leftmost or topmost tile). Consistency across examples is the deciding factor.</description>\\n<example>If you see three identical 3×3 tiles and one different 3×3 tile, the correct representative is one of the identical tiles (not the different one). If all tiles are identical, any of them is a valid representative.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide the output size by the tile dimensions: the output should be exactly one tile (same height and width as each tile). Preserve the tile’s internal arrangement when you produce the output.</description>\\n<example>If each tile is 2×2, the output must be 2×2; if each tile is 3×3, the output must be 3×3. The output is a single copy of the chosen tile, not a larger composite.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for pitfalls: don’t confuse a separator with a regular tile color, and confirm that the remaining columns truly form repeating tiles before selecting one. Also verify the chosen tile matches the examples’ behavior (for example, the leftmost tile is often used).</description>\\n<example>If the grid looks like four identical columns but one column is a constant divider, remove the divider first and then pick a tile. If tiles are not identical, check the examples to see which tile they selected and follow that convention.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single color that appears as a full-height column in every row. Such a color is a candidate divider because it spans every row and is therefore easy to detect across the whole grid.</description>\\n<example>Imagine a grid where column 3 is blue in every row while other columns vary. That blue column is a vertical divider: it consistently separates left and right regions and is a natural candidate to remove when extracting a repeating pattern.</example>\\n</note1>\\n\\n<note2>\\n<description>Check the remaining columns for a repeated structure: the same color often fills the left block of cells and the same color fills the right block of cells, producing a mirrored (palindromic) arrangement. This indicates the pattern is composed of two identical halves.</description>\\n<example>For instance, if the left half of columns is all green and the right half is also all green (with the divider between them), you can treat the left and right halves as identical halves of a repeating unit.</example>\\n</note2>\\n\\n<note3>\\n<description>When both halves are identical, the meaningful information is contained in one half. Remove the divider and keep either half to produce the minimal representation that preserves the repeating structure.</description>\\n<example>If you have a grid with a blue divider and both sides are green, discarding the blue column and keeping the left (or right) green block yields a compact grid that still shows the repeating pattern.</example>\\n</note3>\\n\\n<note4>\\n<description>Preserve the original ordering and orientation of the kept half: do not rotate, mirror, or reorder columns. The task is to compress the grid by removing the divider, not to rearrange the pattern.</description>\\n<example>If the left half is [A A A | B B B | C C C], keep that same left-to-right sequence after removing the divider; do not swap A with B or reverse the order.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple checks to confirm your choice: the divider should be present in every row, the halves should be identical, and the result should be a smaller grid that still shows the repeating pattern. If the halves differ, look for another consistent column or a different repeating unit.</description>\\n<example>If a candidate column is the only color that appears in every row and both halves around it are identical, removing that column gives a compact output that matches the examples; if not, try other full-height columns or consider a different grouping.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single color that forms a continuous vertical stripe (or column) running from top to bottom across the grid. This stripe is usually the separator and is distinct from the repeating interior pattern because it occupies the same column in every row.</description>\\n<example>Imagine a 5×4 grid where column 2 is entirely color X while the other columns show a repeating arrangement of other colors. That full-column of X is the vertical divider you should isolate before doing any further analysis.</example>\\n</note1>\\n\\n<note2>\\n<description>Once you have the divider, remove that column entirely and treat the remaining columns as the interior pattern to analyze. The output grid will be the same number of rows as the input but only contain the columns that were left after the divider was dropped.</description>\\n<example>If the input is 7 rows by 6 columns and you remove one full column, you get 7 rows by 5 columns of interior pixels to work with.</example>\\n</note2>\\n\\n<note3>\\n<description>Within the interior, identify the dominant color by frequency: the color that fills most of the remaining cells. This majority color is the one that defines the interior’s structure and is what the output will represent.</description>\\n<example>Suppose the interior 5 columns contain 20 cells of color A and 10 of other colors; A is the dominant color and is the natural choice for the interior pattern.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide how many rows to keep by inspecting the interior for vertical repetition: if the interior pattern repeats every r rows, keep only one period (the minimal repeating block) so the output has fewer rows but preserves the same column layout. If no clear period exists, keep all interior rows.</description>\\n<example>If the interior shows the same 3-row block repeated down the grid, compress the grid to that 3-row block; if the interior has no repeating block, leave all interior rows intact.</example>\\n</note4>\\n\\n<note5>\\n<description>Finally, produce the output by filling every cell of the reduced interior grid with the dominant color. This produces a compact representation of the interior pattern while discarding the separator and any non-repeating row information.</description>\\n<example>After removing the divider and compressing to one period, fill every remaining cell with the most frequent interior color so the result is a smaller grid showing only that dominant color.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[6, 1, 6, 6], [9, 1, 9, 9], [6, 1, 6, 6], [6, 1, 6, 6], [2, 1, 2, 2], [6, 1, 6, 6], [6, 1, 6, 6], [6, 1, 6, 6], [1, 1, 1, 1], [6, 1, 6, 6], [1, 1, 1, 1], [6, 1, 6, 6], [4, 1, 4, 4], [6, 1, 6, 6], [6, 1, 6, 6], [1, 1, 1, 1], [6, 1, 6, 6], [6, 1, 6, 6], [6, 1, 6, 6], [6, 1, 6, 6], [0, 1, 0, 0], [6, 1, 6, 6]], \"output\": [[6, 6], [6, 6], [6, 6], [6, 6], [6, 6], [6, 6], [6, 6], [6, 6]]}, {\"input\": [[6, 9, 6], [1, 9, 1], [6, 9, 6], [6, 9, 6], [6, 9, 6], [3, 9, 3], [6, 9, 6], [6, 9, 6], [6, 9, 6], [6, 9, 6], [2, 9, 2], [6, 9, 6], [5, 9, 5], [6, 9, 6], [7, 9, 7], [6, 9, 6], [6, 9, 6], [6, 9, 6], [6, 9, 6], [9, 9, 9], [6, 9, 6], [9, 9, 9], [6, 9, 6]], \"output\": [[6, 6], [6, 6], [6, 6], [6, 6], [6, 6], [6, 6], [6, 6], [6, 6]]}, {\"input\": [[0, 0, 0, 0, 4, 0, 7, 0, 1, 0, 8, 0, 8, 0, 0], [5, 5, 5, 5, 4, 5, 7, 5, 1, 5, 8, 5, 8, 5, 5], [0, 0, 0, 0, 4, 0, 7, 0, 1, 0, 8, 0, 8, 0, 0], [0, 0, 0, 0, 4, 0, 7, 0, 1, 0, 8, 0, 8, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]}]"},"test":{"kind":"string","value":"[{\"input\": [[3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [5, 5, 5, 5, 2, 5, 5, 2, 5, 5], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [4, 4, 4, 4, 2, 4, 4, 2, 4, 4], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3]], \"output\": [[3, 3, 3], [3, 3, 3], [3, 3, 3], [3, 3, 3]]}]"},"source":{"kind":"string","value":"rearc"},"prompt":{"kind":"string","value":"You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n6 1 6 6\n9 1 9 9\n6 1 6 6\n6 1 6 6\n2 1 2 2\n6 1 6 6\n6 1 6 6\n6 1 6 6\n1 1 1 1\n6 1 6 6\n1 1 1 1\n6 1 6 6\n4 1 4 4\n6 1 6 6\n6 1 6 6\n1 1 1 1\n6 1 6 6\n6 1 6 6\n6 1 6 6\n6 1 6 6\n0 1 0 0\n6 1 6 6\n```\n\nOutput:\n```\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n```\n\n## Example 2\nInput:\n```\n6 9 6\n1 9 1\n6 9 6\n6 9 6\n6 9 6\n3 9 3\n6 9 6\n6 9 6\n6 9 6\n6 9 6\n2 9 2\n6 9 6\n5 9 5\n6 9 6\n7 9 7\n6 9 6\n6 9 6\n6 9 6\n6 9 6\n9 9 9\n6 9 6\n9 9 9\n6 9 6\n```\n\nOutput:\n```\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n6 6\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 4 0 7 0 1 0 8 0 8 0 0\n5 5 5 5 4 5 7 5 1 5 8 5 8 5 5\n0 0 0 0 4 0 7 0 1 0 8 0 8 0 0\n0 0 0 0 4 0 7 0 1 0 8 0 8 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0\n0 0 0 0 0 0\n```\n\n# Test Problem:\n```\n3 3 3 3 2 3 3 2 3 3\n3 3 3 3 2 3 3 2 3 3\n2 2 2 2 2 2 2 2 2 2\n3 3 3 3 2 3 3 2 3 3\n5 5 5 5 2 5 5 2 5 5\n3 3 3 3 2 3 3 2 3 3\n3 3 3 3 2 3 3 2 3 3\n4 4 4 4 2 4 4 2 4 4\n3 3 3 3 2 3 3 2 3 3\n```"},"answer":{"kind":"string","value":"```\n3 3 3\n3 3 3\n3 3 3\n3 3 3\n```"},"num_tokens":{"kind":"number","value":968,"string":"968"}}},{"rowIdx":99,"cells":{"abstraction_prompt":{"kind":"string","value":"<|im_start|>user\nDeveloper: # ARC HINT GENERATOR\n\n## Role & Goal\nYou are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted hint that helps the user discover the core transformation principle for themselves without revealing the answer.\n\nBegin with a concise checklist (3-7 bullets) of what you will do; keep items conceptual, not implementation-level.\n\n---\n\n## Hint Generation Strategy\n1. **Compare** the input and output grids for each example. Identify the shared transformation pattern that allows the input grid to be converted into the output grid.\n2. **Identify the Core Principle**: Review the problem description and ground-truth solution to fully discern the key transformation rule. Break it down into its essential operations (e.g., object completion, pattern repetition, symmetry, gravity), paying close attention to properties such as object count, shapes, colors, sizes, symmetry, repetition, relative positioning, and broader grid-level patterns.\n3. **Craft a Targeted Hint**: Generate a hint that guides the user toward the core insight needed to solve the problem. The hint should assist the user during their attempt without revealing the solution.\n4. Structure each note using the template below:\n - **Description** (up to 3 sentences): Explain the concept, when and why it applies, and why it is effective. Include any relevant general formula or principle in its most general form.\n - **Example** (up to 6 sentences): Present a worked example covering all aspects of the description, using a simplified yet representative scenario (not necessarily from the current problem).\n - Optionally, include **Heuristics** or **Pitfalls** in the note where relevant.\n - Focus on methodologies and core principles over specific calculations or problem details.\n - Ensure each hint applies broadly—at least 80% of analogous problems.\n\nAfter generating a hint, verify that no specifics of the solution are revealed, and that the hint remains at the level of guiding the approach.\n\n### Output Format\nProduce a **sequence of 5** notes in the structure:\n<note1>\n<description>...</description>\n<example>...</example>\n</note1>\n<note2>\n<description>...</description>\n<example>...</example>\n</note2>\n...\n\n### Design Guidelines\n- Clarity: Use precise language and correct sentence structure.\n- Atomicity: Each note addresses one recognizable sub-problem.\n- Self-containment: All information needed to understand the idea and its application is within the note.\n- Generalizability: Avoid problem-specific details or variables.\n- Transferability: Notes should apply across a class of problems.\n- Distinctness: Each note addresses a distinct principle.\n\n---\n\n## Guidelines\n- **Guide, Don't Solve**: Illuminate the approach, not the answer. Emphasize what to observe or consider.\n- **Specific yet Abstract**: Use concrete grid details (e.g., \"note the relationship between the blue and red pixels\") to ground abstract patterns (e.g., \"think about one color containing another\").\n\nValidate your generated hint: confirm it is self-contained, actionable, and nondirective. If any aspect is too revealing, revise before finalizing.\n\n---\n\n## Inputs\n### Problem Description\nA full ARC problem, including input/output pairs for training and testing.\n\nYou will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 2 2 0 0 0 0 2 2 0 2 0 0 2 0\n0 0 2 2 2 0 0 0 0 0 0 0 2 2 2 2 0\n0 0 2 2 2 0 0 0 0 0 0 0 2 2 2 2 0\n2 0 0 2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 0 2 2 2 0 0 0 0 0 0 0 0\n2 0 0 0 0 0 0 2 2 2 0 0 0 0 0 0 0\n2 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0 0\n2 0 0 0 0 0 0 0 0 2 0 0 0 0 0 2 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 2 2\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 6 6 0 0 0 0 6 6 0 6 0 0 6 0\n0 0 6 6 6 0 0 0 0 0 0 0 6 6 6 6 0\n0 0 6 6 6 0 0 0 0 0 0 0 6 6 6 6 0\n6 0 0 6 6 0 0 0 0 0 0 0 0 0 0 0 0\n6 6 0 0 0 0 6 6 6 0 0 0 0 0 0 0 0\n6 0 0 0 0 0 0 6 6 6 0 0 0 0 0 0 0\n6 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0 0\n6 0 0 0 0 0 0 0 0 6 0 0 0 0 0 4 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 4 4\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 0\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 2 0 0 2 0 0 0 0 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n2 0 0 0 0 0 0 0 0 0 2 2 0 0 0\n2 2 2 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 0 2 2 0 0 2 0 0 2\n0 0 0 0 0 0 0 2 2 0 0 2 2 2 2\n0 0 0 0 0 0 0 0 0 0 0 2 2 2 2\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 6 0 0 6 0 0 0 0 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n4 0 0 0 0 0 0 0 0 0 6 6 0 0 0\n4 4 4 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 0 6 6 0 0 6 0 0 6\n0 0 0 0 0 0 0 6 6 0 0 6 6 6 6\n0 0 0 0 0 0 0 0 0 0 0 6 6 6 6\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0 2 2 0 0 0\n0 0 0 0 0 2 0 0 0 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 0 0 0 0 2 2 0 0 0\n2 2 0 2 2 2 2 2 0 0 0 2 2 0 0 0\n2 0 0 0 2 2 2 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 2 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 2 2 2 2 2\n0 0 0 0 0 0 0 0 0 0 0 0 2 2 2 0\n0 0 0 0 2 2 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 2 2 2 0 0 0 2 2 2 0 0 0\n0 0 0 0 2 2 2 0 0 0 2 2 2 0 0 0\n0 0 0 0 2 2 0 0 0 0 2 0 2 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0 6 6 0 0 0\n0 0 0 0 0 6 0 0 0 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 0 0 0 0 6 6 0 0 0\n4 4 0 6 6 6 6 6 0 0 0 6 6 0 0 0\n4 0 0 0 6 6 6 0 0 0 0 0 0 0 0 0\n4 4 0 0 0 6 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 6 6 6 6 6\n0 0 0 0 0 0 0 0 0 0 0 0 6 6 6 0\n0 0 0 0 6 6 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 6 6 6 0 0 0 6 6 6 0 0 0\n0 0 0 0 6 6 6 0 0 0 6 6 6 0 0 0\n0 0 0 0 6 6 0 0 0 0 6 0 6 0 0 0\n```\n\n# Test Problem:\n```\n0 0 2 2 0 2 2 0 0 0 0 0 0 0\n0 0 2 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 0 0 0 0 0 2 2 0 0 0\n2 2 0 0 0 0 0 0 0 2 2 0 0 0\n2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 0 0 0 0 0 2 0 2 0\n0 0 0 0 0 0 0 0 0 2 2 2 2 2\n0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 2 2 0 0 0 2 2 0 0 0 0 0 0\n2 2 0 0 0 0 2 2 0 0 0 0 0 0\n2 2 0 0 0 0 2 2 0 0 2 2 2 0\n0 2 2 0 0 0 0 0 0 0 2 2 2 0\n```\n\n---\n\n\n# Generated Hint<|im_end|>\n<|im_start|>assistant\n"},"abstraction_prompt_length":{"kind":"number","value":3734,"string":"3,734"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>Look for the single non-background color that forms the objects of interest. When the input has one dominant color against a uniform background, that color is the one the transformation targets; everything else (including the background) is left unchanged.</description>\n<example>Imagine a grid with mostly zeros and a few blue pixels forming shapes. Treat blue as the object color and ignore the zeros when deciding which pixels to recolor.</example>\n</note1>\n\n<note2>\n<description>Group same-colored pixels into connected components using orthogonal (up/down/left/right) adjacency. Each such connected group is a distinct object to be considered independently.</description>\n<example>For example, two blue pixels that touch only at a corner are two separate components if you use orthogonal adjacency; two blue pixels that touch by a side are one component.</example>\n</note2>\n\n<note3>\n<description>Compute each component's bounding box (min/max row and column) and use the box's height and width to classify the object: small boxes (height × width ≤ 2) are single-pixel or two-pixel objects, while larger boxes indicate multi-pixel shapes.</description>\n<example>If a component spans one column and two rows, its bounding box is 2×1 and counts as a small object. If another component spans three columns and two rows, its box is 2×3 and is a larger shape.</example>\n</note3>\n\n<note4>\n<description>Apply a consistent recoloring rule to all components: recolor every pixel of the small-component objects with one new color and recolor every pixel of the larger-component objects with a different new color. Do not change background pixels or any other colors.</description>\n<example>So a single pixel or a two-pixel L-shape becomes color A everywhere it appears, while a three- or more-pixel blob becomes color B everywhere it appears.</example>\n</note4>\n\n<note5>\n<description>Handle ambiguous cases by using the component's bounding-box area (or the number of pixels) as the primary discriminator; if two components have similar area, use a deterministic tie-breaker like topmost then leftmost component. After recoloring, verify that background and other colors are preserved.</description>\n<example>If two components both have a 2×2 bounding box, choose the one whose top row is smallest (and if tied, the leftmost) as the \"small\" class and recolor accordingly; then check that zeros and any other colors remain unchanged.</example>\n</note5>","<note1>\n<description>First isolate the target color: identify which non-background color is being transformed. This is usually the color that appears as several disconnected blobs; focus on those connected components rather than background pixels.</description>\n<example>Imagine a grid with zeros everywhere except a few red pixels forming three separate blobs. Treat those red pixels as the objects to analyze and ignore the black background for now. Knowing which color is the object simplifies the next steps.</example>\n</note1>\n\n<note2>\n<description>For each connected component, compute its bounding box and its centroid (the average of the component’s coordinates). The centroid gives a compact position that you can compare across components.</description>\n<example>Take a component that occupies rows 3–6 and columns 7–9: its bounding box is that rectangle and its centroid is the average of those coordinates. Do this for every component so you have a single representative point for each object.</example>\n</note2>\n\n<note3>\n<description>Order the components by their centroid’s y-coordinate (top-to-bottom). Use that ordering to decide which component is “topmost” and which is “bottommost.”</description>\n<example>If three centroids have y-values 2, 6 and 10, label them from top to bottom as A, B, C. This ordering is robust even if centroids share the same y-value (then break ties by x-coordinate).</example>\n</note3>\n\n<note4>\n<description>Classify components by their rank in that ordered list: the topmost component is one class, the bottommost component is another class, and any components that lie strictly between them form a third class. The number of classes is determined by how many distinct ranks exist.</description>\n<example>With three components A (top), B (middle), C (bottom), you get three classes. With only two components, you would have two classes. With more components, the middle group will be the third class.</example>\n</note4>\n\n<note5>\n<description>Recolor each component according to its class: map one class to a single replacement color, another class to a different replacement color, and any middle group to a third color. Apply the recoloring to every pixel of that component and leave the background unchanged.</description>\n<example>So if you have three classes, recolor all pixels of the topmost component with color X, all middle components with color Y, and all bottommost with color Z. This produces a consistent, ordered recoloring that preserves the shapes but separates them by position.</example>\n</note5>","<note1>\n<description>First, identify the object color and treat each connected region of that color as an independent entity. This reduces the problem to comparing a small set of shapes rather than every pixel. Recognizing these objects lets you reason about their size and shape independently of background noise.</description>\n<example>Imagine a grid with several blue islands on a black background. Mark each blue island by grouping adjacent blue pixels (up/down/left/right). You now have a small list of objects: three islands of sizes 3, 6 and 10, which you can compare and transform as separate units.</example>\n</note1>\n\n<note2>\n<description>Compute each object's bounding box and use its area (number of pixels) as the primary distinguishing feature. The area is a robust, easy-to-compare numeric property that often determines the transformation. If areas differ, that numeric difference usually drives the change in the output.</description>\n<example>For the three blue islands you found, their bounding-box areas might be 4, 6 and 10. Record these values so you can later decide how each island should be handled based on its size.</example>\n</note2>\n\n<note3>\n<description>Look for a simple partition of objects by size: typically the largest object is handled differently from the rest. Many tasks treat the largest object as an exception and apply a different rule to it while the remaining objects receive a single uniform treatment. This is effective when outputs show one object in a distinct color and the others in the same color.</description>\n<example>Given the areas 4, 6 and 10, you might decide that the object with area 10 is special and should be recolored differently, while the objects with areas 4 and 6 are recolored the same way.</example>\n</note3>\n\n<note4>\n<description>When recoloring, preserve each object's geometry and position exactly: do not move, rotate, or reshape objects—only change their color. The transformation should be a uniform recoloring of whole objects, not a pixel-by-pixel edit. This keeps the spatial relationships intact while applying the color rule.</description>\n<example>If a 3×2 block sits at the top-left in the input, it should remain a 3×2 block at the same coordinates in the output but in the new color you assigned to that object's size class.</example>\n</note4>\n\n<note5>\n<description>Be consistent across the grid: apply the same recoloring rule to every object of the same size class and use a single distinct color for the special-case object. Use a consistent tie-breaker (for example, pick the largest object as the exception) when two objects share the same size. This ensures the output is unambiguous and matches the pattern seen in the training examples.</description>\n<example>If two objects both have area 6, recolor both the same way; if there is a single object of area 10, recolor it with the other distinct color. After applying these rules to all objects, verify the overall layout and color counts match the expected pattern.</example>\n</note5>","<note1>\n<description>First separate foreground pixels from background and treat each connected group of the same non-background color as an object. Working at the object level (not individual pixels) makes it easier to see repeated shapes and their positions.</description>\n<example>Imagine a grid where a single color appears as three separate patches. Record each patch as an object with its bounding box and pixel pattern. You can then compare these objects to one another instead of scanning every pixel.</example>\n</note1>\n\n<note2>\n<description>Compute simple geometric descriptors for each object (area, bounding-box width and height, whether it touches the top or left edge, and whether it is symmetric). These descriptors are often the distinguishing features the task uses to classify objects.</description>\n<example>For instance, if two objects have the same area but one has a bounding box that is wider than tall and the other is square, treat those as different cases. If an object touches the left edge, mark that as a distinguishing attribute.</example>\n</note2>\n\n<note3>\n<description>Look for a consistent rule that assigns a different output color to objects sharing the same descriptor set. In many puzzles the transformation is “group by descriptor, then repaint each group uniformly.”</description>\n<example>If you find three objects that all have area 6 and touch the left edge, they should receive the same new color in the output; if another object has area 6 but does not touch the left edge, it should get a different color.</example>\n</note3>\n\n<note4>\n<description>Decide how to break ties and assign colors so the mapping is deterministic. A common, robust tie-break is to use the object’s topmost row (or the leftmost column) as a secondary key when shapes are identical by other descriptors.</description>\n<example>If two objects share area and orientation, pick the one that appears higher (smaller row index) as the representative and give it one output color; the other identical shape gets the other color. This avoids ambiguity while preserving the original ordering information.</example>\n</note4>\n\n<note5>\n<description>When you recolor, preserve each object’s exact shape and location—only change the color value—and leave the background untouched. Finally, verify that the recoloring is consistent across the training examples before applying it to the test grid.</description>\n<example>After you decide a rule like “group by area+edge-touch and recolor groups,” apply that rule to every object in the input: repaint each object with its group color but do not move or resize it. Check that every object in the training outputs follows the same recoloring pattern.</example>\n</note5>","<note1>\n<description>Look for the dominant color that forms the shapes you must transform. When one color appears far more often than background and other colors, treat that color as the object to be recolored in the output.</description>\n<example>Imagine a grid where black is background and many red pixels form several shapes; red is the object to act on. If you see a single color filling most non-background cells, that color is the one you will consider for recoloring.</example>\n</note1>\n\n<note2>\n<description>Group connected pixels of the object color into separate components (use 4‑connectivity). Each connected component is an independent object to analyze and may receive a different treatment.</description>\n<example>For example, a 3×3 red square and a separate 2×2 red square are two components even though they share the same color. Work with those two components separately rather than mixing them.</example>\n</note2>\n\n<note3>\n<description>For each component, compute its bounding box (min/max row and column) and the component’s width and height. These measures give a concise description of the object’s shape and orientation.</description>\n<example>If a component occupies rows 2–4 and columns 5–6 its bounding box is height=3 and width=2; another component that spans rows 7–9 and columns 2–3 has height=3 and width=2, but different coordinates.</example>\n</note3>\n\n<note4>\n<description>Compare bounding boxes across components: the key distinguishing property is whether a component’s bounding box is square (width == height). Components with equal width and height are treated differently from non-square components.</description>\n<example>Two components both with height=2 and width=2 are square components; a component with height=3 and width=2 is not square. Use this equality test to classify components rather than relying on size alone.</example>\n</note4>\n\n<note5>\n<description>Apply a single consistent recoloring rule to all components: recolor every square component with one new color and recolor every non-square component with a second new color; leave background pixels unchanged. This preserves shapes while making the classification visually clear.</description>\n<example>Given several red components, recolor every red component whose bounding box is a perfect square to the same blue fill, and recolor every other red component to a different green fill. The result is the same shape in the output but with two distinct colors marking square vs. non-square components.</example>\n</note5>","<note1>\n<description>Start by isolating the non-background objects: collect all maximal connected components of the colored pixels and treat each component as an independent object. This reduces the problem to comparing a small set of shapes instead of many scattered pixels. Work with the shapes' outlines or bounding boxes so you can reason about size and orientation.</description>\n<example>Imagine a grid with several separate clusters of the same color. For each cluster, mark its bounding box and note whether it is a compact square, a long bar, or an irregular blob. You now have a small set of objects to compare rather than many individual pixels.</example>\n</note1>\n\n<note2>\n<description>Compare the objects by a geometric property such as area (pixel count) or bounding-box area, and count how many objects share that property. The transformation often distinguishes between \"most common\" and \"rare\" objects by this measure. Use the training pairs to infer which property is being used.</description>\n<example>If you find three 2×2 squares and several other shapes, the 2×2 squares are the \"most frequent\" objects and are treated differently from the rarer shapes. Counting occurrences helps you identify which shapes to recolor separately.</example>\n</note2>\n\n<note3>\n<description>Decide which color to apply to the common objects and which color to apply to the rare objects. The output typically uses one distinct color for all objects of the same class (common) and another distinct color for the remaining objects (rare). Treat the background as unchanged.</description>\n<example>For instance, if the common objects are recolored uniformly to color A and the rare ones to color B, every object of the same class in the test grid should receive the same color. This preserves the original shapes while making the class membership explicit.</example>\n</note3>\n\n<note4>\n<description>Apply the recoloring globally: recolor every pixel belonging to the identified common-class objects and every pixel belonging to the rare-class objects, regardless of their original color. Do not change background pixels. This keeps the spatial arrangement intact while highlighting the class difference.</description>\n<example>Given a grid with two classes, change every pixel of the first class to the common color and every pixel of the second class to the rare color. The shapes' positions and shapes remain identical, only their colors are reassigned according to class.</example>\n</note4>\n\n<note5>\n<description>Use simple heuristics to avoid common mistakes: ensure you treat each connected component independently (not the whole grid), prefer the most frequent connected component as the target class, and check that the rare class is not empty. If there is a tie, prefer the class that appears as the largest connected component or the one with the most pixels.</description>\n<example>If two classes are equally frequent, choose the one with the larger bounding box or the greater pixel count as the \"common\" class; then recolor the other class uniformly. This avoids ambiguous decisions when multiple colors or shapes could be candidates.</example>\n</note5>","<note1>\n<description>Separate objects by grouping same-colored pixels into connected components (4‑connected adjacency). Treat each group as a single object so you can reason about whole shapes instead of individual pixels.</description>\n<example>Imagine a grid with several red clusters. Mark every red pixel and connect horizontally or vertically adjacent red pixels to form components; each distinct cluster becomes one object you will analyze.</example>\n</note1>\n\n<note2>\n<description>For each object, compute its bounding box (min/max row and column) and the box’s height and width. The bounding box gives a compact way to compare the shapes and to identify the object that is different.</description>\n<example>If one object covers rows 2–4 and cols 5–6, its bounding box is height 3 and width 2. Repeat for every object so you can compare their sizes and shapes.</example>\n</note2>\n\n<note3>\n<description>Look for an object whose bounding box is square (height equals width). That square bounding box is the distinguishing feature in these tasks and is usually the one to treat differently from the others.</description>\n<example>Among several rectangles you might find one whose bounding box is 2×2, 3×3, or 4×4. That square box stands out and should be considered the special object.</example>\n</note3>\n\n<note4>\n<description>Recolor the identified square object with a distinct color while leaving all other objects in their original color. This makes the special shape visually and logically separate from the rest.</description>\n<example>After finding the square object, change every pixel of that object to a new color so it is clearly marked, while all other colored pixels remain unchanged.</example>\n</note4>\n\n<note5>\n<description>Be careful not to confuse filled squares with other rectangular shapes: use the bounding-box test (height == width) and check that the object is not simply a 1×1 pixel. Avoid changing background zeros or unrelated colors.</description>\n<example>A 2×2 filled square has height 2 and width 2, while a 2×4 rectangle has height 2 and width 4—those two are not the same. Also ensure you recolor only the object’s pixels, not the surrounding background.</example>\n</note5>","<note1>\n<description>Locate the target color by frequency: the transformation acts on the color that appears most often in the grid. This is effective because the examples always change the majority-colored pixels while leaving other colors or background alone.</description>\n<example>Imagine a 6×6 grid where color A appears 18 times and all other colors appear fewer times; A is the target for the transformation. Counting occurrences across the whole grid quickly isolates A as the candidate to be recolored.</example>\n</note1>\n\n<note2>\n<description>Check the output for a single replacement color: the majority color is uniformly replaced by one new color across all examples, while other colors remain unchanged. The rule is a global recoloring of that color rather than a geometric operation.</description>\n<example>For example, if color A appears in many disconnected blobs in the input, the output shows all those blobs in the same new color B, with every other color preserved exactly as in the input.</example>\n</note2>\n\n<note3>\n<description>Verify that shapes and positions are preserved: the transformation only changes color values, not pixel coordinates or object geometry. So you can treat each connected component of the target color as an intact object before recoloring.</description>\n<example>If a blob of A occupies rows 2–4 and columns 5–7 in the input, it will occupy the same rows and columns in the output but with the new color B; the shape and location are identical.</example>\n</note3>\n\n<note4>\n<description>Confirm the background and minority colors are left untouched: only the most frequent color is targeted. This tells you not to alter zeros or any other colors that appear in the grid.</description>\n<example>For instance, if the background is black (0) and other colors are C and D, those pixels should remain as 0, C and D respectively in the output while the dominant color A is replaced.</example>\n</note4>\n\n<note5>\n<description>Use simple heuristics to avoid pitfalls: always use the global count (not local counts inside a single object), and if multiple colors tie for most frequent, prefer the color that appears across multiple disconnected objects. These checks help resolve ambiguous cases.</description>\n<example>If two colors each occur 12 times but one spans several separate blobs while the other is a single isolated pixel, the spanning color is the one to recolor. Also, double-check that the replacement is applied to every instance of the chosen color, not just a subset.</example>\n</note5>","<note1>\n<description>Start by isolating the non-background pixels and grouping them into connected components. Treat each contiguous patch of the same color as a separate object so you can reason about shape, size and position independently.</description>\n<example>Imagine a grid with many scattered blue pixels: first mark all blue cells, then group them by adjacency into distinct blobs. Each blob is a candidate object to analyze further (count pixels, compute bounding box, look at orientation).</example>\n</note1>\n\n<note2>\n<description>Compare component sizes: many ARC tasks separate objects by size (e.g., small vs large). Compute the number of pixels for each component and use that count as the primary criterion for distinguishing objects.</description>\n<example>For example, if you find several blobs and one blob contains exactly 3 pixels while others are 4 or more, that single 3-pixel blob is a natural candidate for a different treatment than the larger blobs.</example>\n</note2>\n\n<note3>\n<description>Once you identify a target object by size, change its color while leaving every other cell unchanged. The transformation is a recoloring operation: keep geometry and coordinates the same, only change the color label.</description>\n<example>Take a 3-pixel blob you identified; replace each of its cells with the new color (call it color A) but do not move or reshape it. All other pixels remain exactly as in the input.</example>\n</note3>\n\n<note4>\n<description>Choose a single replacement color that is distinct from the background and any other colors present in the input so the change is unambiguous. Use a color not used elsewhere to avoid confusion with other objects.</description>\n<example>If the input uses colors 0 (background) and 2, pick a third color (for example, color 6) to recolor the target object; this makes it visually and logically separate from the original shapes.</example>\n</note4>\n\n<note5>\n<description>Use simple tie-breakers when multiple small objects exist: prefer a uniquely sized object, or break ties by proximity to the grid center. After applying the rule, verify that the transformed grid matches the training examples' pattern of recoloring only the intended objects.</description>\n<example>If two blobs both have the same small size, pick the one whose bounding box is closer to the grid center or the one that is uniquely small in the examples; then check that only that blob's color changed and all other pixels stayed the same.</example>\n</note5>","<note1>\n<description>Look for the single non-background color that forms many separate objects. This color is the only one that changes between input and output, so isolating it reduces the problem to a small set of objects to analyze.</description>\n<example>Imagine a grid with many tiny red shapes on a black background. Count the cells of red: if red is the only color with a nonzero count, you can focus only on the red objects and ignore other colors for the transformation.</example>\n</note1>\n\n<note2>\n<description>Group every connected component of the target color into objects (use orthogonal adjacency). Treat each such connected group as a single item to be compared across examples.</description>\n<example>For instance, if you see three separate red blobs, treat each blob as one object. Label them by their bounding boxes (min/max row and column) and record their sizes and positions rather than individual pixels.</example>\n</note2>\n\n<note3>\n<description>Look for a consistent size-based rule across the examples: one object class is recolored uniformly and the other class is recolored uniformly, and the rule is based on object size. Find which size class is treated the same in every training pair.</description>\n<example>Suppose the training pairs show that every object of size 6 or larger becomes color A while every smaller object becomes color B. That indicates a size-based classification rather than a positional or shape-based rule.</example>\n</note3>\n\n<note4>\n<description>Decide how the two output colors are assigned to the two size classes: check whether the larger class is always given one specific color and the smaller class the other. This gives you a deterministic mapping to apply to the test grid.</description>\n<example>If in every example the biggest objects are recolored with color A and the smaller ones with color B, then when you recolor objects in the test grid, give each object the color corresponding to its class (big → A, small → B).</example>\n</note4>\n\n<note5>\n<description>After recoloring, verify the result: the number of objects and their shapes should match the input, only their colors changed; the background should remain unchanged. This confirms you applied the correct classification and mapping.</description>\n<example>As a final check, count how many objects of each size you have in the test input and make sure you recolored exactly that many objects to the appropriate color classes. If counts or shapes differ, re-check your object detection or the size threshold you inferred from the examples.</example>\n</note5>","<note1>\n<description>Start by listing every connected component of the target color (here, the non-background pixels). Treat each contiguous group as a separate object and record its pixel count and bounding box — these are the basic units the transformation will operate on.</description>\n<example>For instance, if you see three separate blobs of the same color, note their sizes (e.g., 2, 3 and 5 pixels) and their bounding boxes. These counts and positions are what you will compare across the examples to infer the rule.</example>\n</note1>\n\n<note2>\n<description>Look for a simple global recoloring: many tasks replace all occurrences of the target color with a single new color. If so, the shape and location of objects remain identical while only their color changes.</description>\n<example>Imagine a grid with several blue islands; if every blue island becomes green in the output, that indicates a uniform color substitution rather than moving or reshaping the islands.</example>\n</note2>\n\n<note3>\n<description>Search for a secondary, selective recoloring that depends on object size. Often the smallest object is treated differently from the others — check whether the smallest component is recolored to a distinct color while larger components keep the main color.</description>\n<example>Suppose three islands have sizes 2, 4 and 7; if the output shows one island recolored to a different color and the other two islands are the same color, that points to a size-based secondary rule (the smallest island is singled out).</example>\n</note3>\n\n<note4>\n<description>Be explicit about how you measure “smallest”: compare connected components by the number of pixels they contain, not by area in a bounding-box sense. Use orthogonal (4‑connected) adjacency unless the examples indicate diagonal connectivity.</description>\n<example>If two blobs touch diagonally but are separated by a background cell, they are two separate components and should be counted separately. The correct rule will pick the component with the fewest pixels, not the one with the smallest bounding-box width.</example>\n</note4>\n\n<note5>\n<description>Validate your hypothesis by applying the two-step recoloring to each training example: first recolor all target-color pixels to the main replacement color, then recolor the smallest component(s) to the secondary color. If this reproduces every training output, the rule is consistent.</description>\n<example>Try the rule on a simple grid: recolor every blob to color A, then recolor the smallest blob to color B. If that matches the example outputs, you can confidently use the same two-step approach on the test grid.</example>\n</note5>","<note1>\n<description>Find the target color by frequency: the color that appears many times in the input is the one being transformed. This is effective because the transformation is applied to a single, dominant color while other colors remain unchanged.</description>\n<example>Imagine a grid where one color fills most non-background pixels and another color appears only a few times. The first step is to identify that dominant color — it is the one you will recolor in the output.</example>\n</note1>\n\n<note2>\n<description>Compare shapes, not just counts: treat each contiguous region of the target color as a separate object and compare their geometry (area, bounding box, number of pixels, and whether they are compact or have holes). The rule often picks one geometric class (for example, the largest or most compact objects).</description>\n<example>For instance, if two regions both have the same pixel count but one is a solid filled block and the other has a missing pixel, the solid block is a different geometric shape and may be treated differently from the hole-containing object.</example>\n</note2>\n\n<note3>\n<description>Look for a simple, consistent recoloring rule: the dominant color is usually replaced by a single new color in the output, while the other color is recolored to a second, distinct color. The mapping is global (all occurrences of the dominant color become one new color) and the other color becomes a different new color.</description>\n<example>Think of a transformation that changes every occurrence of the dominant color to one new color and every occurrence of the other color to another new color; this produces two clear, uniform recolor classes across the grid.</example>\n</note3>\n\n<note4>\n<description>Use symmetry and positional checks to confirm the selection: sometimes the chosen object is the one that is symmetric, centrally located, or has a particular orientation (for example, an axis-aligned square or a symmetric shape). If multiple objects are symmetric, prefer the largest or most central one.</description>\n<example>If several objects are present and one stands out because it is perfectly square and centered, that object is a strong candidate to be treated differently from the others in the output.</example>\n</note4>\n\n<note5>\n<description>Apply the rule consistently across the whole grid and verify by checking that all occurrences of the selected class receive the same new color and that every occurrence of the other color receives the other new color. Watch for edge cases like very small objects that are ignored by the rule.</description>\n<example>After choosing which class to recolor, recolor every pixel of that class the same way and every pixel of the other color the other way; the correct rule will produce two uniform recolor classes and leave background pixels unchanged.</example>\n</note5>","<note1>\n<description>Focus first on the foreground color: many ARC tasks change only the non-background pixels while leaving background cells unchanged. This means you can ignore zeros and treat every non-zero cell as part of the same object set to analyze.</description>\n<example>Imagine a 6×6 grid with zeros everywhere except one color occupying several connected pixels. If the output keeps zeros in place and only alters those colored pixels, you should first isolate all colored cells and ignore the black background when searching for a pattern.</example>\n</note1>\n\n<note2>\n<description>Group the foreground pixels into connected components (orthogonal adjacency). Treat each contiguous blob as an independent object and record its basic properties: number of cells, bounding box, centroid, and whether it is an L-shape or a compact square.</description>\n<example>For example, a 3×3 block is a compact square and should be treated as one object, while three pixels touching in an L shape are a different object. Label each object so you can compare them consistently across the grid.</example>\n</note2>\n\n<note3>\n<description>Compare the objects by simple numeric invariants: area (pixel count), bounding-box side length, and whether the bounding box is filled. These invariants often reveal which objects are “special” (e.g., the largest or uniquely shaped).</description>\n<example>Suppose you find three objects with sizes 4, 6 and 10 pixels; the 10-pixel object is the largest and will usually be singled out by a transformation. If one object’s bounding box is filled while others are not, that filled box is also a strong indicator.</example>\n</note3>\n\n<note4>\n<description>Use the training examples to infer the mapping: one distinct object type is recolored uniformly while the rest keep their original color. The mapping is typically applied consistently across the whole grid, so once you identify which object class is special, recolor every instance of that class the same way.</description>\n<example>If two identical L-shaped objects in the training inputs are shown in a different color while all other objects remain the same, then the rule is “recolor all L-shapes” and leave other shapes untouched. Apply that same rule to the test grid.</example>\n</note4>\n\n<note5>\n<description>Be careful with tie-breakers and orientation: when two objects share the same size or shape, check secondary features (position, orientation, or whether a bounding box is filled) to decide which to recolor. Also verify that the background (zeros) stays unchanged.</description>\n<example>If two components both have 6 pixels but one is a filled 2×3 rectangle and the other is an L-shape, prefer the filled rectangle as the special object. Always confirm your choice against the examples before recoloring.</example>\n</note5>","<note1>\n<description>Find the primary object by grouping all non-background pixels and computing the minimal bounding rectangle that contains them. This rectangle is the natural unit to compare across examples and isolates the pattern to inspect.</description>\n<example>Imagine a grid with a single colored blob: its bounding rectangle is the smallest rectangle that contains every pixel of that blob. Treat that rectangle as the object to analyze rather than individual scattered pixels.</example>\n</note1>\n\n<note2>\n<description>Within that bounding rectangle, count the number of colored pixels and the number of rows that contain at least one colored pixel (the vertical span). These two numbers (pixel count and row span) are the key quantitative features to compare across examples.</description>\n<example>If the bounding box is 3 rows tall and contains 4 colored pixels, record (height=3, count=4). If the box is 2 rows tall and contains 3 colored pixels, record (height=2, count=3). Use these pairs to find a consistent mapping.</example>\n</note2>\n\n<note3>\n<description>Look for a simple one-to-one mapping from the object's feature values to a color label: the same feature value always maps to the same output color. In many tasks the mapping is determined by comparing pairs of objects (e.g., \"which feature distinguishes object A from object B\") rather than by a formula like pixel count squared.</description>\n<example>Suppose you find two objects with the same height but different row spans, and the examples show they receive two different colors. That indicates a mapping based on the row-span value rather than the absolute pixel count.</example>\n</note3>\n\n<note4>\n<description>When recoloring the test grid, keep each object's pixels in place and change only their color according to the mapping you inferred. Do not move, resize, or remove objects—preserve their shapes and positions.</description>\n<example>If an object's bounding rectangle matches the training object's rectangle (same height and row-span), recolor all its pixels to the corresponding color you identified. If it does not match, check whether it matches another training object or whether a different feature (such as whether a pixel sits on an edge) determines the label.</example>\n</note4>\n\n<note5>\n<description>Use quick sanity checks: compare training pairs to confirm the mapping is consistent, and verify that identical rectangles in different examples share the same color. If you encounter a rectangle that doesn't match any training pair, re-evaluate whether you misidentified the object or whether another feature (edge position, aspect ratio) is the deciding factor.</description>\n<example>If two different training rectangles both have height 2 and you see they are both recolored the same way, that supports a \"height → color\" rule. If a new rectangle with height 2 still requires a different color, look for a secondary feature (for example, whether the top row of the bounding box is fully filled) that breaks the tie.</example>\n</note5>","<note1>\n<description>First, identify the objects: treat every contiguous group of non-background pixels as an object and record its pixel count (size). This reduces the problem from many pixels to a few objects whose sizes determine the transformation.</description>\n<example>Imagine a grid with several blobs of the same color. For each blob count how many colored pixels it contains (e.g., sizes 5, 6, 7). Those numeric sizes are the quantities you will compare across examples.</example>\n</note1>\n\n<note2>\n<description>Compare the sizes across examples to find a consistent ordering. Often the transformation is driven by rank: the object with the largest size is treated differently from the other objects, which are treated the same way.</description>\n<example>Suppose three objects have sizes 4, 5 and 6. If the output changes only the object of size 6 while the others are changed similarly, then “largest-by-size” is the key property to use.</example>\n</note2>\n\n<note3>\n<description>Decide how colors are reassigned: typically all non-background objects receive one new color and the largest object receives a second new color. The background (zeros) stays unchanged.</description>\n<example>With two replacement colors available, you might see every object painted with color A except one object painted with color B. That tells you the rule is “one uniform recolor for all objects, one special recolor for the largest object.”</example>\n</note3>\n\n<note4>\n<description>Choose the distinguishing property by checking invariants: compare size, bounding-box area, perimeter, and connectedness. The correct property is the one that is consistent across examples (e.g., largest size is preserved while other objects are grouped together).</description>\n<example>If two objects have the same bounding-box area but different numbers of pixels, and only the one with more pixels is singled out in the outputs, then pixel count (size) is the distinguishing invariant rather than bounding-box area.</example>\n</note4>\n\n<note5>\n<description>Before finalizing, verify the rule on every training pair and watch for pitfalls: do not confuse background with objects, do not treat separate disconnected components of the same color as one object, and ensure the chosen invariant is unique across examples.</description>\n<example>After you pick “largest-by-pixel-count” as the invariant, apply the recoloring to each training input and confirm the outputs match exactly. If any training example fails, try the next invariant (e.g., bounding-box area or perimeter) until one consistently explains all examples.</example>\n</note5>","<note1>\n<description>First isolate the objects: treat every contiguous region of non‑zero pixels as a separate object and record its bounding box and footprint. This reduces the problem from many pixels to a small set of shapes you can compare.</description>\n<example>Imagine a grid with three colored blobs. Draw the smallest rectangle around each blob and write down how many pixels each blob has and what those pixels look like (for example, a filled square vs a 3×3 block with a missing corner). These summaries let you reason about shapes without looking at every cell.</example>\n</note1>\n\n<note2>\n<description>Look for a single color that is used to mark one class of objects while the rest are recolored to a different color. The rule usually applies consistently across the grid: all objects of that class are changed together, and all others are changed to the same other color.</description>\n<example>For instance, if you see that two identical shapes in the input both become the same new color in the output, while every other object becomes a third color, that indicates a two‑class recoloring: one class is marked by a distinct color, the rest share another color.</example>\n</note2>\n\n<note3>\n<description>Decide the selection criterion by comparing object properties: area, bounding box dimensions, symmetry, or a simple footprint count. Many tasks pick the class by a numeric property (for example, “the largest area” or “the one with a particular aspect ratio”).</description>\n<example>Suppose the grid contains three blobs and their areas are 12, 18 and 4. If the output keeps the 18‑area blob in its special color and recolors the other two, then the selection rule is “largest area.” Try the same numeric test on the training pairs to confirm which property is used.</example>\n</note3>\n\n<note4>\n<description>Apply the recoloring globally and uniformly: once you know which class to mark and which color to use for the rest, recolor every pixel of each object according to that class. The spatial arrangement and internal pattern of each object should remain unchanged except for color.</description>\n<example>If you determine that all 3×3 filled squares should be recolored to the marker color and all other objects to the secondary color, then every 3×3 square in the test grid should receive the marker color and every other object the secondary color—no rotation, reflection, or relocation should occur.</example>\n</note4>\n\n<note5>\n<description>Watch for edge cases: disconnected pieces of the same color are usually treated as one object, and identical shapes in different places should be handled consistently. If more than one property seems plausible, prefer the property that is consistent across all training examples.</description>\n<example>If a color appears as two separate blobs, treat them as two objects and recolor each according to its class. If two objects share the same size and shape but only one is recolored in the examples, recheck whether the rule uses a secondary property (position, orientation, or a numeric tie‑break) rather than just size.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Look for the single non-background color that forms the objects of interest. When the input has one dominant color against a uniform background, that color is the one the transformation targets; everything else (including the background) is left unchanged.</description>\\n<example>Imagine a grid with mostly zeros and a few blue pixels forming shapes. Treat blue as the object color and ignore the zeros when deciding which pixels to recolor.</example>\\n</note1>\\n\\n<note2>\\n<description>Group same-colored pixels into connected components using orthogonal (up/down/left/right) adjacency. Each such connected group is a distinct object to be considered independently.</description>\\n<example>For example, two blue pixels that touch only at a corner are two separate components if you use orthogonal adjacency; two blue pixels that touch by a side are one component.</example>\\n</note2>\\n\\n<note3>\\n<description>Compute each component's bounding box (min/max row and column) and use the box's height and width to classify the object: small boxes (height × width ≤ 2) are single-pixel or two-pixel objects, while larger boxes indicate multi-pixel shapes.</description>\\n<example>If a component spans one column and two rows, its bounding box is 2×1 and counts as a small object. If another component spans three columns and two rows, its box is 2×3 and is a larger shape.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply a consistent recoloring rule to all components: recolor every pixel of the small-component objects with one new color and recolor every pixel of the larger-component objects with a different new color. Do not change background pixels or any other colors.</description>\\n<example>So a single pixel or a two-pixel L-shape becomes color A everywhere it appears, while a three- or more-pixel blob becomes color B everywhere it appears.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle ambiguous cases by using the component's bounding-box area (or the number of pixels) as the primary discriminator; if two components have similar area, use a deterministic tie-breaker like topmost then leftmost component. After recoloring, verify that background and other colors are preserved.</description>\\n<example>If two components both have a 2×2 bounding box, choose the one whose top row is smallest (and if tied, the leftmost) as the \\\"small\\\" class and recolor accordingly; then check that zeros and any other colors remain unchanged.</example>\\n</note5>\",\n \"<note1>\\n<description>First isolate the target color: identify which non-background color is being transformed. This is usually the color that appears as several disconnected blobs; focus on those connected components rather than background pixels.</description>\\n<example>Imagine a grid with zeros everywhere except a few red pixels forming three separate blobs. Treat those red pixels as the objects to analyze and ignore the black background for now. Knowing which color is the object simplifies the next steps.</example>\\n</note1>\\n\\n<note2>\\n<description>For each connected component, compute its bounding box and its centroid (the average of the component’s coordinates). The centroid gives a compact position that you can compare across components.</description>\\n<example>Take a component that occupies rows 3–6 and columns 7–9: its bounding box is that rectangle and its centroid is the average of those coordinates. Do this for every component so you have a single representative point for each object.</example>\\n</note2>\\n\\n<note3>\\n<description>Order the components by their centroid’s y-coordinate (top-to-bottom). Use that ordering to decide which component is “topmost” and which is “bottommost.”</description>\\n<example>If three centroids have y-values 2, 6 and 10, label them from top to bottom as A, B, C. This ordering is robust even if centroids share the same y-value (then break ties by x-coordinate).</example>\\n</note3>\\n\\n<note4>\\n<description>Classify components by their rank in that ordered list: the topmost component is one class, the bottommost component is another class, and any components that lie strictly between them form a third class. The number of classes is determined by how many distinct ranks exist.</description>\\n<example>With three components A (top), B (middle), C (bottom), you get three classes. With only two components, you would have two classes. With more components, the middle group will be the third class.</example>\\n</note4>\\n\\n<note5>\\n<description>Recolor each component according to its class: map one class to a single replacement color, another class to a different replacement color, and any middle group to a third color. Apply the recoloring to every pixel of that component and leave the background unchanged.</description>\\n<example>So if you have three classes, recolor all pixels of the topmost component with color X, all middle components with color Y, and all bottommost with color Z. This produces a consistent, ordered recoloring that preserves the shapes but separates them by position.</example>\\n</note5>\",\n \"<note1>\\n<description>First, identify the object color and treat each connected region of that color as an independent entity. This reduces the problem to comparing a small set of shapes rather than every pixel. Recognizing these objects lets you reason about their size and shape independently of background noise.</description>\\n<example>Imagine a grid with several blue islands on a black background. Mark each blue island by grouping adjacent blue pixels (up/down/left/right). You now have a small list of objects: three islands of sizes 3, 6 and 10, which you can compare and transform as separate units.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute each object's bounding box and use its area (number of pixels) as the primary distinguishing feature. The area is a robust, easy-to-compare numeric property that often determines the transformation. If areas differ, that numeric difference usually drives the change in the output.</description>\\n<example>For the three blue islands you found, their bounding-box areas might be 4, 6 and 10. Record these values so you can later decide how each island should be handled based on its size.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a simple partition of objects by size: typically the largest object is handled differently from the rest. Many tasks treat the largest object as an exception and apply a different rule to it while the remaining objects receive a single uniform treatment. This is effective when outputs show one object in a distinct color and the others in the same color.</description>\\n<example>Given the areas 4, 6 and 10, you might decide that the object with area 10 is special and should be recolored differently, while the objects with areas 4 and 6 are recolored the same way.</example>\\n</note3>\\n\\n<note4>\\n<description>When recoloring, preserve each object's geometry and position exactly: do not move, rotate, or reshape objects—only change their color. The transformation should be a uniform recoloring of whole objects, not a pixel-by-pixel edit. This keeps the spatial relationships intact while applying the color rule.</description>\\n<example>If a 3×2 block sits at the top-left in the input, it should remain a 3×2 block at the same coordinates in the output but in the new color you assigned to that object's size class.</example>\\n</note4>\\n\\n<note5>\\n<description>Be consistent across the grid: apply the same recoloring rule to every object of the same size class and use a single distinct color for the special-case object. Use a consistent tie-breaker (for example, pick the largest object as the exception) when two objects share the same size. This ensures the output is unambiguous and matches the pattern seen in the training examples.</description>\\n<example>If two objects both have area 6, recolor both the same way; if there is a single object of area 10, recolor it with the other distinct color. After applying these rules to all objects, verify the overall layout and color counts match the expected pattern.</example>\\n</note5>\",\n \"<note1>\\n<description>First separate foreground pixels from background and treat each connected group of the same non-background color as an object. Working at the object level (not individual pixels) makes it easier to see repeated shapes and their positions.</description>\\n<example>Imagine a grid where a single color appears as three separate patches. Record each patch as an object with its bounding box and pixel pattern. You can then compare these objects to one another instead of scanning every pixel.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute simple geometric descriptors for each object (area, bounding-box width and height, whether it touches the top or left edge, and whether it is symmetric). These descriptors are often the distinguishing features the task uses to classify objects.</description>\\n<example>For instance, if two objects have the same area but one has a bounding box that is wider than tall and the other is square, treat those as different cases. If an object touches the left edge, mark that as a distinguishing attribute.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a consistent rule that assigns a different output color to objects sharing the same descriptor set. In many puzzles the transformation is “group by descriptor, then repaint each group uniformly.”</description>\\n<example>If you find three objects that all have area 6 and touch the left edge, they should receive the same new color in the output; if another object has area 6 but does not touch the left edge, it should get a different color.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide how to break ties and assign colors so the mapping is deterministic. A common, robust tie-break is to use the object’s topmost row (or the leftmost column) as a secondary key when shapes are identical by other descriptors.</description>\\n<example>If two objects share area and orientation, pick the one that appears higher (smaller row index) as the representative and give it one output color; the other identical shape gets the other color. This avoids ambiguity while preserving the original ordering information.</example>\\n</note4>\\n\\n<note5>\\n<description>When you recolor, preserve each object’s exact shape and location—only change the color value—and leave the background untouched. Finally, verify that the recoloring is consistent across the training examples before applying it to the test grid.</description>\\n<example>After you decide a rule like “group by area+edge-touch and recolor groups,” apply that rule to every object in the input: repaint each object with its group color but do not move or resize it. Check that every object in the training outputs follows the same recoloring pattern.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the dominant color that forms the shapes you must transform. When one color appears far more often than background and other colors, treat that color as the object to be recolored in the output.</description>\\n<example>Imagine a grid where black is background and many red pixels form several shapes; red is the object to act on. If you see a single color filling most non-background cells, that color is the one you will consider for recoloring.</example>\\n</note1>\\n\\n<note2>\\n<description>Group connected pixels of the object color into separate components (use 4‑connectivity). Each connected component is an independent object to analyze and may receive a different treatment.</description>\\n<example>For example, a 3×3 red square and a separate 2×2 red square are two components even though they share the same color. Work with those two components separately rather than mixing them.</example>\\n</note2>\\n\\n<note3>\\n<description>For each component, compute its bounding box (min/max row and column) and the component’s width and height. These measures give a concise description of the object’s shape and orientation.</description>\\n<example>If a component occupies rows 2–4 and columns 5–6 its bounding box is height=3 and width=2; another component that spans rows 7–9 and columns 2–3 has height=3 and width=2, but different coordinates.</example>\\n</note3>\\n\\n<note4>\\n<description>Compare bounding boxes across components: the key distinguishing property is whether a component’s bounding box is square (width == height). Components with equal width and height are treated differently from non-square components.</description>\\n<example>Two components both with height=2 and width=2 are square components; a component with height=3 and width=2 is not square. Use this equality test to classify components rather than relying on size alone.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply a single consistent recoloring rule to all components: recolor every square component with one new color and recolor every non-square component with a second new color; leave background pixels unchanged. This preserves shapes while making the classification visually clear.</description>\\n<example>Given several red components, recolor every red component whose bounding box is a perfect square to the same blue fill, and recolor every other red component to a different green fill. The result is the same shape in the output but with two distinct colors marking square vs. non-square components.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by isolating the non-background objects: collect all maximal connected components of the colored pixels and treat each component as an independent object. This reduces the problem to comparing a small set of shapes instead of many scattered pixels. Work with the shapes' outlines or bounding boxes so you can reason about size and orientation.</description>\\n<example>Imagine a grid with several separate clusters of the same color. For each cluster, mark its bounding box and note whether it is a compact square, a long bar, or an irregular blob. You now have a small set of objects to compare rather than many individual pixels.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the objects by a geometric property such as area (pixel count) or bounding-box area, and count how many objects share that property. The transformation often distinguishes between \\\"most common\\\" and \\\"rare\\\" objects by this measure. Use the training pairs to infer which property is being used.</description>\\n<example>If you find three 2×2 squares and several other shapes, the 2×2 squares are the \\\"most frequent\\\" objects and are treated differently from the rarer shapes. Counting occurrences helps you identify which shapes to recolor separately.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide which color to apply to the common objects and which color to apply to the rare objects. The output typically uses one distinct color for all objects of the same class (common) and another distinct color for the remaining objects (rare). Treat the background as unchanged.</description>\\n<example>For instance, if the common objects are recolored uniformly to color A and the rare ones to color B, every object of the same class in the test grid should receive the same color. This preserves the original shapes while making the class membership explicit.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the recoloring globally: recolor every pixel belonging to the identified common-class objects and every pixel belonging to the rare-class objects, regardless of their original color. Do not change background pixels. This keeps the spatial arrangement intact while highlighting the class difference.</description>\\n<example>Given a grid with two classes, change every pixel of the first class to the common color and every pixel of the second class to the rare color. The shapes' positions and shapes remain identical, only their colors are reassigned according to class.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple heuristics to avoid common mistakes: ensure you treat each connected component independently (not the whole grid), prefer the most frequent connected component as the target class, and check that the rare class is not empty. If there is a tie, prefer the class that appears as the largest connected component or the one with the most pixels.</description>\\n<example>If two classes are equally frequent, choose the one with the larger bounding box or the greater pixel count as the \\\"common\\\" class; then recolor the other class uniformly. This avoids ambiguous decisions when multiple colors or shapes could be candidates.</example>\\n</note5>\",\n \"<note1>\\n<description>Separate objects by grouping same-colored pixels into connected components (4‑connected adjacency). Treat each group as a single object so you can reason about whole shapes instead of individual pixels.</description>\\n<example>Imagine a grid with several red clusters. Mark every red pixel and connect horizontally or vertically adjacent red pixels to form components; each distinct cluster becomes one object you will analyze.</example>\\n</note1>\\n\\n<note2>\\n<description>For each object, compute its bounding box (min/max row and column) and the box’s height and width. The bounding box gives a compact way to compare the shapes and to identify the object that is different.</description>\\n<example>If one object covers rows 2–4 and cols 5–6, its bounding box is height 3 and width 2. Repeat for every object so you can compare their sizes and shapes.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for an object whose bounding box is square (height equals width). That square bounding box is the distinguishing feature in these tasks and is usually the one to treat differently from the others.</description>\\n<example>Among several rectangles you might find one whose bounding box is 2×2, 3×3, or 4×4. That square box stands out and should be considered the special object.</example>\\n</note3>\\n\\n<note4>\\n<description>Recolor the identified square object with a distinct color while leaving all other objects in their original color. This makes the special shape visually and logically separate from the rest.</description>\\n<example>After finding the square object, change every pixel of that object to a new color so it is clearly marked, while all other colored pixels remain unchanged.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful not to confuse filled squares with other rectangular shapes: use the bounding-box test (height == width) and check that the object is not simply a 1×1 pixel. Avoid changing background zeros or unrelated colors.</description>\\n<example>A 2×2 filled square has height 2 and width 2, while a 2×4 rectangle has height 2 and width 4—those two are not the same. Also ensure you recolor only the object’s pixels, not the surrounding background.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the target color by frequency: the transformation acts on the color that appears most often in the grid. This is effective because the examples always change the majority-colored pixels while leaving other colors or background alone.</description>\\n<example>Imagine a 6×6 grid where color A appears 18 times and all other colors appear fewer times; A is the target for the transformation. Counting occurrences across the whole grid quickly isolates A as the candidate to be recolored.</example>\\n</note1>\\n\\n<note2>\\n<description>Check the output for a single replacement color: the majority color is uniformly replaced by one new color across all examples, while other colors remain unchanged. The rule is a global recoloring of that color rather than a geometric operation.</description>\\n<example>For example, if color A appears in many disconnected blobs in the input, the output shows all those blobs in the same new color B, with every other color preserved exactly as in the input.</example>\\n</note2>\\n\\n<note3>\\n<description>Verify that shapes and positions are preserved: the transformation only changes color values, not pixel coordinates or object geometry. So you can treat each connected component of the target color as an intact object before recoloring.</description>\\n<example>If a blob of A occupies rows 2–4 and columns 5–7 in the input, it will occupy the same rows and columns in the output but with the new color B; the shape and location are identical.</example>\\n</note3>\\n\\n<note4>\\n<description>Confirm the background and minority colors are left untouched: only the most frequent color is targeted. This tells you not to alter zeros or any other colors that appear in the grid.</description>\\n<example>For instance, if the background is black (0) and other colors are C and D, those pixels should remain as 0, C and D respectively in the output while the dominant color A is replaced.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple heuristics to avoid pitfalls: always use the global count (not local counts inside a single object), and if multiple colors tie for most frequent, prefer the color that appears across multiple disconnected objects. These checks help resolve ambiguous cases.</description>\\n<example>If two colors each occur 12 times but one spans several separate blobs while the other is a single isolated pixel, the spanning color is the one to recolor. Also, double-check that the replacement is applied to every instance of the chosen color, not just a subset.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by isolating the non-background pixels and grouping them into connected components. Treat each contiguous patch of the same color as a separate object so you can reason about shape, size and position independently.</description>\\n<example>Imagine a grid with many scattered blue pixels: first mark all blue cells, then group them by adjacency into distinct blobs. Each blob is a candidate object to analyze further (count pixels, compute bounding box, look at orientation).</example>\\n</note1>\\n\\n<note2>\\n<description>Compare component sizes: many ARC tasks separate objects by size (e.g., small vs large). Compute the number of pixels for each component and use that count as the primary criterion for distinguishing objects.</description>\\n<example>For example, if you find several blobs and one blob contains exactly 3 pixels while others are 4 or more, that single 3-pixel blob is a natural candidate for a different treatment than the larger blobs.</example>\\n</note2>\\n\\n<note3>\\n<description>Once you identify a target object by size, change its color while leaving every other cell unchanged. The transformation is a recoloring operation: keep geometry and coordinates the same, only change the color label.</description>\\n<example>Take a 3-pixel blob you identified; replace each of its cells with the new color (call it color A) but do not move or reshape it. All other pixels remain exactly as in the input.</example>\\n</note3>\\n\\n<note4>\\n<description>Choose a single replacement color that is distinct from the background and any other colors present in the input so the change is unambiguous. Use a color not used elsewhere to avoid confusion with other objects.</description>\\n<example>If the input uses colors 0 (background) and 2, pick a third color (for example, color 6) to recolor the target object; this makes it visually and logically separate from the original shapes.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple tie-breakers when multiple small objects exist: prefer a uniquely sized object, or break ties by proximity to the grid center. After applying the rule, verify that the transformed grid matches the training examples' pattern of recoloring only the intended objects.</description>\\n<example>If two blobs both have the same small size, pick the one whose bounding box is closer to the grid center or the one that is uniquely small in the examples; then check that only that blob's color changed and all other pixels stayed the same.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the single non-background color that forms many separate objects. This color is the only one that changes between input and output, so isolating it reduces the problem to a small set of objects to analyze.</description>\\n<example>Imagine a grid with many tiny red shapes on a black background. Count the cells of red: if red is the only color with a nonzero count, you can focus only on the red objects and ignore other colors for the transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Group every connected component of the target color into objects (use orthogonal adjacency). Treat each such connected group as a single item to be compared across examples.</description>\\n<example>For instance, if you see three separate red blobs, treat each blob as one object. Label them by their bounding boxes (min/max row and column) and record their sizes and positions rather than individual pixels.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a consistent size-based rule across the examples: one object class is recolored uniformly and the other class is recolored uniformly, and the rule is based on object size. Find which size class is treated the same in every training pair.</description>\\n<example>Suppose the training pairs show that every object of size 6 or larger becomes color A while every smaller object becomes color B. That indicates a size-based classification rather than a positional or shape-based rule.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide how the two output colors are assigned to the two size classes: check whether the larger class is always given one specific color and the smaller class the other. This gives you a deterministic mapping to apply to the test grid.</description>\\n<example>If in every example the biggest objects are recolored with color A and the smaller ones with color B, then when you recolor objects in the test grid, give each object the color corresponding to its class (big → A, small → B).</example>\\n</note4>\\n\\n<note5>\\n<description>After recoloring, verify the result: the number of objects and their shapes should match the input, only their colors changed; the background should remain unchanged. This confirms you applied the correct classification and mapping.</description>\\n<example>As a final check, count how many objects of each size you have in the test input and make sure you recolored exactly that many objects to the appropriate color classes. If counts or shapes differ, re-check your object detection or the size threshold you inferred from the examples.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by listing every connected component of the target color (here, the non-background pixels). Treat each contiguous group as a separate object and record its pixel count and bounding box — these are the basic units the transformation will operate on.</description>\\n<example>For instance, if you see three separate blobs of the same color, note their sizes (e.g., 2, 3 and 5 pixels) and their bounding boxes. These counts and positions are what you will compare across the examples to infer the rule.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a simple global recoloring: many tasks replace all occurrences of the target color with a single new color. If so, the shape and location of objects remain identical while only their color changes.</description>\\n<example>Imagine a grid with several blue islands; if every blue island becomes green in the output, that indicates a uniform color substitution rather than moving or reshaping the islands.</example>\\n</note2>\\n\\n<note3>\\n<description>Search for a secondary, selective recoloring that depends on object size. Often the smallest object is treated differently from the others — check whether the smallest component is recolored to a distinct color while larger components keep the main color.</description>\\n<example>Suppose three islands have sizes 2, 4 and 7; if the output shows one island recolored to a different color and the other two islands are the same color, that points to a size-based secondary rule (the smallest island is singled out).</example>\\n</note3>\\n\\n<note4>\\n<description>Be explicit about how you measure “smallest”: compare connected components by the number of pixels they contain, not by area in a bounding-box sense. Use orthogonal (4‑connected) adjacency unless the examples indicate diagonal connectivity.</description>\\n<example>If two blobs touch diagonally but are separated by a background cell, they are two separate components and should be counted separately. The correct rule will pick the component with the fewest pixels, not the one with the smallest bounding-box width.</example>\\n</note4>\\n\\n<note5>\\n<description>Validate your hypothesis by applying the two-step recoloring to each training example: first recolor all target-color pixels to the main replacement color, then recolor the smallest component(s) to the secondary color. If this reproduces every training output, the rule is consistent.</description>\\n<example>Try the rule on a simple grid: recolor every blob to color A, then recolor the smallest blob to color B. If that matches the example outputs, you can confidently use the same two-step approach on the test grid.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the target color by frequency: the color that appears many times in the input is the one being transformed. This is effective because the transformation is applied to a single, dominant color while other colors remain unchanged.</description>\\n<example>Imagine a grid where one color fills most non-background pixels and another color appears only a few times. The first step is to identify that dominant color — it is the one you will recolor in the output.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare shapes, not just counts: treat each contiguous region of the target color as a separate object and compare their geometry (area, bounding box, number of pixels, and whether they are compact or have holes). The rule often picks one geometric class (for example, the largest or most compact objects).</description>\\n<example>For instance, if two regions both have the same pixel count but one is a solid filled block and the other has a missing pixel, the solid block is a different geometric shape and may be treated differently from the hole-containing object.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a simple, consistent recoloring rule: the dominant color is usually replaced by a single new color in the output, while the other color is recolored to a second, distinct color. The mapping is global (all occurrences of the dominant color become one new color) and the other color becomes a different new color.</description>\\n<example>Think of a transformation that changes every occurrence of the dominant color to one new color and every occurrence of the other color to another new color; this produces two clear, uniform recolor classes across the grid.</example>\\n</note3>\\n\\n<note4>\\n<description>Use symmetry and positional checks to confirm the selection: sometimes the chosen object is the one that is symmetric, centrally located, or has a particular orientation (for example, an axis-aligned square or a symmetric shape). If multiple objects are symmetric, prefer the largest or most central one.</description>\\n<example>If several objects are present and one stands out because it is perfectly square and centered, that object is a strong candidate to be treated differently from the others in the output.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the rule consistently across the whole grid and verify by checking that all occurrences of the selected class receive the same new color and that every occurrence of the other color receives the other new color. Watch for edge cases like very small objects that are ignored by the rule.</description>\\n<example>After choosing which class to recolor, recolor every pixel of that class the same way and every pixel of the other color the other way; the correct rule will produce two uniform recolor classes and leave background pixels unchanged.</example>\\n</note5>\",\n \"<note1>\\n<description>Focus first on the foreground color: many ARC tasks change only the non-background pixels while leaving background cells unchanged. This means you can ignore zeros and treat every non-zero cell as part of the same object set to analyze.</description>\\n<example>Imagine a 6×6 grid with zeros everywhere except one color occupying several connected pixels. If the output keeps zeros in place and only alters those colored pixels, you should first isolate all colored cells and ignore the black background when searching for a pattern.</example>\\n</note1>\\n\\n<note2>\\n<description>Group the foreground pixels into connected components (orthogonal adjacency). Treat each contiguous blob as an independent object and record its basic properties: number of cells, bounding box, centroid, and whether it is an L-shape or a compact square.</description>\\n<example>For example, a 3×3 block is a compact square and should be treated as one object, while three pixels touching in an L shape are a different object. Label each object so you can compare them consistently across the grid.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare the objects by simple numeric invariants: area (pixel count), bounding-box side length, and whether the bounding box is filled. These invariants often reveal which objects are “special” (e.g., the largest or uniquely shaped).</description>\\n<example>Suppose you find three objects with sizes 4, 6 and 10 pixels; the 10-pixel object is the largest and will usually be singled out by a transformation. If one object’s bounding box is filled while others are not, that filled box is also a strong indicator.</example>\\n</note3>\\n\\n<note4>\\n<description>Use the training examples to infer the mapping: one distinct object type is recolored uniformly while the rest keep their original color. The mapping is typically applied consistently across the whole grid, so once you identify which object class is special, recolor every instance of that class the same way.</description>\\n<example>If two identical L-shaped objects in the training inputs are shown in a different color while all other objects remain the same, then the rule is “recolor all L-shapes” and leave other shapes untouched. Apply that same rule to the test grid.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful with tie-breakers and orientation: when two objects share the same size or shape, check secondary features (position, orientation, or whether a bounding box is filled) to decide which to recolor. Also verify that the background (zeros) stays unchanged.</description>\\n<example>If two components both have 6 pixels but one is a filled 2×3 rectangle and the other is an L-shape, prefer the filled rectangle as the special object. Always confirm your choice against the examples before recoloring.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the primary object by grouping all non-background pixels and computing the minimal bounding rectangle that contains them. This rectangle is the natural unit to compare across examples and isolates the pattern to inspect.</description>\\n<example>Imagine a grid with a single colored blob: its bounding rectangle is the smallest rectangle that contains every pixel of that blob. Treat that rectangle as the object to analyze rather than individual scattered pixels.</example>\\n</note1>\\n\\n<note2>\\n<description>Within that bounding rectangle, count the number of colored pixels and the number of rows that contain at least one colored pixel (the vertical span). These two numbers (pixel count and row span) are the key quantitative features to compare across examples.</description>\\n<example>If the bounding box is 3 rows tall and contains 4 colored pixels, record (height=3, count=4). If the box is 2 rows tall and contains 3 colored pixels, record (height=2, count=3). Use these pairs to find a consistent mapping.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a simple one-to-one mapping from the object's feature values to a color label: the same feature value always maps to the same output color. In many tasks the mapping is determined by comparing pairs of objects (e.g., \\\"which feature distinguishes object A from object B\\\") rather than by a formula like pixel count squared.</description>\\n<example>Suppose you find two objects with the same height but different row spans, and the examples show they receive two different colors. That indicates a mapping based on the row-span value rather than the absolute pixel count.</example>\\n</note3>\\n\\n<note4>\\n<description>When recoloring the test grid, keep each object's pixels in place and change only their color according to the mapping you inferred. Do not move, resize, or remove objects—preserve their shapes and positions.</description>\\n<example>If an object's bounding rectangle matches the training object's rectangle (same height and row-span), recolor all its pixels to the corresponding color you identified. If it does not match, check whether it matches another training object or whether a different feature (such as whether a pixel sits on an edge) determines the label.</example>\\n</note4>\\n\\n<note5>\\n<description>Use quick sanity checks: compare training pairs to confirm the mapping is consistent, and verify that identical rectangles in different examples share the same color. If you encounter a rectangle that doesn't match any training pair, re-evaluate whether you misidentified the object or whether another feature (edge position, aspect ratio) is the deciding factor.</description>\\n<example>If two different training rectangles both have height 2 and you see they are both recolored the same way, that supports a \\\"height → color\\\" rule. If a new rectangle with height 2 still requires a different color, look for a secondary feature (for example, whether the top row of the bounding box is fully filled) that breaks the tie.</example>\\n</note5>\",\n \"<note1>\\n<description>First, identify the objects: treat every contiguous group of non-background pixels as an object and record its pixel count (size). This reduces the problem from many pixels to a few objects whose sizes determine the transformation.</description>\\n<example>Imagine a grid with several blobs of the same color. For each blob count how many colored pixels it contains (e.g., sizes 5, 6, 7). Those numeric sizes are the quantities you will compare across examples.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the sizes across examples to find a consistent ordering. Often the transformation is driven by rank: the object with the largest size is treated differently from the other objects, which are treated the same way.</description>\\n<example>Suppose three objects have sizes 4, 5 and 6. If the output changes only the object of size 6 while the others are changed similarly, then “largest-by-size” is the key property to use.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide how colors are reassigned: typically all non-background objects receive one new color and the largest object receives a second new color. The background (zeros) stays unchanged.</description>\\n<example>With two replacement colors available, you might see every object painted with color A except one object painted with color B. That tells you the rule is “one uniform recolor for all objects, one special recolor for the largest object.”</example>\\n</note3>\\n\\n<note4>\\n<description>Choose the distinguishing property by checking invariants: compare size, bounding-box area, perimeter, and connectedness. The correct property is the one that is consistent across examples (e.g., largest size is preserved while other objects are grouped together).</description>\\n<example>If two objects have the same bounding-box area but different numbers of pixels, and only the one with more pixels is singled out in the outputs, then pixel count (size) is the distinguishing invariant rather than bounding-box area.</example>\\n</note4>\\n\\n<note5>\\n<description>Before finalizing, verify the rule on every training pair and watch for pitfalls: do not confuse background with objects, do not treat separate disconnected components of the same color as one object, and ensure the chosen invariant is unique across examples.</description>\\n<example>After you pick “largest-by-pixel-count” as the invariant, apply the recoloring to each training input and confirm the outputs match exactly. If any training example fails, try the next invariant (e.g., bounding-box area or perimeter) until one consistently explains all examples.</example>\\n</note5>\",\n \"<note1>\\n<description>First isolate the objects: treat every contiguous region of non‑zero pixels as a separate object and record its bounding box and footprint. This reduces the problem from many pixels to a small set of shapes you can compare.</description>\\n<example>Imagine a grid with three colored blobs. Draw the smallest rectangle around each blob and write down how many pixels each blob has and what those pixels look like (for example, a filled square vs a 3×3 block with a missing corner). These summaries let you reason about shapes without looking at every cell.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a single color that is used to mark one class of objects while the rest are recolored to a different color. The rule usually applies consistently across the grid: all objects of that class are changed together, and all others are changed to the same other color.</description>\\n<example>For instance, if you see that two identical shapes in the input both become the same new color in the output, while every other object becomes a third color, that indicates a two‑class recoloring: one class is marked by a distinct color, the rest share another color.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide the selection criterion by comparing object properties: area, bounding box dimensions, symmetry, or a simple footprint count. Many tasks pick the class by a numeric property (for example, “the largest area” or “the one with a particular aspect ratio”).</description>\\n<example>Suppose the grid contains three blobs and their areas are 12, 18 and 4. If the output keeps the 18‑area blob in its special color and recolors the other two, then the selection rule is “largest area.” Try the same numeric test on the training pairs to confirm which property is used.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the recoloring globally and uniformly: once you know which class to mark and which color to use for the rest, recolor every pixel of each object according to that class. The spatial arrangement and internal pattern of each object should remain unchanged except for color.</description>\\n<example>If you determine that all 3×3 filled squares should be recolored to the marker color and all other objects to the secondary color, then every 3×3 square in the test grid should receive the marker color and every other object the secondary color—no rotation, reflection, or relocation should occur.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for edge cases: disconnected pieces of the same color are usually treated as one object, and identical shapes in different places should be handled consistently. If more than one property seems plausible, prefer the property that is consistent across all training examples.</description>\\n<example>If a color appears as two separate blobs, treat them as two objects and recolor each according to its class. If two objects share the same size and shape but only one is recolored in the examples, recheck whether the rule uses a secondary property (position, orientation, or a numeric tie‑break) rather than just size.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 2, 0, 0, 2, 0], [0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0], [0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0], [2, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 6, 6, 0, 0, 0, 0, 6, 6, 0, 6, 0, 0, 6, 0], [0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0], [0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0], [6, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [6, 6, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0], [6, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0], [6, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0], [6, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0]]}, {\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [2, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 2, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 2, 2, 2, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 6, 6, 0, 0, 0], [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0], [4, 4, 4, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 6, 0, 0, 6], [0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 6, 6, 6, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6]]}, {\"input\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0], [2, 2, 0, 2, 2, 2, 2, 2, 0, 0, 0, 2, 2, 0, 0, 0], [2, 0, 0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0], [0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 2, 2, 2, 0, 0, 0], [0, 0, 0, 0, 2, 2, 2, 0, 0, 0, 2, 2, 2, 0, 0, 0], [0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0], [0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 6, 6, 0, 0, 0], [4, 4, 0, 6, 6, 6, 6, 6, 0, 0, 0, 6, 6, 0, 0, 0], [4, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 4, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0], [0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 6, 0, 6, 0, 0, 0]]}]"},"test":{"kind":"string","value":"[{\"input\": [[0, 0, 2, 2, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 2, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2], [0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 2, 2, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 2, 2, 0, 0, 2, 2, 2, 0], [0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0]], \"output\": [[0, 0, 6, 6, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 6, 0, 0, 4, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0], [6, 6, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 0], [6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 6, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6], [0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [0, 6, 6, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [6, 6, 0, 0, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0], [6, 6, 0, 0, 0, 0, 6, 6, 0, 0, 4, 4, 4, 0], [0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 0]]}]"},"source":{"kind":"string","value":"barc_heavy"},"prompt":{"kind":"string","value":"You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectangular matrix of integers between 0 and 9 (inclusive). Each number corresponds to a color. 0 is black. Your task is to determine the transformation rule from examples and find out the answer, involving determining the size of the output grid for the test and correctly filling each cell of the grid with the appropriate color or number. The transformation only needs to be unambiguous and applicable to the example inputs and the test input. It doesn't need to work for all possible inputs. Observe the examples carefully, imagine the grid visually, and try to find the pattern. Please output your answer within a code block (```), formatted as a grid of numbers. \n\n# Examples\n## Example 1\nInput:\n```\n0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 2 2 0 0 0 0 2 2 0 2 0 0 2 0\n0 0 2 2 2 0 0 0 0 0 0 0 2 2 2 2 0\n0 0 2 2 2 0 0 0 0 0 0 0 2 2 2 2 0\n2 0 0 2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 0 2 2 2 0 0 0 0 0 0 0 0\n2 0 0 0 0 0 0 2 2 2 0 0 0 0 0 0 0\n2 0 0 0 0 0 0 0 2 2 0 0 0 0 0 0 0\n2 0 0 0 0 0 0 0 0 2 0 0 0 0 0 2 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 2 2\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 6 6 0 0 0 0 6 6 0 6 0 0 6 0\n0 0 6 6 6 0 0 0 0 0 0 0 6 6 6 6 0\n0 0 6 6 6 0 0 0 0 0 0 0 6 6 6 6 0\n6 0 0 6 6 0 0 0 0 0 0 0 0 0 0 0 0\n6 6 0 0 0 0 6 6 6 0 0 0 0 0 0 0 0\n6 0 0 0 0 0 0 6 6 6 0 0 0 0 0 0 0\n6 0 0 0 0 0 0 0 6 6 0 0 0 0 0 0 0\n6 0 0 0 0 0 0 0 0 6 0 0 0 0 0 4 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 4 4\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 4 0\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 2 0 0 2 0 0 0 0 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 2 0 0 2 2 0 0 0\n2 0 0 0 0 0 0 0 0 0 2 2 0 0 0\n2 2 2 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 0 2 2 0 0 2 0 0 2\n0 0 0 0 0 0 0 2 2 0 0 2 2 2 2\n0 0 0 0 0 0 0 0 0 0 0 2 2 2 2\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 6 0 0 6 0 0 0 0 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 6 0 0 6 6 0 0 0\n4 0 0 0 0 0 0 0 0 0 6 6 0 0 0\n4 4 4 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 0 6 6 0 0 6 0 0 6\n0 0 0 0 0 0 0 6 6 0 0 6 6 6 6\n0 0 0 0 0 0 0 0 0 0 0 6 6 6 6\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0 2 2 0 0 0\n0 0 0 0 0 2 0 0 0 0 0 2 2 0 0 0\n0 0 0 0 2 2 2 0 0 0 0 2 2 0 0 0\n2 2 0 2 2 2 2 2 0 0 0 2 2 0 0 0\n2 0 0 0 2 2 2 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 2 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 2 2 2 2 2\n0 0 0 0 0 0 0 0 0 0 0 0 2 2 2 0\n0 0 0 0 2 2 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 2 2 2 0 0 0 2 2 2 0 0 0\n0 0 0 0 2 2 2 0 0 0 2 2 2 0 0 0\n0 0 0 0 2 2 0 0 0 0 2 0 2 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0 6 6 0 0 0\n0 0 0 0 0 6 0 0 0 0 0 6 6 0 0 0\n0 0 0 0 6 6 6 0 0 0 0 6 6 0 0 0\n4 4 0 6 6 6 6 6 0 0 0 6 6 0 0 0\n4 0 0 0 6 6 6 0 0 0 0 0 0 0 0 0\n4 4 0 0 0 6 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 6 6 6 6 6\n0 0 0 0 0 0 0 0 0 0 0 0 6 6 6 0\n0 0 0 0 6 6 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 6 6 6 0 0 0 6 6 6 0 0 0\n0 0 0 0 6 6 6 0 0 0 6 6 6 0 0 0\n0 0 0 0 6 6 0 0 0 0 6 0 6 0 0 0\n```\n\n# Test Problem:\n```\n0 0 2 2 0 2 2 0 0 0 0 0 0 0\n0 0 2 2 2 2 2 0 0 2 2 0 0 0\n0 0 0 0 0 0 0 0 0 2 2 0 0 0\n2 2 0 0 0 0 0 0 0 2 2 0 0 0\n2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 0 0 0 0 0 0 0 0 0\n2 2 0 0 0 0 0 0 0 0 2 0 2 0\n0 0 0 0 0 0 0 0 0 2 2 2 2 2\n0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 0 0 0 0 0 2 2 0 0 0 0 0 0\n0 2 2 0 0 0 2 2 0 0 0 0 0 0\n2 2 0 0 0 0 2 2 0 0 0 0 0 0\n2 2 0 0 0 0 2 2 0 0 2 2 2 0\n0 2 2 0 0 0 0 0 0 0 2 2 2 0\n```"},"answer":{"kind":"string","value":"```\n0 0 6 6 0 6 6 0 0 0 0 0 0 0\n0 0 6 6 6 6 6 0 0 4 4 0 0 0\n0 0 0 0 0 0 0 0 0 4 4 0 0 0\n6 6 0 0 0 0 0 0 0 4 4 0 0 0\n6 6 0 0 0 0 0 0 0 0 0 0 0 0\n6 6 0 0 0 0 0 0 0 0 0 0 0 0\n6 6 0 0 0 0 0 0 0 0 6 0 6 0\n0 0 0 0 0 0 0 0 0 6 6 6 6 6\n0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 0 0 0 0 0 6 6 0 0 0 0 0 0\n0 6 6 0 0 0 6 6 0 0 0 0 0 0\n6 6 0 0 0 0 6 6 0 0 0 0 0 0\n6 6 0 0 0 0 6 6 0 0 4 4 4 0\n0 6 6 0 0 0 0 0 0 0 4 4 4 0\n```"},"num_tokens":{"kind":"number","value":3030,"string":"3,030"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":0,"numItemsPerPage":100,"numTotalItems":1396,"offset":0,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MDcyMjk4OSwic3ViIjoiL2RhdGFzZXRzL2FzaW5naDE1L2FyYy1iYXJjLXByb2Nlc3NlZC1kaXJlY3QtbWF4NGstc2Z0YWJzLTVvZjgiLCJleHAiOjE3ODA3MjY1ODksImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.nhCenehEk1LXTpAxIijaqrLzocTgOvB0fqHgD5lIq7WkenNBWSIQJTsvdJ2xqc9czCFJQE9X7UKbkfBbKQW6DQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"test","numRows":15,"numBytesParquet":596066},{"config":"default","split":"train","numRows":1396,"numBytesParquet":30041975}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
abstraction_prompt stringlengths 4.7k 8.5k | abstraction_prompt_length int64 1.04k 4.8k | generated_abstractions listlengths 16 16 | train stringlengths 182 5.88k | test stringlengths 46 5.19k | source stringclasses 4
values | prompt stringlengths 1.2k 5k | answer stringlengths 9 1.69k | num_tokens int64 339 4.1k |
|---|---|---|---|---|---|---|---|---|
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,475 | [
"<note1>\n<description>Look for a horizontal divider: a row made entirely of one color that appears exactly once in the input. That row usually separates two meaningful subgrids and tells you which region to extract. Recognizing this divider reduces the problem to comparing two smaller blocks.</description>\n<examp... | [{"input": [[1, 1, 0, 0], [0, 1, 0, 1], [0, 1, 0, 0], [1, 0, 1, 0], [4, 4, 4, 4], [2, 2, 2, 2], [0, 0, 2, 2], [2, 2, 0, 0], [0, 0, 2, 2]], "output": [[3, 3, 3, 3], [0, 3, 3, 3], [3, 3, 0, 0], [3, 0, 3, 3]]}, {"input": [[1, 1, 1, 0], [0, 1, 0, 1], [0, 0, 1, 1], [1, 1, 0, 1], [4, 4, 4, 4], [0, 0, 0, 2], [0, 0, 0, 2], [2,... | [{"input": [[1, 0, 1, 0], [1, 0, 1, 0], [0, 1, 0, 0], [1, 0, 1, 0], [4, 4, 4, 4], [2, 2, 0, 0], [0, 0, 2, 0], [0, 2, 0, 2], [2, 2, 2, 0]], "output": [[3, 3, 3, 0], [3, 0, 3, 0], [0, 3, 0, 3], [3, 3, 3, 0]]}] | arc 1 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 3 3 0
3 0 3 0
0 3 0 3
3 3 3 0
``` | 771 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,916 | [
"<note1>\n<description>Find the background by frequency: the color that fills most cells is usually the background and should not be part of the final pattern. Removing it simplifies the scene and reveals the true objects.</description>\n<example>Imagine a 10×10 grid where 90 cells are color A and a few cells are c... | [{"input": [[6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, ... | [{"input": [[5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 1, 1, 5, 5, 5, 5], [5, 5, 5, 5, 5, 4, 5, 5, 3, 5, 5, 5], [5, 5, 5, 5, 5, 4, 5, 5, 3, 5, 5, 5], [5, 5, 5, 5, 5, 4, 5, 5, 3, 5, 5, 5], [5, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 1 1 5
4 5 9 3
4 4 5 3
4 9 9 3
5 7 7 5
``` | 3,212 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,158 | [
"<note1>\n<description>Separate background from foreground by frequency: the color that fills most cells is usually the background and can be ignored when looking for the rule. Focusing on the minority colors reduces noise and makes the transformation easier to spot. This is effective because many ARC tasks only ch... | [{"input": [[9, 9, 9, 2, 9, 6, 9, 9, 3, 2], [9, 9, 9, 9, 9, 2, 9, 6, 9, 9], [9, 6, 6, 9, 9, 6, 9, 6, 6, 3], [9, 9, 3, 9, 9, 9, 9, 9, 9, 6], [9, 6, 9, 9, 3, 9, 9, 9, 9, 9], [9, 3, 9, 2, 9, 9, 9, 9, 9, 2], [9, 3, 9, 9, 9, 9, 3, 9, 9, 9], [6, 2, 9, 9, 9, 6, 9, 9, 9, 9], [9, 3, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 2, 3, 9, 6, 9... | [{"input": [[1, 1, 3, 2, 1, 1, 2, 1, 1, 1], [2, 1, 6, 1, 1, 1, 1, 1, 1, 1], [1, 3, 1, 1, 3, 1, 1, 1, 2, 1], [1, 1, 2, 1, 1, 1, 1, 1, 3, 1], [6, 1, 1, 6, 1, 1, 1, 1, 1, 1], [2, 1, 1, 3, 1, 1, 1, 1, 2, 1], [1, 1, 1, 3, 1, 1, 1, 6, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 6, 1, 6, 1, 1, 2, 3], [1, 1, 1, 1, 1, 1, 3... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
1 1 8 1 1 1 2 1 1 1
2 1 6 1 1 1 1 1 1 1
1 3 1 1 3 1 1 1 1 1
1 1 2 1 1 1 1 1 8 1
6 1 1 6 1 1 1 1 1 1
2 1 1 3 1 1 1 1 2 1
1 1 1 3 1 1 1 6 1 1
1 1 1 1 1 1 1 1 1 1
1 1 1 6 1 6 1 1 1 8
1 1 1 1 1 1 3 1 8 1
6 1 1 6 6 2 1 6 1 3
1 2 1 1 1 1 1 1 8 1
1 1 6 1 1 1 2 2 1 1
6 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 2 1
``` | 3,454 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,870 | [
"<note1>\n<description>Look for contiguous vertical blocks that repeat across the grid: when the same column-sequence of colors appears in several adjacent rows, those rows are likely part of the same repeated tile. This is effective when the grid is built by stacking identical vertical segments.</description>\n<ex... | [{"input": [[7, 7, 7, 4, 7, 7, 4, 7, 7, 7, 4, 7, 7, 4, 7, 7, 7, 4, 7, 7, 4], [4, 7, 4, 4, 4, 7, 4, 4, 7, 4, 4, 4, 7, 4, 4, 7, 4, 4, 4, 7, 4], [7, 7, 4, 4, 7, 4, 7, 7, 7, 4, 4, 7, 4, 7, 7, 7, 4, 4, 7, 4, 7], [4, 7, 7, 4, 4, 7, 7, 4, 7, 7, 4, 4, 7, 7, 4, 7, 7, 4, 4, 7, 7], [4, 7, 7, 4, 7, 4, 7, 4, 7, 7, 4, 7, 4, 7, 4, 7,... | [{"input": [[5, 0, 0, 0, 0, 0, 5, 0, 7, 5, 0, 0, 0, 0, 0, 5, 0, 7, 5, 0, 0, 0, 0, 0, 5, 0, 7], [5, 5, 0, 0, 0, 0, 0, 0, 8, 5, 5, 0, 0, 0, 0, 0, 0, 8, 5, 5, 0, 0, 0, 0, 0, 0, 8], [0, 5, 0, 5, 0, 0, 1, 7, 0, 0, 5, 0, 5, 0, 0, 1, 7, 0, 0, 5, 0, 5, 0, 0, 1, 7, 0], [0, 5, 7, 0, 5, 0, 0, 0, 0, 0, 5, 7, 0, 5, 0, 0, 0, 0, 0, 5... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 0 0 0 0 0 5 0 7
5 5 0 0 0 0 0 0 8
0 5 0 5 0 0 1 7 0
0 5 7 0 5 0 0 0 0
0 5 0 1 1 0 0 0 0
1 0 5 8 1 0 8 0 5
``` | 1,166 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,150 | [
"<note1>\n<description>Look for full rows or full columns made of a single color — these are strong structural anchors. Treat them as separators that split the grid into independent horizontal bands (stripes) and/or vertical bands (tiles).</description>\n<example>Imagine a grid where one column is entirely color X ... | [{"input": [[7, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 9, 7, 8, 7, 7, 7, 7, 7, 7], [7, 7, 7, 9, 9, 7, 8, 7, 7, 7, 9, 9, 7], [7, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [7, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 8, 7, 7, 7, 7, 9, 7], [7, 7, 7, 7, 7, 7, 8,... | [{"input": [[1, 1, 1, 1, 3, 1, 1, 1, 1, 3, 1, 1, 1, 1], [1, 1, 1, 1, 3, 1, 1, 1, 1, 3, 1, 1, 6, 1], [1, 1, 1, 1, 3, 1, 6, 6, 1, 3, 1, 6, 6, 1], [1, 1, 1, 1, 3, 1, 6, 1, 1, 3, 1, 1, 6, 1], [1, 6, 1, 1, 3, 1, 6, 1, 1, 3, 1, 6, 1, 1], [1, 1, 1, 1, 3, 1, 1, 1, 1, 3, 1, 1, 1, 1], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
1 1 1 1 3 1 1 1 1 3 1 1 1 1
1 3 3 1 3 1 3 3 1 3 1 3 6 1
1 3 3 1 3 1 6 6 1 3 1 6 6 1
1 3 3 1 3 1 6 3 1 3 1 3 6 1
1 6 1 1 3 1 6 1 1 3 1 6 1 1
1 1 1 1 3 1 1 1 1 3 1 1 1 1
3 3 3 3 3 3 3 3 3 3 3 3 3 3
1 1 1 1 3 1 1 1 1 3 1 1 1 1
1 3 3 1 3 1 3 6 1 3 1 6 6 1
1 3 3 1 3 1 6 6 1 3 1 6 3 1
1 3 3 1 3 1 3 3 1 3 1 6 6 1
1 3 1 1 ... | 2,446 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,734 | [
"<note1>\n<description>Separate the scene into independent objects by grouping non-background pixels that touch orthogonally; each connected component is a candidate for transformation. This reduces the problem to handling a few small shapes instead of many scattered pixels.</description>\n<example>Imagine a grid w... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0], [0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0], [0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 4, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0
9 0 0 0 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0 0 0 0
4 0 0 0 0 0 0 0 0 0 0 0 0 0
4 6 6 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 7 7 0 0 0 0 0 0 0 0 0
0 0 0 7 7 0 0 0 0 0 0 0 0 0
0 0 0 7 ... | 3,030 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,682 | [
"<note1>\n<description>Look first for a narrow vertical band (few adjacent rows) that is uniformly one color; this band is the structural spine that defines the transformation region. Recognizing that spine reduces the problem to a few rows/columns instead of the whole grid.</description>\n<example>Imagine a grid w... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 8, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, ... | arc 1 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0 0
2 8 8 8 8 8 8 8 4 0 0 0
2 8 8 8 8 8 8 4 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0 0
2 8 8 8 4 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 ... | 2,978 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,320 | [
"<note1>\n<description>Look first for a consistent per-cell mapping: does each input cell become a different color in the output? If so, the transformation is likely a one-to-one substitution (a permutation of colors) rather than a spatial operation like rotation or reflection.</description>\n<example>Imagine a sma... | [{"input": [[7, 5, 8, 9, 9], [5, 1, 1, 3, 3], [1, 1, 9, 4, 1], [1, 5, 1, 7, 2], [1, 5, 1, 1, 9]], "output": [[5, 5, 5, 0, 8], [0, 0, 5, 5, 0], [5, 5, 9, 5, 6], [5, 8, 2, 1, 9], [9, 3, 5, 1, 9]]}, {"input": [[2, 9, 9, 5, 4], [5, 7, 9, 5, 4], [5, 4, 3, 3, 3], [8, 9, 1, 6, 4], [7, 8, 1, 6, 6]], "output": [[8, 6, 0, 0, 3],... | [{"input": [[2, 2, 3, 1, 8], [2, 6, 3, 8, 8], [2, 7, 6, 1, 1], [7, 2, 6, 6, 1], [7, 2, 2, 6, 2]], "output": [[8, 8, 3, 3, 3], [3, 3, 8, 5, 3], [3, 5, 5, 1, 1], [5, 5, 5, 6, 5], [3, 5, 5, 6, 6]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
8 8 3 3 3
3 3 8 5 3
3 5 5 1 1
5 5 5 6 5
3 5 5 6 6
``` | 616 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,664 | [
"<note1>\n<description>Scan the input for any color that appears exactly once (a singleton). That singleton is the trigger: it is not moved but used to determine where other pixels should appear in the output. Recognizing the singleton first simplifies the rest of the transformation.</description>\n<example>Imagine... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 2, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 3, 0, 2, 0, 1, 0], [0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 0, 0, 0, 2, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 9 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 9 0 0 1 9 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 9 0 0 0 0 0
0 3 0 9 2 3 9 2 0 1 0
0 0 0 0 0 2 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 2 3 0 0 2 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 2 0 0
``` | 1,960 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,734 | [
"<note1>\n<description>Look for uniform 2×2 blocks in the output: many ARC tasks convert single input pixels into small filled squares. If you see many 2×2 patches of the same color, that strongly suggests the transformation is \"expand single pixels into 2×2 blocks.\"</description>\n<example>Imagine a 6×6 input wi... | [{"input": [[4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7], [1, 0, 4, 0, 0, 0, 7, 0, 0, 8, 0, 0, 0, 0, 0, 0, 4], [0, 7, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0, 9, 2, 0, 8, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 7, 0, 9, 0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[5, 0, 0, 0, 0, 5, 5, 0, 0, 7, 0, 8, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 3, 0, 3], [0, 0, 8, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 4], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 7, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5 0 0 0 5 5 8 8 7 3 3 3 3
5 8 8 0 0 0 9 9 8 7 3 3 4 4
0 1 1 0 0 0 9 9 0 0 0 0 4 4
0 1 1 0 0 1 7 7 0 0 0 0 0 0
0 0 0 0 0 1 7 7 0 0 0 0 0 0
0 5 5 0 0 0 0 0 0 0 0 0 0 0
2 2 5 0 5 5 6 6 0 0 3 3 0 0
2 2 0 0 5 4 4 8 8 0 3 8 8 0
8 8 0 0 0 4 4 8 8 7 7 8 8 0
8 8 0 0 0 0 0 0 0 7 7 0 0 0
2 2 0 0 0 0 0 0 0 0 5 5 0 0
2 2 0 0 ... | 3,030 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,590 | [
"<note1>\n<description>Look first for a global spatial reduction: many tasks compress the grid by grouping adjacent cells into a smaller grid. If the output dimensions are exactly half the input dimensions, think in terms of 2×2 blocks (or 1×2 or 2×1 blocks) that each become one output cell.</description>\n<example... | [{"input": [[7, 7, 7, 4, 7, 5, 7, 7], [7, 7, 7, 7, 7, 7, 7, 5], [7, 4, 7, 7, 5, 5, 7, 7], [7, 4, 7, 4, 7, 7, 7, 7], [7, 7, 4, 7, 7, 5, 7, 5], [7, 7, 7, 7, 7, 7, 7, 7], [7, 4, 7, 7, 7, 7, 7, 7]], "output": [[7, 6, 7, 6], [7, 7, 7, 6], [6, 6, 7, 7], [7, 6, 7, 6], [7, 6, 6, 6], [7, 7, 7, 7], [7, 6, 7, 7]]}, {"input": [[2,... | [{"input": [[2, 2, 2, 2, 2, 1], [2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 5], [2, 2, 2, 2, 2, 2]], "output": [[2, 2, 2, 2, 2, 6], [2, 2, 2, 2, 2, 2]]}] | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 2 2 2 2 6
2 2 2 2 2 2
``` | 1,886 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,182 | [
"<note1>\n<description>Look for a repeated rectangular block that stands out from the surrounding background: the output usually isolates the smallest contiguous rectangle that contains the whole motif. This rectangle is the minimal bounding box around the pattern you must extract.</description>\n<example>Imagine a... | [{"input": [[4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 0, 8, 8, 8, 8, 0, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 0, 4, 0, 4, 4], [4, 4, 4, 0, 4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 0, 8, 8, 8, 8, 0, 4, 4], [4, 4, 0, 4, 4, 0, 4, 0, 0, 4], [4, 4, 4, 4, 0, 4, 4... | [{"input": [[2, 2, 2, 2, 4, 2, 2, 4, 2, 2, 4], [2, 2, 2, 4, 8, 2, 2, 2, 2, 2, 8], [2, 2, 2, 2, 8, 2, 4, 2, 2, 2, 8], [2, 2, 2, 2, 4, 2, 2, 2, 4, 2, 4], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]], "output": [[4, 2, 2, 4, 2, 2, 4], [8, 2, 2, 2, 2, 2, 8], [8, 2, 4, 2, 2, 2, 8], [4, 2, 2, 2, 4, 2, 4]]}] | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
4 2 2 4 2 2 4
8 2 2 2 2 2 8
8 2 4 2 2 2 8
4 2 2 2 4 2 4
``` | 1,478 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,393 | [
"<note1>\n<description>Spot the target color: look for a single color that appears as compact, contiguous patches (often 2×2 squares or larger rectangles). That color is the one being transformed, while other colors usually remain unchanged.</description>\n<example>Imagine a grid with a big 3×3 red patch and a few ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0], [2, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 5, 5, 0, 0, 0, 0, 5, 5, 0, 0], [2, 0, 5, 5, 0, 0, 0, 0, 5, 5, 0, 0], [2, 0, 5, 5, 0, 0, 0, 0, 5, 5, 0, 0], [1, ... | [{"input": [[1, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0], [8, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0], [1, 0, 5, 5, 5, 5, 5, 5, 0, 0, 0, 0], [1, 0, 5, 5, 5, 5, 5, 5, 0, 5, 5, 5], [7, 0, 5, 5, 5, 5, 5, 5, 0, 5, 5, 5], [7, 0, 5, 5, 5, 5, 5, 5, 0, 5, 5, 5], [7, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5], [7, 0, 0, 0, 0, 0, 5, 5, 5, 0, 0, 0], [8, ... | arc 1 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
1 0 1 1 1 1 1 1 0 0 0 0
8 0 8 8 8 8 8 8 0 0 0 0
1 0 1 1 1 1 1 1 0 0 0 0
1 0 1 1 1 1 1 1 0 1 1 1
7 0 7 7 7 7 7 7 0 7 7 7
7 0 7 7 7 7 7 7 0 7 7 7
7 0 0 0 0 0 7 7 7 7 7 7
7 0 0 0 0 0 7 7 7 0 0 0
8 0 0 0 0 0 8 8 8 0 0 0
8 0 8 8 8 0 8 8 8 0 0 0
8 0 8 8 8 0 8 8 8 0 0 0
8 0 8 8 8 0 8 8 8 0 0 0
``` | 1,689 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,370 | [
"<note1>\n<description>Look for the anchor: many ARC tasks use a full row of one color that stays unchanged. Treat that row as fixed and use it to partition the grid into two equal halves (top and bottom).</description>\n<example>Imagine a 10×10 grid where row 9 is entirely color 5; you should consider rows 0–8 as ... | [{"input": [[0, 0, 0, 0, 0, 0, 6, 0, 0, 0], [0, 4, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 2, 3], [0, 5, 0, 0, 0, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 3, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 5, 0, 0, 2], [0, 0, 0, 0, 0, 0, 0, 6, 5, 3], [5, 5, 5, 5, 5, 5, 5... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 3, 4], [0, 9, 9, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [9, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [7, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 9, 0, 0, 0, 3, 0, 0], [7, 0, 0, 4, 0, 0, 7, 0, 0, 8], [0, 0, 0, 0, 0, 0, 0, 0, 2, 0], [5, 5, 5, 5, 5, 5, 5... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
9 9 9 9 0 0 7 3 3 4
0 0 0 0 0 0 0 0 1 8
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 2 0
7 0 0 0 0 0 0 0 0 0
0 0 0 4 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
5 5 5 5 5 5 5 5 5 5
``` | 1,666 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,916 | [
"<note1>\n<description>Look for a horizontal partition: many tasks split the grid into two large blocks separated by a full row of one color. That full row (or full column) is not part of the final composition; it simply separates two regions you will work with.</description>\n<example>Imagine a grid where row 7 is... | [{"input": [[8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [7, 8, 8, 7, 8, 8, 8, 8, 8, 3, 8, 8, 8], [8, 7, 7, 8, 8, 8, 3, 8, 3, 3, 8, 8, 8], [8, 8, 8, 8, 8, 3, 8, 8, 3, 3, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8,... | [{"input": [[6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 0, 4, 4, 4, 4, 4, 6], [6, 6, 6, 6, 6, 4, 4, 0, 4, 0, 4, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [4, 3, 4, 6, 6, 6, 6, 6, 6, 6, 6, 6], [4, 4, 3, 6, 6, 6, 6, 4, 4, 1, 4, 6], [4, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 7 7 7 7 7 7 7 7 7 7 7
7 4 3 4 7 7 7 7 7 7 7 7
7 4 4 3 7 7 7 7 7 7 7 7
7 4 4 4 7 7 7 7 7 7 7 7
7 4 4 4 7 7 7 7 7 7 7 7
7 4 4 4 7 7 7 7 7 7 7 7
7 7 7 7 7 7 7 7 7 7 7 7
7 7 7 7 4 4 7 7 7 7 7 7
7 7 7 7 4 9 7 7 7 7 7 7
7 7 7 7 7 7 7 7 7 7 7 7
7 7 7 7 7 7 7 7 7 7 7 7
7 7 7 0 4 4 4 4 4 7 7 7
7 7 7 4 4 0 4 0 4 7 7 7
``` | 3,212 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,366 | [
"<note1>\n<description>Look for a single contiguous region that contains every color present in the grid. That region is usually the largest connected blob and is the source of the transformation.</description>\n<example>Imagine a grid where one large block contains red, blue and green pixels while other colors app... | [{"input": [[6, 5, 6, 6, 9, 9], [6, 6, 6, 9, 9, 9], [6, 5, 5, 9, 9, 9], [6, 6, 5, 6, 9, 9], [6, 6, 6, 9, 6, 9], [6, 6, 5, 9, 6, 9], [6, 6, 6, 6, 6, 0], [6, 6, 6, 6, 6, 6], [6, 6, 8, 6, 6, 6], [6, 6, 6, 6, 6, 0], [6, 6, 6, 0, 0, 6], [6, 6, 6, 6, 0, 6]], "output": [[6, 9, 9], [9, 9, 9], [9, 9, 9], [6, 9, 9], [9, 0, 9], [... | [{"input": [[5, 5, 5, 7, 7, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 5, 5, 4, 5, 5, 5], [7, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 5, 4, 5, 4], [5, 5, 5, 5, 7, 5, 5, 5, 5, 5, 5, 5, 5, 4, 5, 5, 4, 4, 4, 5, 4, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 5, 4, 4, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 5 3 3 4 5 5 4 6 5 6
6 3 5 3 4 4 4 6 4 3 4
6 3 4 3 7 4 4 4 5 4 6
6 6 3 4 3 4 4 6 6 3 6
5 5 3 5 4 6 6 6 4 4 4
4 6 4 3 5 6 6 4 6 4 3
4 5 6 4 6 4 4 4 6 5 4
``` | 1,662 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,114 | [
"<note1>\n<description>Identify the background by frequency: the color that fills most of the grid is usually the background. Treat every other color as foreground and collect their coordinates as the seed points for the transformation.</description>\n<example>Imagine a 7×7 grid where 40 cells are color A and 3 cel... | [{"input": [[5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, ... | [{"input": [[6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 9, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 6 6 6 6 6 6 6 6 6 6
6 6 6 6 6 6 6 6 6 6 6 6
6 6 9 9 9 9 9 9 9 9 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 6 6 6 6 9 6
6 6 9 6 6 6 9 6 6 6 9 6
6 6 ... | 2,410 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,823 | [
"<note1>\n<description>Look for a repeating vertical period: many ARC tasks tile the same arrangement of colors down the rows. If you can split the grid into identical vertical blocks (same columns, same heights), the output is usually one of those blocks.</description>\n<example>Imagine a grid where the left 3 col... | [{"input": [[1, 4, 1, 1, 1, 1, 1, 1, 1, 4, 1], [4, 4, 1, 1, 1, 1, 1, 1, 1, 4, 4], [1, 1, 1, 1, 1, 1, 1, 8, 8, 1, 1], [1, 1, 3, 1, 1, 1, 1, 1, 8, 1, 1], [1, 1, 3, 1, 1, 1, 1, 1, 8, 1, 1], [1, 1, 1, 1, 1, 1, 1, 8, 8, 1, 1], [4, 4, 1, 1, 1, 1, 1, 1, 1, 4, 4], [1, 4, 1, 1, 1, 1, 1, 1, 1, 4, 1], [1, 4, 1, 1, 1, 1, 1, 1, 1, ... | [{"input": [[2, 2, 8, 2, 2, 2, 2, 8, 2, 2, 2, 2, 8, 2, 2, 2, 2, 8, 2, 2, 2, 2, 8, 2, 2], [2, 1, 6, 1, 2, 2, 4, 6, 4, 2, 2, 1, 6, 1, 2, 2, 4, 6, 4, 2, 2, 8, 8, 8, 2], [8, 8, 8, 8, 8, 8, 4, 4, 4, 8, 8, 1, 1, 1, 8, 8, 4, 4, 4, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 4, 6, 4, 8, 8, 1, 6, 1, 8, 8, 4, 6, 4, 8, 8, 8, 8, 8, 8], ... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 2 8 2 2
2 1 6 1 2
8 1 1 1 8
8 1 6 1 8
2 1 1 1 2
2 1 6 1 2
2 1 1 1 2
8 1 6 1 8
8 1 1 1 8
2 1 6 1 2
2 2 8 2 2
``` | 2,119 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,970 | [
"<note1>\n<description>Look for small, fully filled square objects: contiguous same-color pixels that form a perfect square (all cells inside a square bounding box are that color). These compact, axis-aligned filled squares are the units that get moved or rearranged. Identifying these shapes is the first step becau... | [{"input": [[0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 2, 2, 0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 4, 4, 0, 1, 1, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 2, 2, 0, 4, 4, 0, 1, 1, 0], [0, 2, 2, 0, 4, 4, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 2, 2], [0, 0, 0, 0, 0, 0, 0, 0, 2, 2], [0, 1, 1, 0, 0, 0, 0, 2, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 0], [0, 0, 0, 4, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | arc 1 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 1 1 0 4 4 0 0 2 2
0 1 1 0 4 4 0 0 2 2
1 0 0 4 0 0 0 2 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
``` | 1,266 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,968 | [
"<note1>\n<description>Look for the single non-background color that is consistently present across examples. When one color stands out (it is not the background) and appears repeatedly, that color is the natural candidate to drive the transformation.</description>\n<example>Imagine a grid of zeros with several blu... | [{"input": [[0, 0, 4, 4], [0, 0, 0, 4], [0, 0, 4, 4], [0, 4, 0, 0], [0, 0, 0, 0], [0, 0, 4, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 4, 0], [0, 0, 4, 0], [0, 0, 0, 0], [0, 4, 0, 0], [4, 0, 0, 0], [0, 4, 0, 0], [0, 0, 0, 4], [0, 0, 4, 4], [0, 0, 0, 4], [0, 0, 0, 0], [0, 0, 4, 0], [0, 0, 0, 0], [0, 0, 0, 0], ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 8, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0], [0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 8, 0, 0, 8, 0, 0, 0, 0, 0], ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8
``` | 2,264 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,530 | [
"<note1>\n<description>Look for a single color that fills most of the grid or appears as a large uniform region; treat that color as the background and ignore it when searching for the meaningful pattern. This isolates the small, repeated object that the transformation acts on.</description>\n<example>Imagine a 10×... | [{"input": [[1, 1, 1, 1, 1, 1, 3, 8, 8, 3, 8, 8], [1, 1, 1, 1, 1, 1, 9, 0, 8, 9, 0, 8], [1, 1, 1, 1, 1, 1, 1, 9, 8, 1, 9, 8], [1, 1, 1, 1, 1, 1, 1, 0, 9, 1, 0, 9], [1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 9, 1], [1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 9, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], "output": [[3, 8, 8, 3, 8, 8, 3, 8, 8, 3,... | [{"input": [[6, 1, 8, 6, 1, 8, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [4, 1, 1, 6, 6, 1, 4, 4, 4, 1, 4, 1, 6, 1, 7, 7, 7], [6, 1, 8, 6, 1, 8, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [4, 1, 1, 6, 6, 1, 4, 4, 4, 1, 4, 1, 6, 1, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 1 8 6 1 8 4 7 7 7 7 7 7 7 7 7 7
4 1 1 6 6 1 4 4 4 1 4 1 6 1 7 7 7
6 1 8 6 1 8 4 7 7 7 7 7 7 7 7 7 7
4 1 1 6 6 1 4 4 4 1 4 1 6 1 7 7 7
6 1 8 6 1 8 4 7 7 7 7 7 7 7 7 7 7
4 1 1 6 6 1 4 4 4 1 4 1 6 1 7 7 7
6 1 8 6 1 8 4 7 7 7 7 7 7 7 7 7 7
4 1 1 6 6 1 4 4 4 1 4 1 6 1 7 7 7
6 1 8 6 1 8 4 7 7 7 7 7 7 7 7 7 7
4 1 1 6 6 ... | 3,826 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,642 | [
"<note1>\n<description>Look for a single, dominant color that appears far more often than any other. When one color overwhelmingly fills the grid, that color is often the anchor for the transformation.</description>\n<example>Imagine a 6×6 grid where color A appears 20 times and every other color appears at most tw... | [{"input": [[8, 0, 6, 0, 0, 5, 0, 7, 9, 0, 8, 0, 2], [9, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3], [0, 0, 8, 3, 1, 0, 0, 5, 0, 0, 9, 8, 0], [8, 0, 0, 0, 0, 8, 0, 0, 0, 4, 0, 0, 2], [0, 0, 0, 0, 3, 8, 0, 2, 6, 9, 9, 7, 0], [0, 0, 7, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6], [1, 9, 0, 0, 0, 9, 0, 5, 0, 0, 7, 0, 0], [0, 0, 1, 3, 5, 0, 7,... | [{"input": [[0, 0, 8, 0, 3, 9], [0, 0, 0, 0, 0, 5], [0, 2, 0, 3, 7, 0], [4, 0, 0, 7, 0, 0], [5, 0, 0, 0, 0, 6], [0, 7, 0, 0, 1, 0], [0, 8, 9, 5, 0, 0], [0, 4, 2, 0, 9, 0], [0, 1, 0, 0, 9, 3], [8, 5, 0, 0, 0, 0], [7, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 3, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 3 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
``` | 1,938 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,734 | [
"<note1>\n<description>Separate foreground from background by frequency and connectivity: treat any cell that is not the background color as part of an object. This isolates shapes so you can compare them as whole objects rather than individual pixels.</description>\n<example>Imagine a grid with a black background ... | [{"input": [[0, 0, 6, 0, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 0, 0, 0, 9, 9, 9, 9, 0, 0, 0, 0, 0], [0, 6, 6, 6, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 6, 0, 0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
8 8 8 0 0 0 0 0 0 0 0 0 0 0
8 8 8 0 0 0 0 0 0 0 0 0 0 0
0 8 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 8 8 0 0 0 0 0 0 0 0 0 0 0
8 8 8 8 0 0 0 0 0 0 0 0 0 0
8 8 8 8 ... | 3,030 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,160 | [
"<note1>\n<description>Look for a single color that appears in a compact, contiguous block and is completely surrounded by other colors; that block is the object to extract. This color is typically the only one that forms a solid patch distinct from the surrounding pattern.</description>\n<example>Imagine a grid wh... | [{"input": [[6, 5, 2, 9, 2, 9, 2, 2, 2, 2, 2, 3, 2, 6, 3, 5, 6, 2, 2, 2, 6, 2, 2], [6, 5, 2, 9, 2, 9, 2, 2, 2, 2, 2, 3, 2, 6, 3, 5, 6, 2, 2, 2, 6, 2, 2], [6, 5, 0, 9, 0, 8, 8, 8, 8, 8, 8, 8, 0, 6, 3, 5, 6, 0, 0, 0, 6, 0, 0], [0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [6, 5, 2, 9, 2, 8, 2, 2,... | [{"input": [[9, 5, 9, 9, 1, 9, 8, 9, 5], [9, 5, 9, 9, 1, 9, 8, 9, 5], [2, 5, 2, 2, 1, 2, 8, 2, 5], [9, 5, 9, 9, 1, 9, 8, 9, 5], [9, 5, 9, 9, 1, 9, 8, 9, 5], [9, 5, 9, 9, 1, 9, 8, 9, 5], [9, 5, 9, 9, 1, 9, 8, 9, 5], [9, 5, 9, 9, 1, 9, 8, 9, 5], [9, 5, 9, 9, 4, 4, 4, 9, 5], [6, 6, 6, 6, 4, 6, 4, 6, 6], [9, 5, 9, 9, 4, 9,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
4 4 4
4 6 4
4 9 4
4 4 4
``` | 2,456 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,370 | [
"<note1>\n<description>Find the anchor object: look for a single, closed, uniform-colored frame or ring that occupies a compact area and surrounds a smaller interior region. This frame is the reference object whose interior is the source of the transformation.</description>\n<example>Imagine a small square of one c... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 7, 7, 7, 7, 7, 7, 0, 0], [0, 0, 7, 2, 0, 0, 8, 7, 0, 0], [0, 0, 7, 0, 0, 0, 0, 7, 0, 0], [0, 0, 7, 0, 0, 0, 0, 7, 0, 0], [0, 0, 7, 9, 0, 0, 3, 7, 0, 0], [0, 0, 7, 7, 7, 7, 7, 7, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 3, 3, 3, 3, 3, 0, 0], [0, 0, 3, 6, 0, 0, 4, 3, 0, 0], [0, 0, 3, 0, 0, 0, 0, 3, 0, 0], [0, 0, 3, 8, 0, 0, 2, 3, 0, 0], [0, 0, 3, 3, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 2 0 0 0 0 0 0 8 0
0 0 3 3 3 3 3 3 0 0
0 0 3 0 0 0 0 3 0 0
0 0 3 0 0 0 0 3 0 0
0 0 3 0 0 0 0 3 0 0
0 0 3 3 3 3 3 3 0 0
0 4 0 0 0 0 0 0 6 0
0 0 0 0 0 0 0 0 0 0
``` | 1,666 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,376 | [
"<note1>\n<description>Find the motif by locating a contiguous horizontal block of a color that is different from the dominant background. Treat that contiguous run as the repeating unit to be transformed rather than isolated single pixels.</description>\n<example>Imagine a grid mostly filled with color A and one r... | [{"input": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], "output": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1... | [{"input": [[2, 2, 2, 2, 2, 2, 2, 2, 2, 8], [2, 2, 2, 2, 2, 2, 2, 2, 8, 2], [2, 2, 2, 2, 2, 2, 2, 8, 2, 2]], "output": [[2, 2, 2, 2, 2, 2, 2, 2, 2, 8], [2, 2, 2, 2, 2, 2, 2, 2, 8, 2], [2, 2, 2, 2, 2, 2, 2, 8, 2, 2], [2, 2, 2, 2, 2, 2, 8, 2, 2, 2], [2, 2, 2, 2, 2, 8, 2, 2, 2, 2], [2, 2, 2, 2, 8, 2, 2, 2, 2, 2], [2, 2, 2... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 2 2 2 2 2 2 2 2 8
2 2 2 2 2 2 2 2 8 2
2 2 2 2 2 2 2 8 2 2
2 2 2 2 2 2 8 2 2 2
2 2 2 2 2 8 2 2 2 2
2 2 2 2 8 2 2 2 2 2
2 2 2 8 2 2 2 2 2 2
2 2 8 2 2 2 2 2 2 2
2 8 2 2 2 2 2 2 2 2
8 2 2 2 2 2 2 2 2 2
``` | 2,672 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,834 | [
"<note1>\n<description>Look for a full row and a full column made of the same color; those two lines cross and form a rectangular \"hole\" that is the area to change. This is the only region the output modifies and everything else stays as-is. Identifying this cross is the first step because it defines the target r... | [{"input": [[0, 0, 5, 0, 0, 0, 1, 1, 1], [0, 0, 5, 0, 0, 0, 1, 1, 1], [0, 0, 5, 0, 1, 1, 1, 1, 1], [0, 0, 5, 0, 1, 1, 1, 0, 0], [0, 0, 5, 1, 1, 1, 1, 0, 0], [0, 0, 5, 0, 1, 0, 0, 0, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5], [4, 8, 5, 0, 0, 0, 0, 0, 0], [9, 6, 5, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 8, 8, 8], [0, 0, 0, 8, 8,... | [{"input": [[3, 7, 5, 0, 0, 0, 0, 0, 0], [6, 8, 5, 0, 0, 0, 0, 0, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5], [0, 0, 5, 0, 1, 1, 0, 0, 0], [0, 0, 5, 0, 0, 1, 0, 0, 1], [0, 0, 5, 0, 0, 1, 1, 1, 1], [0, 0, 5, 1, 1, 1, 1, 0, 0], [0, 0, 5, 1, 0, 0, 1, 0, 0], [0, 0, 5, 0, 0, 0, 1, 1, 0]], "output": [[0, 3, 3, 0, 0, 0], [0, 0, 3, 0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 3 3 0 0 0
0 0 3 0 0 7
0 0 3 7 7 7
6 6 6 8 0 0
6 0 0 8 0 0
0 0 0 8 8 0
``` | 1,130 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,370 | [
"<note1>\n<description>Separate the grid into meaningful objects by treating connected non-background pixels as components. This isolates the shapes that the transformation acts on rather than the whole grid.</description>\n<example>Imagine a grid with a single contiguous 3×3 block of color A and another isolated 2... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 2, 0, 0, 2, 0], [0, 0, 0, 1, 1, 2, 1, 1, 2, 0], [0, 0, 1, 1, 1, 2, 2, 2, 2, 0], [0, 0, 1, 1, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 1, 2, 1, 0], [0, 0, 0, 0, 0, 0, 2, 2, 2, 0], [0, 0, 0, 0, 0, 0, 2, 2, 2, 0], [0, 0, 0, 0, 0, 0, 1, 2, 1, 0], [0, 0, 0, 0, 0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 0, 0, 0, 0, 0], [0, 1, 0, 2, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0
0 3 3 3 3 0 0 0 0 0
0 3 0 2 0 0 0 0 0 0
0 3 3 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 3 3 3 0 0 0 0
0 0 0 3 3 3 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
``` | 1,666 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,478 | [
"<note1>\n<description>Look for contiguous groups of a minority color that form a compact, roughly rectangular cluster. Such clusters are the objects the task usually targets because they are visually distinct from the dominant background and the other color.</description>\n<example>Imagine a mostly gray grid with ... | [{"input": [[9, 6, 9, 9, 9, 9, 9, 9, 9, 9, 6, 6, 9, 6, 9, 6, 6, 6, 6, 6, 6, 9, 6, 6, 9, 9, 6, 6, 6, 6], [6, 9, 6, 6, 9, 6, 6, 6, 9, 6, 9, 6, 6, 9, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 9, 6, 9], [6, 6, 6, 6, 9, 6, 6, 6, 9, 6, 9, 6, 9, 9, 9, 9, 9, 6, 9, 9, 9, 6, 6, 6, 6, 6, 9, 6, 9, 6], [6, 6, 6, 6, 6, 9, 9, 9, 9, 6, 6... | [{"input": [[7, 7, 7, 3, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 3, 7, 7, 7, 7, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [3, 7, 7, 3, 7, 7, 7, 7, 3, 7, 7, 7, 7, 3, 3, 3, 3, 3, 3, 3, 3, 7], [7, 3, 3, 3, 7, 7, 3, 7, 3, 3, 3, 3, 3, 3, 7, 3, 3, 3, 3, 3, 3, 7], [3, 7, 3, 3, 7, 7, 7, 7, 3, 3, 7, 7,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 7 7 3 3 3 3 3 7 7 7 7 7 7 7 7 7 7 7 7 7 7
7 7 7 3 4 4 4 4 3 7 7 7 7 7 7 7 7 7 7 7 7 7
3 7 7 3 4 4 4 4 3 7 7 7 7 3 3 3 3 3 3 3 3 7
7 3 3 3 4 4 3 4 3 3 3 3 3 3 4 3 3 3 3 3 3 7
3 4 3 3 4 4 4 4 3 3 4 4 3 3 4 3 4 4 4 3 3 7
3 4 3 7 3 3 3 3 3 3 3 3 3 3 4 3 3 3 3 3 3 7
3 4 3 7 7 7 3 3 3 3 3 4 4 3 4 4 4 4 4 4 3 7
3 4 3 7 ... | 3,774 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,984 | [
"<note1>\n<description>Find the unique non-background color in the input; that color is the target for the transformation. Focusing on a single target simplifies the task because the rule applies only to that color's pixels.</description>\n<example>Imagine a grid filled with zeros except for a few red pixels. Mark ... | [{"input": [[0, 0, 0, 0, 0, 8, 0, 0], [8, 0, 8, 8, 0, 0, 0, 8], [0, 8, 8, 0, 8, 0, 8, 8], [0, 8, 0, 8, 8, 0, 0, 8], [8, 0, 8, 0, 8, 8, 0, 0], [8, 0, 8, 0, 8, 0, 8, 8], [8, 0, 0, 0, 8, 8, 8, 8], [8, 8, 8, 8, 0, 0, 8, 0], [0, 0, 0, 0, 0, 8, 0, 0], [8, 0, 8, 0, 8, 8, 8, 8]], "output": [[0, 0, 0, 0, 0, 4, 0, 0], [4, 2, 4, ... | [{"input": [[0, 6, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 6, 0, 6, 0, 6, 6], [0, 6, 6, 0, 6, 6, 6, 6, 6], [6, 0, 0, 0, 0, 0, 6, 0, 0], [0, 0, 6, 0, 6, 6, 6, 0, 6], [0, 6, 0, 0, 6, 6, 0, 0, 6], [6, 6, 0, 6, 6, 6, 6, 0, 0], [6, 0, 6, 0, 0, 0, 6, 6, 6], [0, 0, 6, 6, 0, 0, 6, 0, 6]], "output": [[0, 5, 0, 5, 5, 5, 2, 2, 2], [0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 5 0 5 5 5 2 2 2
0 0 0 5 2 5 2 5 5
0 5 6 2 5 5 5 5 5
5 2 0 2 2 2 5 2 2
0 0 5 2 5 5 5 2 6
2 5 2 2 5 5 2 2 5
5 5 2 6 6 6 6 0 0
6 0 5 2 0 0 6 6 6
0 0 5 5 0 0 6 0 6
``` | 1,280 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,992 | [
"<note1>\n<description>Find the background color first: it is usually the single color that fills most of the grid. Treat that color as the canvas and focus on the small set of other colors that form the interesting objects. This reduces the problem to “where are the non-background pixels?”</description>\n<example>... | [{"input": [[3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 8, 3, 3, 8], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 4, 3, 3,... | [{"input": [[5, 5, 5, 5, 0, 5, 5, 5, 0, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 4, 6, 4, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 4, 6, 4, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 6, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 6, 6, 6, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 6, 4, 6, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 4, 6, 6... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5 5 5 0 5 5 5 0 5 5 5 5 5 5
5 5 5 5 5 4 6 4 5 5 5 5 5 5 5
5 5 5 5 5 4 6 4 5 5 5 5 5 5 5
5 5 5 5 5 6 5 5 5 5 5 5 5 5 5
5 5 5 5 5 6 6 6 5 5 5 5 5 5 5
5 5 5 5 5 6 4 6 5 5 5 5 5 5 5
5 5 5 5 5 4 6 6 5 5 5 5 5 5 5
5 5 5 5 5 6 4 4 5 5 5 5 5 5 5
5 5 5 5 5 6 4 6 5 5 5 5 5 5 5
5 5 5 5 5 5 4 6 5 5 5 5 5 5 5
5 5 5 5 5 5 4 6 ... | 3,288 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,078 | [
"<note1>\n<description>Look for a single full-width (or full-height) line made of the same color that runs across the grid; that line usually serves as a deliberate divider and should not be part of the final output. Treat it as a separator rather than content to keep. This is effective because a continuous stripe ... | [{"input": [[8, 2, 2, 8, 2, 0, 8, 8, 8, 8, 4], [8, 8, 2, 2, 2, 0, 4, 8, 8, 4, 4], [2, 2, 2, 2, 2, 0, 4, 4, 8, 8, 4], [8, 8, 8, 8, 8, 0, 8, 8, 8, 8, 8], [2, 2, 8, 8, 2, 0, 8, 8, 8, 8, 4], [2, 2, 8, 8, 8, 0, 8, 8, 8, 8, 8], [2, 2, 8, 2, 8, 0, 8, 4, 4, 8, 4], [2, 2, 8, 2, 2, 0, 8, 4, 8, 8, 8], [8, 8, 2, 2, 8, 0, 8, 8, 4, ... | [{"input": [[7, 5], [5, 5], [5, 5], [5, 5], [5, 7], [7, 5], [5, 5], [5, 5], [5, 5], [0, 0], [6, 6], [5, 6], [5, 5], [6, 6], [6, 6], [6, 6], [6, 5], [5, 6], [6, 5]], "output": [[3, 3], [5, 3], [5, 5], [3, 3], [3, 3], [3, 3], [3, 5], [5, 3], [3, 5]]}] | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 3
5 3
5 5
3 3
3 3
3 3
3 5
5 3
3 5
``` | 2,374 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,590 | [
"<note1>\n<description>Look for a single color that appears in the outputs but not in the inputs; that color is the marker used by the transformation. When a color is introduced only in the outputs, it usually indicates a systematic recoloring rather than a new object.</description>\n<example>Imagine a 6×6 input wi... | [{"input": [[5, 5, 0, 0, 8, 5, 8, 8, 8, 0, 0, 5, 9, 0, 0, 0, 9], [0, 8, 0, 5, 9, 7, 0, 0, 9, 7, 8, 0, 0, 0, 0, 0, 0], [8, 5, 9, 7, 0, 8, 8, 0, 0, 5, 0, 0, 0, 7, 0, 0, 0], [9, 0, 7, 0, 0, 0, 7, 0, 0, 0, 8, 8, 0, 5, 7, 0, 0], [5, 0, 7, 0, 5, 7, 9, 9, 7, 0, 7, 8, 0, 0, 9, 9, 0], [7, 5, 0, 8, 0, 7, 9, 8, 7, 5, 7, 8, 0, 9, ... | [{"input": [[0, 2, 0, 1, 1, 2, 2, 0, 9, 0], [0, 0, 1, 0, 0, 0, 9, 0, 0, 9], [2, 0, 0, 0, 2, 1, 0, 2, 9, 1], [0, 9, 0, 0, 9, 0, 9, 0, 0, 0], [0, 9, 2, 1, 0, 0, 2, 0, 0, 1]], "output": [[0, 2, 0, 6, 1, 2, 6, 0, 9, 0], [0, 0, 1, 0, 0, 0, 6, 0, 0, 6], [6, 0, 0, 0, 2, 1, 0, 2, 9, 6], [0, 9, 0, 0, 9, 0, 6, 0, 0, 0], [0, 9, 2... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 2 0 6 1 2 6 0 9 0
0 0 1 0 0 0 6 0 0 6
6 0 0 0 2 1 0 2 9 6
0 9 0 0 9 0 6 0 0 0
0 9 2 6 0 0 6 0 0 6
``` | 2,886 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,734 | [
"<note1>\n<description>Scan each color's pixels and compute its bounding box: the smallest rectangle that contains every pixel of that color. This reduces each colored shape to a compact coordinate pair (min_row, min_col) and (max_row, max_col).</description>\n<example>Imagine a color appears at positions that span... | [{"input": [[0, 0, 6, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 0, 0, 6, 0, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 8, 8, 0, 6, 6, 0, 0, 0, 0, ... | [{"input": [[0, 0, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 5 5
0 0 0 0 0 0 0 0 0 0 0 5 5 0
0 0 0 0 0 0 0 0 0 0 0 5 5 0
0 0 0 0 0 0 0 0 0 6 6 6 5 5
0 0 0 0 ... | 3,030 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,656 | [
"<note1>\n<description>Look for a single isolated pixel that is different from the dominant background and the main object. Such a pixel often acts as a marker whose color is preserved and moved in the output.</description>\n<example>Imagine a mostly empty grid with one green pixel sitting alone on the edge; that g... | [{"input": [[0, 0, 0, 0, 0, 0, 8], [0, 4, 4, 4, 0, 0, 0], [0, 4, 4, 4, 4, 0, 0], [0, 4, 4, 4, 4, 4, 0], [0, 0, 4, 4, 4, 4, 0], [0, 0, 0, 4, 4, 4, 0], [0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0], [0, 4, 4, 4, 0, 0, 0], [0, 4, 4, 4, 4, 0, 0], [0, 4, 4, 4, 4, 4, 0], [0, 0, 4, 4, 4, 4, 0], [0, 0, 0, 4, 4, 4, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 5], [0, 0, 6, 6, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 0, 0], [0, 0, 0, 6, 6, 0, 0], [0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 0, 0], [0, 0, 0, 6, 6, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0
0 0 6 6 0 0 0
0 0 6 6 6 6 0
0 6 6 6 6 6 0
0 6 6 6 6 0 0
0 0 0 6 6 0 0
0 0 0 0 0 0 5
``` | 952 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,928 | [
"<note1>\n<description>Look for a narrow vertical band made of a single repeated color; this band usually spans many rows and is a clear structural feature. Treat that band as the reference for other operations rather than as a color to change.</description>\n<example>Imagine a grid where column 4 is filled with th... | [{"input": [[7, 7, 7, 7, 7, 7, 7], [7, 8, 7, 7, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7]], "output": [[7, 7, 7, 7, 7, 7, 7], [7, 8, 7, 7, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 5, 7]]}, {"input": [[7, 7, ... | [{"input": [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 7, 7, 7], [7, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 7, 7, 7], [7, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 7, 7, 7], [7, 8, 7, 7, 7, 7, 7, 8, 7, 7, 7, 2, 7, 7, 7], [7, 8, 7, 7, 7, 7, 7, 8, 7, 7, 7, 2, 7, 7, 7], [7, 8, 7, 2, 7, 7, 7, 8, 7... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 7 7 7 7 7 7 7 7 7 7 7 7 7 7
7 7 7 7 7 7 7 7 7 7 7 2 7 7 7
7 8 7 7 7 7 7 7 7 7 7 2 7 7 7
7 8 7 7 7 7 7 7 7 7 7 2 7 7 7
7 8 7 7 7 7 7 8 7 7 7 2 7 7 7
7 8 7 7 7 7 7 8 7 7 7 2 7 7 7
7 8 7 2 7 7 7 8 7 7 7 2 7 7 7
7 8 7 2 7 8 7 8 7 7 7 2 7 5 7
7 8 7 2 7 8 7 8 7 2 7 2 7 5 7
``` | 1,224 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,936 | [
"<note1>\n<description>Locate the single non-background color and treat its connected component as the object to transform. When there is one dominant color forming a single contiguous shape, that color is usually the one being moved or extended.</description>\n<example>Imagine a grid with only zeros and a cluster ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 0, 0, 0], [0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 0, 0, 0], [0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 0, 0, 0], [0, 0, 0, 0, 0, 8, 8,... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 8, 8, 8, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 8 8 8 8 8 8 8 8
0 0 0 0 0 0 0 8 8 8 8 8 8 8 8
0 0 0 0 0 0 0 8 8 8 8 8 8 8 8
0 0 0 0 0 0 0 8 8 8 8 8 8 8 8
0 0 0 8 8 8 8 8 8 8 8 8 8 8 8
0 0 0 0 8 8 8 8 8 8 8 8 8 8 8
0 0 0 0 8 8 8 8 8 8 8 8 8 8 8
0 0 0 8 0 8 8 8 8 8 8 8 8 8 8
0 0 0 0 0 0 0 8 8 8 8 8 8 8 8
``` | 2,232 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,490 | [
"<note1>\n<description>Look for a single, unique non-background pixel in each input. When the input contains exactly one colored cell, that cell is usually the element the transformation acts on; identifying it reduces the problem to a small geometric operation.</description>\n<example>Imagine a 7×7 grid with one r... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 8, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0], [0, 0, 0, 0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 ... | 1,786 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,356 | [
"<note1>\n<description>Look for the dominant (background) color by frequency or by the color that fills most of the grid. This color is usually the one you should exclude when searching for the target object. Identifying it first simplifies the rest of the search.</description>\n<example>Imagine a grid where one co... | [{"input": [[4, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 4], [5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 8, 4, 4, 8, 4, 8, 4, 4], [4, 5, 4, 4, 4, 4, 8, 4, 4, 4, 8, 4, 4, 4, 8, 4, 4, 4], [4, 5, 4, 4, 4, 4, 8, 8, 4, 8, 4, 4, 4, 4, 8, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 8, 4, 4, 4, 4, 8, 4, 4, 4, 4], [4, 1, 1, 4, 1, 4, 4, 4, 4, ... | [{"input": [[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 7, 7], [2, 2, 2, 8, 2, 2, 2, 2, 7, 7, 7, 7, 7], [2, 2, 2, 2, 8, 8, 2, 2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 2], [9, 9, 2, 2, 2, 2, 2, 2, 2, 2, 6, 2, 2], [2, 9, 2, 2, 2, 2, 2, 2, 2, 6, 2, 2, 2], [2, 2, 2, 2, 2, 2, 3,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5
``` | 3,652 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,610 | [
"<note1>\n<description>Look for a single color that appears in every row at the same column — this is a vertical separator and acts as the grid's spine. Treat that column as a reference line when comparing rows.</description>\n<example>Imagine a 5×6 grid where column 3 is entirely color X in every row. That column ... | [{"input": [[8, 3, 3, 3, 3, 3, 3, 1], [8, 3, 3, 3, 0, 3, 3, 1], [8, 3, 3, 3, 3, 3, 3, 1], [8, 3, 3, 3, 3, 0, 3, 1], [8, 3, 3, 0, 3, 3, 3, 1]], "output": [[8, 3, 3, 3, 3, 3, 3, 1], [8, 3, 3, 3, 1, 3, 3, 1], [8, 3, 3, 3, 3, 3, 3, 1], [8, 3, 3, 3, 3, 1, 3, 1], [8, 3, 3, 8, 3, 3, 3, 1]]}, {"input": [[0, 0, 0, 0, 0, 0, 0, 0... | [{"input": [[8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 4, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 4, 0, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 0, 4, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, 7], [8, 0, 0, 0, 0, 0, 0, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 8 0 0 0 0 7
8 0 0 0 0 0 0 7
8 8 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 8 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 7 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 7 0 7
8 0 0 8 0 0 7 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 0 7
8 0 0 0 0 0 ... | 2,906 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,628 | [
"<note1>\n<description>Look for a one-cell-wide rectangular frame that surrounds the interior: every row has the same first and last cell equal to the frame color, and every column has the same first and last cell equal to that color. This frame is the only region that is entirely uniform (all border cells share on... | [{"input": [[9, 1, 2, 7, 6, 2, 2, 2, 4, 8, 9, 0, 8, 0, 1], [9, 2, 6, 0, 6, 2, 4, 9, 6, 6, 9, 0, 1, 4, 0], [4, 8, 1, 6, 6, 0, 6, 4, 2, 1, 8, 0, 0, 2, 1], [2, 6, 9, 4, 1, 4, 4, 9, 0, 0, 7, 6, 1, 6, 6], [8, 0, 4, 1, 9, 4, 7, 8, 8, 0, 6, 1, 7, 1, 9], [1, 6, 0, 0, 1, 4, 2, 2, 4, 2, 6, 7, 6, 7, 6], [1, 8, 7, 8, 1, 7, 4, 1, 8... | [{"input": [[6, 9, 7, 4, 9, 6, 4, 6, 5, 9, 7, 2, 7, 6, 4], [7, 4, 7, 5, 2, 5, 7, 9, 7, 4, 6, 7, 5, 4, 4], [9, 4, 5, 5, 9, 9, 2, 5, 4, 2, 6, 6, 4, 4, 4], [4, 2, 7, 5, 9, 6, 5, 4, 5, 5, 6, 5, 5, 6, 5], [7, 5, 7, 7, 2, 5, 5, 9, 2, 4, 6, 2, 2, 4, 5], [5, 7, 9, 4, 5, 7, 7, 7, 5, 4, 9, 5, 6, 7, 5], [9, 5, 6, 9, 6, 4, 9, 6, 2... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
7 4 7 5 2 5 7 9 7 4 6 7 5 4 3
3 3 3 3 3 3 3 3 3 3 3 3 3 4 3
3 2 7 5 9 6 5 4 5 5 6 5 3 6 3
3 5 3 3 3 3 3 3 3 3 3 2 3 4 3
3 7 3 4 5 7 7 7 5 4 3 5 3 7 3
3 5 3 9 3 3 3 3 3 4 3 2 3 5 3
3 4 3 4 3 7 7 2 9 9 3 4 3 9 3
3 2 3 9 3 3 3 3 3 3 3 2 3 5 3
3 2 3 4 6 7 2 6 5 2 7 7 3 7 3
3 7 3 3 3 3 3 3 ... | 3,924 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,814 | [
"<note1>\n<description>Look for a horizontal period: many ARC tasks use a small repeating motif (here a 3-cell horizontal pattern). Identifying that motif is the first step because the transformation usually acts on that unit rather than on individual pixels.</description>\n<example>Imagine a row that reads A B A B... | [{"input": [[4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0]], "output": [[6, 0, 4, 0, 4, 0, 6, 0, 4, 0, 4, 0, 6], [6, 4, 4, 6, 4, 4, 6, 4, 4, 6, 4, 4, 6], [0, 4, 0, 6, 0, 4, 0, 4, 0, 6, 0, 4, 0]]}, {"input": [[0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0], [4... | [{"input": [[0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4]], "output": [[0, 4, 0, 6, 0, 4, 0, 4, 0, 6, 0, 4, 0, 4, 0, 6, 0], [6, 4, 4, 6, 4, 4, 6, 4, 4, 6, 4, 4, 6, 4, 4, 6, 4], [6, 0, 4, 0, 4, 0, 6, 0, 4, 0, ... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 4 0 6 0 4 0 4 0 6 0 4 0 4 0 6 0
6 4 4 6 4 4 6 4 4 6 4 4 6 4 4 6 4
6 0 4 0 4 0 6 0 4 0 4 0 6 0 4 0 4
``` | 1,110 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,690 | [
"<note1>\n<description>Identify the background by frequency: the color that occupies the majority of cells is the canvas; everything else is foreground. This separation tells you which pixels are part of the object you should transform. </description>\n<example>Imagine a 10×10 grid where 80 cells are color A and th... | [{"input": [[5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 1], [5, 5, 4, 5, 5, 5, 5], [5, 5, 4, 5, 5, 5, 5], [5, 4, 4, 4, 5, 5, 5], [5, 4, 5, 5, 5, 5, 5], [5, 4, 4, 5, 4, 4, 5], [5, 4, 4, 5, 4, 5, 5], [5, 5, 4, 4, 4, 5, 5], [5, 4, 4, 4, 4, 4, 5], [5, 4, 4,... | [{"input": [[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 8, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 8, 2], [2, 2, 2, 2, 2, 2, 2, 2, 8, 8, 2, 8, 8, 2], [2, 2, 2, 2, 2, 8, 8, 2, 2, 8, 8, 8, 8, 2], ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 2 2 2 2 2 2 2 2 2 2 2 2 2
2 2 2 2 2 2 2 2 2 2 2 5 2 2
2 2 2 2 2 2 2 2 2 2 2 5 2 2
2 2 2 2 2 2 2 2 2 2 2 5 5 2
2 2 2 2 2 2 2 2 2 2 2 5 5 2
2 2 2 2 2 2 2 2 5 5 2 5 5 2
2 2 2 2 2 5 5 2 2 5 5 5 5 2
2 2 2 2 2 2 5 2 5 5 5 5 5 2
2 2 2 2 2 2 5 2 2 2 2 2 5 2
2 2 2 5 5 5 5 5 2 2 5 5 5 2
2 2 2 5 5 5 5 2 2 5 5 5 5 2
2 2 2 5 ... | 2,986 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,370 | [
"<note1>\n<description>Look for the background color (usually 0) that forms a large contiguous area and treat it as the canvas. When the transformation is about filling a region, the canvas color is the natural choice for the newly introduced color.</description>\n<example>Imagine a grid where almost all cells are ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 1, 1], [0, 0, 0, 0, 0, 1, 0, 0, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 1, 0, 0, 1, 1], [0, 0, 0, 0, 0, 1, 0, 0, 1, 1], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 1, 1, 1, 1... | [{"input": [[0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0, 1, 0], [0, 0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 1, 1, 0, 1, 1, 0], [0, 0, 0, 0, 0, 1, 0, 0, 1, 0], [0, 0, 0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 1 0 0 0 0 0
0 0 1 1 1 1 1 0 0 0
0 0 0 0 1 1 0 0 1 0
0 2 0 0 1 0 0 0 1 0
0 2 2 0 1 1 1 1 1 1
2 2 2 2 1 1 0 1 1 0
0 2 0 0 0 1 0 0 1 0
0 2 0 0 1 1 0 0 0 0
0 0 0 1 1 1 1 1 0 0
0 0 0 0 0 1 0 0 0 0
``` | 1,666 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,188 | [
"<note1>\n<description>First isolate the object to transform: find the minimal bounding rectangle that contains every non-background pixel of the target color. This reduces the problem to moving a single shape rather than many pixels scattered around.</description>\n<example>Imagine a grid with a cluster of red pix... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 0], [0, 0, 6, 6, 6, 6, 6, 0], [0, 0, 6, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 6, 6, 6], [0, 0, 6, 6, 6, 6, 6, 0], [0, 0, 6, 6, 6, 6, 6, 0], [0, 0, 0, 0, 6, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 6, 0, 0, 0, 0], [0, 6, 6, 6, 6, 6, 0, 0], [0, 6, 6, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 6 0 0 0 0
0 0 0 6 6 6 0 0 0
0 0 0 0 6 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 6 0 0 0 0
0 0 0 6 6 6 0 0 0
0 0 0 0 6 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 ... | 1,484 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,734 | [
"<note1>\n<description>Find the anchor: many tasks start from a single colored pixel. Treat that pixel as the reference point for all subsequent placement decisions.</description>\n<example>If a grid has exactly one non-background pixel, locate its coordinates and record them. That coordinate will be used as the or... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 6 0 0 6 0 6 0 6
0 0 0 0 0 6 6 6 0 6 0 6 0 6
0 0 0 0 ... | 3,030 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,826 | [
"<note1>\n<description>Look for contiguous rectangular regions that are uniform in color and bounded by another color on each side. These rectangles are the objects the task treats as \"frames\" — their bounding box is the natural unit for the transformation.</description>\n<example>Imagine a grid with a blue recta... | [{"input": [[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 6, 6, 6, 6, 6, 6, 4, 4, 4, 4], [4, 6, 6, 6, 6, 6, 6, 4, 4, 4, 4], [4, 6, 6, 6, 6, 6, 6, 4, 4, 4, 4], [4, 6, 6, 6, 6, 6, 6, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 4, 4, 4, 4, 4, 4, 4, 4, ... | [{"input": [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 2, 2, 2, 2, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 2, 2, 2, 2, 7, 7, 1, 1, 1, 1, 7, 7], [7, 7, 7, 2, 2, 2, 2, 7, 7... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 7 7 7 7 7 7 7 7 7 7 7 7 7 7
7 7 7 2 2 2 2 7 7 7 7 7 7 7 7
7 7 7 2 8 8 2 7 7 7 7 7 7 7 7
7 7 7 2 8 8 2 7 7 7 7 7 7 7 7
7 7 7 2 8 8 2 7 7 7 7 7 7 7 7
7 7 7 2 8 8 2 7 7 1 1 1 1 7 7
7 7 7 2 8 8 2 7 7 1 8 8 1 7 7
7 7 7 2 2 2 2 7 7 1 8 8 1 7 7
7 7 7 7 7 7 7 7 7 1 8 8 1 7 7
7 7 7 7 7 7 7 7 7 1 1 1 1 7 7
7 7 7 7 7 7 7 7 ... | 3,122 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,370 | [
"<note1>\n<description>Look for the unique marker color that is present only once in each input. That single pixel usually serves as the anchor or reference point for the transformation because it is distinct from repeated colors.</description>\n<example>Imagine a grid with many blue pixels and one single red pixel... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 0, 0, 0, 4, 0, 0, 0, 0, 4], [0, 0, 0, 0, 0, 0, 4, 0, 4, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 4, 0, 0, 0], [0, 0, 0, 0, 4, 0, 4... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 4, 0, 0, 4, 4], [0, 0, 4, 0, 0, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 4 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
4 0 0 4 1 4 0 0 4 4
0 0 4 0 0 4 0 0 0 0
0 0 0 0 0 0 0 0 4 0
0 0 0 0 0 4 0 0 0 0
0 0 0 0 0 4 0 0 0 0
0 0 0 0 0 0 0 0 0 0
``` | 1,666 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,378 | [
"<note1>\n<description>Start by comparing dimensions: if the output is a simple multiple of the input's height and width, the transformation is likely a uniform scaling (an enlargement) rather than a rearrangement or recoloring. This gives you a starting hypothesis about how many output rows and columns to expect.<... | [{"input": [[0, 0, 6, 0, 0], [0, 0, 0, 0, 0], [6, 6, 6, 6, 6], [0, 6, 0, 0, 0]], "output": [[0, 0, 6, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [6, 6, 6, 6, 6, 0, 0, 0], [0, 6, 0, 0, 0, 0, 0, 0], [0, 0, 6, 0, 0, 0, 0, 0]]}, {"input": [[0, 0, 7, 7], [7, 0, 7, 0], [0, 0, 0, 0], [7, 0, 0, 0], [0, 0, 0, 7]], "output": [[0,... | [{"input": [[6, 6, 0], [6, 6, 6], [6, 0, 0]], "output": [[6, 6, 0, 0, 0, 0], [6, 6, 6, 0, 0, 0], [6, 0, 0, 0, 0, 0]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 0 0 0 0
6 6 6 0 0 0
6 0 0 0 0 0
``` | 674 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,182 | [
"<note1>\n<description>Find the background by looking for the color that fills most cells; the remaining color(s) form the pattern to isolate. This is effective because the output is a compact crop of the pattern, not the full noisy background.</description>\n<example>Imagine a 7×7 grid where 40 cells are color A a... | [{"input": [[3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, ... | [{"input": [[1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 7, 1, 1, 7, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
1 1 1
1 7 1
4 1 1
``` | 3,478 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,830 | [
"<note1>\n<description>Look for a single non-zero color that appears exactly once in the whole grid; that color is the anchor for the output. This anchor is not the background (zeros) and is used to determine the vertical position of the output.</description>\n<example>Imagine a 5×5 grid with a single green pixel a... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 2, 0, 7, 0, 0, 0], [1, 0, 0, 2, 2, 0, 4, 1, 0, 4], [0, 3, 0, 1, 0, 0, 3, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 7, 0, 1], [0, 0, 3, 0, 0, 3, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 7, 0, 0, 0, 0], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 0, 0, 0, 0, 0, 0, 0, 2, 0], [0, 0, 0, 0, 2, 0, 0, 0, 7, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 3, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 4 0 3 7
0 0 0 0 0
``` | 1,126 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,578 | [
"<note1>\n<description>Look for a dominant (background) color that fills most cells; that color is the one the transformation preserves. Isolating this color makes the rest of the grid easier to analyze because the change will be relative to it.</description>\n<example>Imagine a grid that is almost entirely blue wi... | [{"input": [[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [0, 4, 0, 4, 0, 4, 0, 0, 0, 4, 0, 0, 4, 0, 0, 4, 0, 4, 0, 0, 0, 4, 0, 4, 0, 4], [0, 4, 0, 4, 0, 4, 0, 0, 0, 4, 0, 0, 4, 0, 0, 4, 0, 4, 0, 0, 0, 4, 0, 4, 0, 4], [0, 4, 0, 4, 0, 4, 0, 0, 0, 4, 0, 0, 4, 0, 0, 5, 0, 4, 0, 0, 0, 4, 0... | [{"input": [[5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0], [5, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0], [5, 5, 5, 5, 5, 5, 5, 5, 1, 0, 0, 0, 0, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0], ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 0 0 0 0 0 0 0 0 0 0 0 1
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 0 0 0 0 1
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 5 5 5 5 0
5 5 5 5 5 5 5 5 5 5 5 5 5 0
``` | 3,874 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,678 | [
"<note1>\n<description>Group pixels by their color and treat each contiguous cluster as an object. This reduces the problem to a small set of objects rather than many individual pixels, making it easier to see which objects are being moved or recolored.</description>\n<example>Imagine a grid with three separate col... | [{"input": [[0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 9, 9, 9, 9, 9, 0, 0, 0, 0], [0, 0, 0, 0, 9, 9, 9, 9, 9, 0, 0, 0, 0], [0, 0, 0, 9, 9, 9, 9, 9, 9, 0, 0, 0, 0], [0, 0, 0, 0, 9, 9, 9, 9, 9, 6, 6, 6, 6], [0, 0, 0, 0, 9, 9, 9, 9, 9, 6, 6, 6, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6], [0, 0, 0, 0, 0, 0, 0,... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 9 9 9 9 9 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 9 9 9 9 9 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 9 9 9 9 9 9 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 9 9 9 9 9 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 9 ... | 3,974 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,208 | [
"<note1>\n<description>Look for the primary object: many tasks here are dominated by a single contiguous block of one color. Identifying that block (its bounding box and the color it uses) is the first step because it determines the anchor for the rest of the transformation.</description>\n<example>Imagine a grid w... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7], [0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7], [0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0], [3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 0, 0], [3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 0, 0], [3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 3, 3], [3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 3, 3], [0, 0, 0, 0, 0, 8, 8, 8, 0, 0, 3, 3], [0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0], [0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0], [0, 0, 2, 2, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 3 3 3 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 3 3 3 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 ... | 3,504 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,953 | [
"<note1>\n<description>Find the single non-background object that is being transformed: the colored pixels form a compact cluster (not scattered). Treat that cluster as the unit to be manipulated rather than many independent pixels.</description>\n<example>Imagine a mostly blank grid with a 3×3 colored block in the... | [{"input": [[8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 4, 8, 8, 8, 8, 8, 8, 8], [8, 8, 7, 1, 6, 5, 6, 1, 8, 8], [8, 8, 8, 8, 8, 8, 8, 2, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8... | [{"input": [[8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 9, 9, 2, 8], [8, 8, 8, 8, 8, 8, 9, 8, 2, 8], [8, 8, 6, 6, 1, 8, 5, 8, 2, 8], [8, 8, 6, 8, 4, 8, 5, 8, 4, 8], [8, 8, 7, 8, 1, 5, 5, 8, 4, 8], [8, 8, 7, 8, 8, 8, 8, 8, 4, 8], [8, 8, 7, 8, 8, 8, 8, 8, 1, 8], [8, 8, 1, 1, 7, 8, 8, 1, 1, 8], [8, 8, 8, 8, 8, 8, 8... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
8 8 8 8 8 8 8 8 8 8
8 8 8 8 8 8 4 1 6 8
8 8 8 8 8 8 1 8 6 8
8 8 2 2 9 8 5 8 6 8
8 8 2 8 9 8 5 8 7 8
8 8 4 8 9 5 5 8 7 8
8 8 4 8 8 8 8 8 7 8
8 8 4 8 8 8 8 8 1 8
8 8 1 1 1 8 8 7 1 8
8 8 8 8 8 8 8 8 8 8
``` | 1,249 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,406 | [
"<note1>\n<description>Start by listing all connected components and their bounding boxes. For each component compute its color, area (number of cells), and bounding-box width and height; these simple attributes are the first clues to the transformation.</description>\n<example>Imagine a grid with three colored blo... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0], [0, 4, 4, 4, 0, 0, 0, 2, 2, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 3, 3, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0], [0, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 7, 7, 7, ... | arc 2 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 3 3 3 3 3 0 0 0 0 0 0 0 0 0 0 0
0 3 3 3 3 3 7 7 7 7 0 0 0 0 0 0 0
0 3 3 3 3 3 7 7 7 7 0 0 0 0 0 0 0
0 3 3 3 3 3 7 7 7 7 0 0 0 0 0 0 0
0 3 3 3 3 3 0 0 0 0 0 0 0 0 0 0 0
0 3 3 3 3 3 0 0 0 0 0 0 0 0 0 0 0
0 3 3 3 3 ... | 3,702 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,296 | [
"<note1>\n<description>Separate background from objects by frequency and spatial extent: the background is usually the most frequent color and fills empty areas, while the object color(s) form contiguous shapes. This helps you identify which pixels are part of the shape to transform.</description>\n<example>Imagine... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 0, 0, 0, 0], [0, 0, 0, 2, 2, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, ... | [{"input": [[0, 0, 0, 0, 0, 0, 2, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 2, 2], [0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 1, 0, 0, 0], [2, 1, 1, 1, 1, 1, 2, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 4, 0, 0], [0, 3,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 4 0 0
0 3 3 3 3 3 0 0 0
0 3 3 3 3 3 0 0 0
0 3 3 3 3 3 0 0 0
0 3 3 3 3 3 0 0 0
0 3 3 3 3 3 0 4 4
0 3 3 3 3 3 0 0 0
0 3 3 3 3 3 0 0 0
4 3 3 3 3 3 4 0 0
``` | 1,592 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,734 | [
"<note1>\n<description>Look for a global color permutation: when every non-background pixel in the input appears again in the output at the same coordinates, the transformation is a relabeling of colors rather than a spatial rearrangement. This is effective because it reduces the problem to finding how one color ma... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 7, 0, 6, 0, 4, 0, 6, 0, 9, 0, 8, 0, 5, 0, 6, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 7, 0, 9, 0, 3, 0, 3, 0, 7, 0, 7, 0, 9, 0, 7, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 5, 0, 7, 0, 1, 0, 6, 0, 5, 0, 8, 0, 7, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 6, 0, 5, 0, 3, 0, 6, 0, 9, 0, 5, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 9, 0, 1, 0, 6, 0, 5, 0, 6, 0, 5, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 6, 0, 9, 0, 9, 0, 7, 0, 6, 0, 6, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 7 0 8 0 2 0 7 0 8 0 8 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 8 0 4 0 7 0 8 0 7 0 8 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 7 0 8 0 8 0 6 0 7 0 7 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 7 0 9 0 8 0 1 0 4 0 6 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 6 0 7 0 8 0 4 0 3 0 7 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 8 0 3 ... | 3,030 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,474 | [
"<note1>\n<description>Look for the single compact object that is being transformed: a small filled square (commonly 2×2) made of one non-background color. This object is the only element that matters for the mapping and is typically isolated from the background by spacing.</description>\n<example>Imagine a grid wi... | [{"input": [[0, 0, 0, 0, 0, 0], [0, 6, 6, 0, 0, 0], [0, 6, 6, 0, 0, 0], [0, 0, 0, 6, 6, 0], [0, 0, 0, 6, 6, 0], [0, 0, 0, 0, 0, 0]], "output": [[3, 0, 0, 0, 0, 0], [3, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]}, {"input": [[0, 0, 0, 0, 0, 0], [6, 6, 0, 0, 0, 0], [6,... | [{"input": [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4], [0, 0, 0, 0, 4, 4]], "output": [[7, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
``` | 770 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,378 | [
"<note1>\n<description>Look for a simple tiling: sometimes the output is just the input repeated horizontally. This is effective when each output row matches an input row exactly, with no internal changes.</description>\n<example>Imagine an input row [A B C]. If the output shows [A B C A B C], that indicates the in... | [{"input": [[7, 6, 6, 9, 9], [5, 1, 1, 3, 3], [1, 1, 1, 7, 2], [1, 5, 1, 1, 9]], "output": [[7, 6, 6, 9, 9, 7, 6, 6, 9, 9], [5, 1, 1, 3, 3, 5, 1, 1, 3, 3], [1, 1, 1, 7, 2, 1, 1, 1, 7, 2], [1, 5, 1, 1, 9, 1, 5, 1, 1, 9]]}, {"input": [[2, 2, 7, 7], [7, 7, 7, 7], [3, 7, 1, 7], [3, 8, 6, 1], [7, 4, 4, 1]], "output": [[2, 2... | [{"input": [[6, 1, 8], [1, 1, 4], [1, 6, 2]], "output": [[6, 1, 8, 6, 1, 8], [1, 1, 4, 1, 1, 4], [1, 6, 2, 1, 6, 2]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 1 8 6 1 8
1 1 4 1 1 4
1 6 2 1 6 2
``` | 674 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,678 | [
"<note1>\n<description>Look for a single color that forms a continuous, straight band across many rows or columns — this is the stripe that defines the region of interest. The stripe usually spans most of its row or column and is visually the dominant or repeated feature.</description>\n<example>Imagine a grid wher... | [{"input": [[3, 0, 3, 0, 3, 5, 3, 5, 5, 5, 5, 5, 5, 3, 1, 0, 0, 0, 0], [5, 0, 5, 5, 1, 5, 1, 0, 3, 5, 3, 1, 5, 5, 5, 3, 0, 1, 3], [5, 0, 5, 5, 0, 3, 3, 3, 1, 5, 0, 1, 0, 1, 0, 0, 3, 1, 0], [5, 3, 0, 3, 1, 0, 1, 5, 1, 0, 5, 0, 3, 0, 3, 1, 0, 3, 0], [5, 1, 0, 1, 5, 0, 5, 1, 0, 1, 0, 0, 5, 0, 1, 3, 5, 1, 3], [0, 5, 1, 0, ... | [{"input": [[3, 0, 9, 0, 0, 0, 9, 3, 9, 3, 9, 0, 9, 3, 9, 0, 3, 0], [0, 9, 0, 0, 9, 0, 3, 0, 3, 9, 3, 0, 3, 0, 3, 3, 0, 3], [0, 3, 9, 3, 3, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3], [0, 9, 3, 0, 3, 5, 5, 5, 3, 5, 5, 5, 5, 5, 5, 5, 5, 3], [0, 9, 3, 9, 9, 5, 5, 3, 5, 5, 5, 5, 5, 5, 5, 5, 5, 9], [3, 0, 0, 9, 9, 5, 5, 5, 5, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5 3 3 3 5 5 3 5 5 5 5
3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3 3 3 3
5 5 3 3 3 5 5 3 5 5 5 5
``` | 2,974 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,104 | [
"<note1>\n<description>Identify the single non-background object and compute its bounding box. Knowing its height (rows) and width (columns) reduces the problem to a small set of integer ratios and symmetries to test.</description>\n<example>Imagine a filled 3×4 rectangle: its bounding box is height 3 and width 4. ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 7, 7, 7, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 7, 7, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "ou... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 1 1 0 0 0
0 0 0 0 1 1 0 0 0
0 0 0 0 1 1 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
``` | 1,400 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,832 | [
"<note1>\n<description>Check the output dimensions first: if the output is a 3×3, the task is likely reducing the whole input into a coarse 3×3 summary. This tells you to group the input into 3×3 blocks and summarize each block rather than searching for a local motif or a color change.</description>\n<example>For a... | [{"input": [[0, 0, 3, 4, 3], [0, 3, 4, 3, 3], [3, 4, 4, 3, 0], [4, 0, 9, 0, 0], [3, 4, 0, 3, 4], [9, 0, 4, 9, 4], [0, 3, 3, 0, 4]], "output": [[0, 0, 5], [0, 0, 5], [5, 5, 5]]}, {"input": [[7, 0, 0, 5, 8], [0, 8, 9, 2, 5], [7, 6, 5, 8, 7], [7, 5, 0, 5, 0], [8, 8, 6, 4, 8], [4, 6, 8, 9, 4], [2, 2, 6, 8, 7], [7, 4, 4, 5,... | [{"input": [[6, 6, 9, 9, 9, 3, 6, 9, 9, 9, 9, 9, 9, 9, 6, 6, 9, 9, 6, 6, 3, 6, 9, 6, 3, 9], [9, 9, 6, 9, 9, 6, 9, 6, 9, 9, 3, 3, 9, 9, 6, 6, 6, 6, 3, 9, 9, 9, 9, 6, 3, 3], [9, 3, 6, 9, 9, 6, 6, 9, 6, 9, 6, 9, 9, 6, 9, 9, 6, 9, 9, 3, 9, 6, 6, 6, 6, 6], [9, 6, 9, 6, 9, 6, 9, 6, 9, 6, 3, 3, 6, 6, 9, 6, 9, 9, 6, 9, 9, 3, 9... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 5
0 0 5
5 5 5
``` | 3,128 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,763 | [
"<note1>\n<description>Look for vertical columns that are entirely occupied by the same non‑background color; these are likely the objects to be transformed. Treat each such full column as a single vertical object rather than many separate pixels.</description>\n<example>Imagine a 9×9 grid where column 4 is entirel... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 5, 0, 0, 0, 0, 0, 0], [0, 0, 5, 0, 0, 0, 5, 0, 0], [5, 0, 5, 0, 0, 0, 5, 0, 0], [5, 0, 5, 0, 0, 0, 5, 0, 0], [5, 0, 5, 0, 5, 0, 5, 0, 0], [5, 0, 5, 0, 5, 0, 5, 0, 5], [5, 0, 5, 0, 5, 0, 5, 0, 5], [5, 0, 5, 0, 5, 0, 5, 0, 5]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0,... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 5, 0], [0, 0, 0, 5, 0, 0, 0, 5, 0], [0, 0, 0, 5, 0, 0, 0, 5, 0], [0, 0, 0, 5, 0, 5, 0, 5, 0], [0, 0, 0, 5, 0, 5, 0, 5, 0], [0, 0, 0, 5, 0, 5, 0, 5, 0], [0, 0, 0, 5, 0, 5, 0, 5, 0], [0, 5, 0, 5, 0, 5, 0, 5, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0,... | arc 1 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0
0 2 0 0 0 0 0 1 0
``` | 1,059 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,462 | [
"<note1>\n<description>Look for a single color that consistently becomes a uniform, solid block in the outputs. When one color is the only one that changes and it becomes a filled rectangle, that color is the candidate for the transformation.</description>\n<example>Imagine a grid where only blue pixels appear in t... | [{"input": [[5, 8, 0, 1], [0, 0, 2, 0], [0, 9, 3, 0], [0, 9, 0, 4], [0, 0, 0, 2], [8, 0, 0, 0], [9, 2, 0, 0], [3, 0, 9, 9], [7, 0, 0, 8], [7, 4, 4, 0], [2, 7, 0, 0], [0, 0, 0, 0], [0, 0, 7, 0], [0, 0, 5, 2], [0, 1, 7, 0], [3, 9, 0, 8], [0, 0, 0, 2], [7, 0, 0, 0], [0, 0, 0, 0], [5, 0, 2, 7], [0, 0, 2, 5], [0, 0, 0, 0], ... | [{"input": [[0, 1, 8, 0], [0, 1, 1, 0], [0, 0, 8, 0], [8, 5, 1, 1], [0, 8, 8, 0], [0, 0, 8, 1], [8, 8, 8, 8], [0, 0, 1, 1], [0, 1, 5, 0], [8, 0, 8, 8], [0, 0, 0, 0], [1, 8, 0, 0], [1, 0, 0, 0], [8, 0, 5, 1], [0, 0, 5, 0], [0, 5, 0, 8], [0, 5, 8, 0], [0, 0, 8, 0], [0, 1, 5, 5], [1, 0, 5, 1], [5, 0, 0, 1], [5, 0, 0, 0], ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 1 8 0
0 1 1 0
0 0 8 0
8 5 1 1
0 8 8 0
0 0 8 1
8 8 8 8
0 0 1 1
0 1 5 0
8 0 8 8
0 0 6 6
1 8 6 6
1 0 6 6
8 0 5 1
0 0 5 0
0 5 0 8
0 5 8 0
0 0 8 0
0 1 5 5
1 0 5 1
5 6 6 1
5 6 6 0
1 6 6 8
0 0 8 5
5 0 0 5
8 0 0 5
5 0 1 0
``` | 1,758 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,474 | [
"<note1>\n<description>Check whether the output preserves the input's layout by comparing rows and columns. If each output row is composed of the same sequence of colors as an input row, the transformation is likely a horizontal repetition (tiling) rather than a rearrangement or recoloring.</description>\n<example>... | [{"input": [[9, 9, 9, 9], [1, 4, 4, 1], [1, 4, 4, 1], [1, 4, 4, 1], [1, 1, 1, 1], [9, 4, 4, 9], [1, 9, 9, 1]], "output": [[9, 9, 9, 9, 9, 9, 9, 9], [1, 4, 4, 1, 1, 4, 4, 1], [1, 4, 4, 1, 1, 4, 4, 1], [1, 4, 4, 1, 1, 4, 4, 1], [1, 1, 1, 1, 1, 1, 1, 1], [9, 4, 4, 9, 9, 4, 4, 9], [1, 9, 9, 1, 1, 9, 9, 1]]}, {"input": [[5,... | [{"input": [[4, 4, 8, 4, 4, 8, 4, 4], [8, 8, 8, 8, 8, 8, 8, 8], [3, 8, 4, 8, 8, 4, 8, 3], [8, 3, 4, 8, 8, 4, 3, 8], [3, 8, 4, 4, 4, 4, 8, 3], [4, 4, 8, 8, 8, 8, 4, 4], [4, 8, 4, 4, 4, 4, 8, 4], [3, 4, 8, 3, 3, 8, 4, 3], [8, 4, 8, 4, 4, 8, 4, 8]], "output": [[4, 4, 8, 4, 4, 8, 4, 4, 4, 4, 8, 4, 4, 8, 4, 4], [8, 8, 8, 8,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
4 4 8 4 4 8 4 4 4 4 8 4 4 8 4 4
8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8
3 8 4 8 8 4 8 3 3 8 4 8 8 4 8 3
8 3 4 8 8 4 3 8 8 3 4 8 8 4 3 8
3 8 4 4 4 4 8 3 3 8 4 4 4 4 8 3
4 4 8 8 8 8 4 4 4 4 8 8 8 8 4 4
4 8 4 4 4 4 8 4 4 8 4 4 4 4 8 4
3 4 8 3 3 8 4 3 3 4 8 3 3 8 4 3
8 4 8 4 4 8 4 8 8 4 8 4 4 8 4 8
``` | 770 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,598 | [
"<note1>\n<description>Look for connected components that are not the background: each contiguous patch of a color that is not the background is an object to consider. Treat each such patch as an independent item even if it contains several pixels.</description>\n<example>Imagine a grid with background color A and ... | [{"input": [[3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 7, 7, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 6, 3, 3, 3, 3, 3, 3,... | [{"input": [[0, 7, 7, 7, 7, 7, 7, 7], [0, 7, 7, 7, 7, 7, 7, 7], [7, 0, 7, 7, 7, 7, 7, 7], [7, 0, 7, 7, 7, 7, 7, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, 7], [7, 0, 7, 7, 7, 7, 5, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 7 7 7 7 7 7 7
2 7 7 7 7 7 7 7
7 1 7 7 7 7 7 7
7 1 7 7 7 7 7 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 4 7
7 1 7 7 7 7 7 7
7 1 7 7 7 7 7 7
7 1 7 7 7 7 7 7
7 1 7 7 7 7 7 7
7 1 7 7 7 7 7 7
7 7 7 7 7 7 7 7
7 7 7 7 7 7 7 7
7 7 7 7 7 7 ... | 3,894 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,734 | [
"<note1>\n<description>Separate the scene into distinct objects by color and compute each object's bounding box and footprint. Treat each connected component (same color) as an independent unit so you can compare shapes and positions across examples.</description>\n<example>Imagine a grid with three colored blobs. ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0, 0, 9, 9, 9, 9, 0, 0], [0, 0, 6, 6, 6, 6, 0, 0, 9, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0, 0, 9, 9, 9, 9, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 5, 5, 5, 5, 0, 0, 0, 9, 9, 9, 9, 9, 0], [0, 5, 5, 5, 5, 0, 0, 0, 9, 0, 9, 0, 9, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 6 6 6 6 0 0 5 5 5 5 0 0
0 0 6 6 6 6 0 0 5 0 0 0 0 0
0 0 6 6 6 6 0 0 5 5 5 5 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 9 9 9 9 0 0 0 9 9 9 9 9 0
0 9 9 9 9 0 0 0 9 0 9 0 9 0
0 0 9 9 9 0 0 0 9 9 9 9 9 0
0 9 9 9 9 0 0 0 0 0 0 0 0 0
0 9 9 9 9 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 ... | 3,030 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,836 | [
"<note1>\n<description>Start by checking whether the transformation preserves the set of non-background cells and their coordinates. If every colored pixel in the input appears somewhere in the output at the same coordinates, the rule is likely a relabeling (a permutation of colors) rather than a translation or rot... | [{"input": [[0, 0, 0, 0, 0, 5, 0, 0], [0, 3, 0, 0, 0, 0, 9, 0], [0, 0, 7, 0, 0, 0, 5, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 9], [0, 8, 0, 0, 0, 6, 0, 9], [7, 0, 7, 7, 0, 0, 3, 0], [0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 6, 0, 0, 0, 0, 0], [0, 8, 0, 0, 0, 0, 2, 0], [0, 6, 0, 0, 0, 7, 0, 0], [0, 0, 0, ... | [{"input": [[0, 5, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [9, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 5, 0, 0, 0], [0, 0, 0, 0, 6, 9, 0, 0, 6], [0, 0, 0, 0, 0, 6, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 5], [0, 0, 0, 0, 0, 0, 0, 0, 3]], "output": [[0, 0, 0, 0, 0, 0, 0, 6, 0], [0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 6 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 8
0 0 0 6 0 0 0 0 0
5 0 0 8 5 0 0 0 0
0 0 4 5 0 0 0 0 0
6 0 0 0 0 0 0 0 0
2 0 0 0 0 0 0 0 0
``` | 1,132 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,296 | [
"<note1>\n<description>Isolate the object by finding the single non-background pixel and use its row and column as the anchor for the transformation. Knowing the anchor gives you the center (or pivot) that all subsequent placement decisions are relative to.</description>\n<example>Imagine a grid with one blue pixel... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 8, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
0 0 6 0 0 0 0 0 0
6 6 6 6 6 0 0 0 0
6 6 6 6 6 0 0 0 0
6 6 6 6 6 6 0 0 0
6 6 6 6 6 0 0 0 0
6 6 6 6 6 0 0 0 0
0 0 6 0 0 0 0 0 0
``` | 1,592 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,396 | [
"<note1>\n<description>Look for a color that forms a continuous straight line (a full row or a full column). Such a uniform line is an anchor: the transformation often treats that line as a template and copies its cells into other rows or columns.</description>\n<example>Imagine a grid where column 5 is entirely bl... | [{"input": [[6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 4, 6, 4, 6], [4, 6, 6, 6, 6, 6, 0, 6, 0, 6], [0, 6, 6, 6, 6, 6, 0, 6, 0, 6], [0, 6, 6, 6, 6, 6, 0, 6, 0, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 0, 6, 0, 6], [0, 6, 6... | [{"input": [[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 5, 5, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5], [4, 5, 5, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5], [4, 5, 5, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5], [4, 5, 5, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5], [4, 5, 5, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5, 5, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 4 4 4 4 4 4 7 4 4 4 4 4 4 4 4 4
4 5 5 5 5 5 5 4 5 5 5 5 5 5 5 5 5
4 5 5 5 5 5 5 4 5 5 5 5 5 5 5 5 5
4 5 5 5 5 5 5 4 5 5 5 5 5 5 5 5 5
4 5 5 5 5 5 5 4 5 5 5 5 5 5 5 5 5
4 5 5 5 5 5 5 4 5 5 5 5 5 5 5 5 5
4 5 5 5 5 5 5 4 5 5 5 5 5 5 5 5 5
4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5
5 5 5 5 5 ... | 3,692 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,370 | [
"<note1>\n<description>Look for a horizontal mirror: many tasks reflect the entire grid left↔right. This means each row’s pattern is reversed across the vertical centerline, but each row stays in its original top-to-bottom order.</description>\n<example>Imagine a 2×3 grid with rows [A B C] and [D E F]. A horizontal... | [{"input": [[0, 6, 0, 0, 0, 0, 0, 5, 0, 0], [0, 0, 0, 7, 0, 0, 7, 1, 0, 4], [0, 0, 0, 7, 0, 0, 8, 0, 0, 0], [0, 7, 4, 0, 7, 0, 6, 0, 0, 8], [0, 0, 0, 0, 0, 6, 0, 0, 0, 0], [0, 0, 0, 2, 0, 0, 0, 8, 7, 0], [7, 0, 0, 5, 0, 0, 4, 0, 0, 0], [8, 0, 0, 0, 1, 0, 0, 0, 6, 0], [0, 7, 0, 9, 0, 0, 0, 7, 4, 2], [6, 0, 6, 2, 0, 0, 0... | [{"input": [[0, 5, 0, 0, 0, 0, 5, 5, 0, 0], [7, 0, 8, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 3, 0, 3, 0], [0, 8, 0, 0, 0, 0, 9, 0, 0, 1], [0, 4, 0, 0, 1, 0, 0, 0, 0, 7], [0, 0, 0, 0, 2, 0, 0, 0, 9, 0], [7, 0, 4, 5, 0, 0, 0, 0, 0, 0], [0, 0, 2, 6, 0, 0, 0, 6, 8, 1], [5, 0, 0, 0, 0, 0, 0, 2, 0, 0], [3, 5, 0, 6, 0, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 5 0 6 0 0 5 3 0 0
5 0 8 0 0 0 0 2 1 0
0 0 2 6 0 0 3 6 8 1
7 8 4 5 0 0 9 0 0 1
0 4 0 0 2 0 0 0 9 7
0 4 0 0 1 0 0 0 9 7
7 8 4 5 0 0 9 0 0 1
0 0 2 6 0 0 3 6 3 1
7 0 8 0 0 0 0 2 1 0
3 5 0 6 0 0 5 5 0 0
``` | 1,666 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,542 | [
"<note1>\n<description>Find the dominant background color and treat every other color as an object. This isolates the meaningful shapes to analyze while ignoring uniform filler.</description>\n<example>Imagine a 10×10 grid filled with gray except for a few blue and red pixels. Mark gray as background and focus only... | [{"input": [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 3, 5, 7, 7, 9, 7, 8, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 3, 5, 7, 7, 9, 7, 8, 7, 7, 7,... | [{"input": [[6, 6, 6, 6, 6, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 9, 6, 6, 6, 5, 6, 6, 2, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 9, 6, 6, 6, 5, 6, 6, 2, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 9, 6, 6, 6, 5, 6, 6, 2, 6, 6, 6, 0, 6, 6, 6, 6, 6, 6], [6, 9, 6, 6, 6, 5, 6, 6, 2, 6, 6, 6, 0, 6, 6, 6, 6, 6, 6], [6, 9, 6, 5, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 6 6 6 1 6 6 6 6 6 6 6 6 6 6 6 6 6
6 2 6 6 6 1 6 6 2 6 6 6 6 6 6 6 6 6 6
6 2 6 6 6 1 6 6 2 6 6 6 6 6 6 6 6 6 6
6 2 6 6 6 1 6 6 2 6 6 6 3 6 6 6 6 6 6
6 2 6 6 6 1 6 6 2 6 6 6 3 6 6 6 6 6 6
6 2 6 4 6 1 6 6 2 6 6 6 3 6 6 6 6 6 6
``` | 2,838 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,370 | [
"<note1>\n<description>Look for the four corner pixels in the input; these are often the only colored pixels and carry the transformation information. When a grid is sparse and colored only at corners, those corner colors are typically the key to the output.</description>\n<example>Imagine a 5×5 grid with only the ... | [{"input": [[5, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [3, 0, 0, 0, 0, 0, 0... | [{"input": [[4, 0, 0, 0, 0, 0, 0, 0, 0, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
1 3 3 3 3 3 3 3 3 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
1 0 0 0 0 0 0 0 0 2
2 2 2 2 2 2 2 2 2 2
``` | 1,666 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,128 | [
"<note1>\n<description>Look for a single row and a single column made entirely of the same color; these act as separators that split the grid into four rectangular regions. Treat the area between that horizontal and vertical separator as the four quadrants you will compare.</description>\n<example>Imagine a 7×7 gri... | [{"input": [[0, 0, 0, 1, 3, 3, 0], [0, 0, 0, 1, 3, 3, 3], [0, 0, 0, 1, 3, 3, 3], [5, 0, 0, 1, 3, 3, 3], [0, 0, 0, 1, 3, 3, 3], [0, 0, 0, 1, 0, 0, 3], [1, 1, 1, 1, 1, 1, 1], [8, 0, 8, 1, 0, 0, 0], [8, 8, 8, 1, 4, 0, 4], [8, 8, 8, 1, 0, 0, 0], [8, 8, 8, 1, 0, 4, 0], [8, 8, 8, 1, 0, 4, 4], [8, 8, 8, 1, 4, 0, 0]], "output"... | [{"input": [[6, 6, 0, 6, 5, 6, 6, 6, 8], [0, 0, 6, 6, 5, 8, 6, 8, 8], [6, 0, 6, 6, 5, 6, 6, 8, 8], [6, 6, 6, 6, 5, 8, 8, 8, 8], [5, 5, 5, 5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 5, 6, 6, 6, 6], [6, 6, 6, 6, 5, 6, 6, 6, 6], [6, 6, 6, 6, 5, 9, 6, 6, 6], [7, 6, 6, 6, 5, 6, 6, 6, 6]], "output": [[6, 6, 0, 8], [0, 0, 8, 8], [9, 0, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 0 8
0 0 8 8
9 0 8 8
8 8 8 8
``` | 1,424 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,396 | [
"<note1>\n<description>Look for a single color that appears in every training output while the input contains multiple colors. When one color is consistently chosen across examples, the transformation likely selects that color rather than inventing a new one.</description>\n<example>Imagine three training inputs ea... | [{"input": [[3, 3, 0, 0, 1, 1, 0, 0, 0, 0, 3], [3, 3, 0, 0, 1, 1, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0], [0, 0, 3, 3, 0, 0, 0, 1, 1, 0, 0], [0, 0, 3, 3, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 3, 3, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, ... | [{"input": [[3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
3 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
3 3 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 ... | 2,692 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,104 | [
"<note1>\n<description>Locate the seeds: many ARC tasks use one or two isolated non-background pixels as the only structural information. When only a few pixels differ between input and output, treat those pixels as the generators of the whole transformation.</description>\n<example>Imagine a grid with exactly two ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 4, 0], [0, 0,... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 4, 0, 0, 0], [0, 0,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 4 0 0 0
0 0 0 0 0 1 0 0 0
4 4 4 4 1 1 1 4 4
0 0 0 0 0 1 0 0 0
0 0 0 0 4 4 0 0 0
0 0 0 0 0 4 0 0 0
0 0 0 0 0 4 0 0 0
0 0 0 0 0 4 0 0 0
0 0 0 0 0 4 0 0 0
``` | 1,400 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,890 | [
"<note1>\n<description>Start by separating the grid into a background and foreground: the background is the color that fills large, continuous areas while the foreground is a small set of colors that form compact shapes. Identifying which color is the background reduces the problem to a few candidate foreground col... | [{"input": [[6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 4], [6, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 4, 0], [6, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 4, 0, 0], [6, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 4, 0, 0, 0], [6, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 9, 9, 9, 9, 0, 0], [6, 4, 4, 4, 4, 4, 4, 9, 9, 9, 9, 9, 0, 9, ... | [{"input": [[0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 0, 1, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 1, 0, 1, 1, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3], [3, 8, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3], [3, 8, 8, 8, 0, 1, 1, 1, 1, 0, 8, 0, 0, 0, 0, 0], [3, 8, 8, 8, 1, 0, 1, 1, 8, 8, 8, 0, 0, 0, 0, 0], [3, 8, 8... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 0 1 0 0 3 3 3 3 3 3 3 3 3 3 3
3 1 0 1 1 0 0 0 0 3 3 3 3 3 3 3
3 0 1 0 1 1 1 0 0 0 0 0 0 3 3 3
3 0 1 1 0 1 1 1 1 0 0 0 0 0 0 0
3 3 0 1 1 0 1 1 1 1 1 0 0 0 0 0
3 3 0 1 1 1 0 1 1 1 1 1 1 0 0 0
3 3 0 0 1 1 1 0 1 1 1 1 1 1 1 0
3 3 0 0 1 1 1 1 0 1 1 1 1 1 1 1
3 3 3 0 0 1 1 1 1 0 1 1 1 1 ... | 3,186 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,656 | [
"<note1>\n<description>Find the single isolated pixel that is not part of the main shape; this pixel usually acts as the source color for the transformation. Recognizing this marker is the first step because the rest of the operation is driven by it.</description>\n<example>Imagine a grid where one pixel stands alo... | [{"input": [[8, 0, 0, 0, 0, 0, 0], [0, 4, 4, 4, 0, 0, 0], [0, 4, 4, 4, 4, 0, 0], [0, 4, 4, 4, 4, 4, 0], [0, 0, 4, 4, 4, 4, 0], [0, 0, 0, 4, 4, 4, 0], [0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0], [0, 8, 8, 8, 0, 0, 0], [0, 8, 8, 8, 8, 0, 0], [0, 8, 8, 8, 8, 8, 0], [0, 0, 8, 8, 8, 8, 0], [0, 0, 0, 8, 8, 8, 0... | [{"input": [[5, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 6, 0], [0, 6, 6, 6, 6, 0, 0], [0, 0, 0, 6, 6, 0, 0], [0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0], [0, 0, 5, 5, 0, 0, 0], [0, 0, 5, 5, 5, 5, 0], [0, 5, 5, 5, 5, 5, 0], [0, 5, 5, 5, 5, 0, 0], [0, 0, 0, 5, 5, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0
0 0 5 5 0 0 0
0 0 5 5 5 5 0
0 5 5 5 5 5 0
0 5 5 5 5 0 0
0 0 0 5 5 0 0
0 0 0 0 0 0 0
``` | 952 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,836 | [
"<note1>\n<description>Look for the color that appears only along the outermost rows and columns; this color usually acts as a frame or border and is distinct from the interior shapes. Identifying that color is the first step because it is the one preserved or emphasized in the transformation.</description>\n<examp... | [{"input": [[9, 9, 9, 9, 9, 9, 9, 9], [9, 0, 6, 6, 6, 0, 0, 9], [9, 6, 6, 6, 6, 6, 0, 9], [9, 6, 6, 6, 6, 6, 6, 9], [9, 6, 6, 6, 6, 6, 6, 9], [9, 0, 6, 6, 6, 6, 6, 9], [9, 0, 0, 6, 6, 6, 6, 9], [9, 9, 9, 9, 9, 9, 9, 9]], "output": [[9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, ... | [{"input": [[5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 0, 0, 6, 6, 0, 0, 0, 5], [5, 0, 6, 6, 6, 0, 6, 0, 5], [5, 0, 0, 6, 6, 6, 6, 6, 5], [5, 6, 6, 6, 6, 6, 6, 6, 5], [5, 6, 6, 6, 6, 6, 0, 0, 5], [5, 0, 6, 0, 6, 6, 6, 0, 5], [5, 0, 0, 0, 6, 6, 0, 0, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5]], "output": [[5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5
``` | 1,132 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,560 | [
"<note1>\n<description>Look for a full row and a full column of the same color: when both exist they act like an X-shaped divider that naturally splits the grid into four quadrants. Treat those two lines as the axes to partition the whole grid into four regions.</description>\n<example>Imagine a 7×7 grid where row ... | [{"input": [[1, 1, 1, 1, 1, 8, 1, 4, 1, 3, 1], [1, 1, 1, 1, 1, 8, 1, 1, 1, 1, 3], [1, 1, 1, 1, 1, 8, 1, 3, 1, 1, 4], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [1, 1, 1, 1, 1, 8, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 8, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 8, 1, 1, 1, 1, 1]], "output": [[1, 4, 1, 3, 1, 8, 1, 4, 1, 3, 1], [1, 1, 1, 1, 3, ... | [{"input": [[5, 5, 5, 5, 1, 5, 5, 5, 5], [5, 5, 5, 5, 1, 5, 5, 5, 5], [5, 5, 5, 5, 1, 5, 5, 5, 5], [6, 5, 5, 5, 1, 5, 5, 5, 5], [1, 1, 1, 1, 1, 1, 1, 1, 1], [5, 5, 5, 5, 1, 5, 5, 5, 5], [5, 5, 5, 5, 1, 5, 5, 5, 5], [5, 5, 5, 5, 1, 5, 5, 5, 5], [5, 5, 5, 5, 1, 5, 5, 5, 5]], "output": [[5, 5, 5, 5, 1, 5, 5, 5, 5], [5, 5,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
5 5 5 5 1 5 5 5 5
5 5 5 5 1 5 5 5 5
5 5 5 5 1 5 5 5 5
6 5 5 5 1 6 5 5 5
1 1 1 1 1 1 1 1 1
5 5 5 5 1 5 5 5 5
5 5 5 5 1 5 5 5 5
5 5 5 5 1 5 5 5 5
6 5 5 5 1 6 5 5 5
``` | 2,856 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,542 | [
"<note1>\n<description>Look for a single color that appears as isolated single pixels scattered across the grid; that color is the object to be transformed. This is effective when one color forms many isolated points and the rest of the grid is a uniform background.</description>\n<example>Imagine a mostly-gray gri... | [{"input": [[7, 0, 0, 7, 0, 0, 0, 7, 7, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0], [0, 0, 7, 0, 0, 0, 0, 0, 7, 7, 0]], "output": [[7, 0, 0, 7, 0, 0, 3, 7, 7, 3, 0], [0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 0], [0, 0, 0, 0, 7, 0, 0, 3, 3, 3, 3], [0, 0, 7, 0, 0, 0, 0, 3, 7, 7, 3]]}, {"input": [[1,... | [{"input": [[0, 6, 6, 6, 6, 6, 6, 6, 6, 0, 6], [6, 6, 6, 6, 0, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 0, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 0, 6, 6, 6, 6, 6, 6, 6], [6, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 0, 6, 6, 6, 0, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 6 6 6 6 6 6 6 6 0 6
6 6 6 6 0 6 6 6 6 6 6
6 6 6 6 6 6 6 6 0 6 6
6 6 6 6 6 6 6 6 6 6 6
6 6 6 0 6 6 6 6 6 6 6
6 0 6 6 6 6 6 6 6 6 6
6 6 6 6 6 6 6 6 6 6 6
6 6 6 6 6 0 6 6 6 0 6
6 6 6 6 6 6 6 6 6 6 6
6 6 6 6 6 6 6 0 6 6 6
6 6 0 6 6 6 6 6 6 6 0
6 6 6 6 6 6 6 6 0 6 6
6 0 6 6 6 6 6 6 6 6 6
6 6 6 6 6 6 6 6 6 6 6
6 3 3 3 ... | 2,838 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,074 | [
"<note1>\n<description>Locate the unique non-background color and treat its connected pixels as a single object. Focusing on the object's bounding box (min/max row and column) simplifies reasoning about its size and position.</description>\n<example>Imagine a small 2×3 block of green pixels sitting on a black grid.... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
6 6 6 6 0 0 0 0 0 0 0 0
6 6 6 6 0 0 0 0 0 0 0 0
6 6 6 6 0 0 0 0 0 0 0 0
6 6 6 6 0 0 0 0 0 0 0 0
6 6 6 6 0 0 0 0 0 0 0 0
6 6 6 6 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 ... | 3,370 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,918 | [
"<note1>\n<description>Look for the background: the color that fills most of the grid. Everything else is a candidate object or marker to be transformed. Knowing the background lets you ignore the canvas and focus on the meaningful pixels.</description>\n<example>Imagine a 10×10 grid where 80 cells are color A and ... | [{"input": [[6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 2], [6, 6, 6, 2, 6, 6, 9, 2], [6, 6, 6, 2, 6, 6, 9, 2], [6, 6, 6, 2, 6, 6, 9, 2], [6, 6, 6, 2, 6, 6, 9, ... | [{"input": [[7, 7, 7, 7, 7], [7, 7, 7, 7, 7], [7, 7, 7, 7, 7], [7, 7, 7, 6, 7], [7, 7, 7, 6, 7], [7, 5, 7, 6, 7], [7, 5, 7, 6, 7], [7, 5, 7, 6, 7], [7, 5, 7, 6, 0], [7, 5, 7, 6, 0], [7, 5, 1, 6, 0], [7, 5, 1, 6, 0]], "output": [[7, 7, 7, 7, 7], [7, 7, 7, 7, 7], [7, 7, 7, 7, 7], [7, 7, 7, 1, 7], [7, 7, 7, 1, 7], [7, 2, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 7 7 7 7
7 7 7 7 7
7 7 7 7 7
7 7 7 1 7
7 7 7 1 7
7 2 7 1 7
7 2 7 1 7
7 2 7 1 7
7 2 7 1 3
7 2 7 1 3
7 2 4 1 3
7 2 4 1 3
``` | 3,214 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,844 | [
"<note1>\n<description>Look for a full row or full column made of the same color that runs through the entire grid; such a continuous line usually acts as a divider. When present, it cleanly separates the grid into two rectangular halves and is the natural boundary to use.</description>\n<example>Imagine a 10×6 gri... | [{"input": [[4, 4, 4], [4, 4, 4], [4, 4, 4], [4, 4, 8], [4, 8, 4], [7, 7, 7], [8, 8, 1], [1, 1, 1], [8, 1, 8], [1, 1, 1], [1, 8, 1]], "output": [[3, 3, 3], [3, 3, 3], [3, 3, 3], [3, 3, 3], [3, 8, 3]]}, {"input": [[0, 7, 0, 0, 0, 0, 0, 0, 0, 7, 7, 7, 0, 5, 8, 8, 8, 0, 0, 8, 8, 8, 8, 8, 8, 8, 0], [0, 0, 0, 0, 0, 0, 0, 0,... | [{"input": [[9, 9, 8, 9, 9, 8, 9, 9, 9, 8, 8, 9, 1, 5, 5, 5, 9, 5, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 8, 9, 8, 9, 8, 9, 9, 9, 1, 9, 9, 9, 9, 5, 9, 5, 9, 9, 9, 9, 9], [9, 9, 8, 9, 9, 9, 9, 9, 9, 8, 8, 9, 1, 9, 9, 5, 5, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 8, 8, 9, 9, 9, 9, 8, 9, 9, 9, 1, 9, 9, 9, 9, 9, 5, 9, 9, 9, 9, 9, 9], ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 3 3 9 3 3 9 9 9 3 3 9
9 9 9 9 3 9 3 9 3 9 9 9
9 9 3 3 9 9 9 9 9 3 3 9
9 9 3 3 9 3 9 9 3 9 9 9
9 9 9 3 3 3 3 3 9 9 9 9
9 9 3 9 9 9 9 3 9 9 9 9
9 9 9 3 3 9 9 9 3 9 3 3
9 9 9 9 3 9 9 3 3 9 3 9
9 3 9 9 9 9 9 9 9 9 3 3
9 3 9 3 3 3 9 3 3 3 3 9
9 9 3 3 3 9 3 9 9 3 3 9
9 9 3 9 9 9 3 9 9 9 3 9
3 3 9 3 3 3 3 3 9 9 3 3
9 3 ... | 3,140 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,458 | [
"<note1>\n<description>Isolate the object by finding the smallest rectangle that contains every non-background cell. Treat that rectangle as the atomic unit for the transformation — its dimensions and internal pattern are what get reused. This helps you ignore surrounding empty space and focus on the core motif.</d... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 4, 4, 4, 0, 0, 0, 0], [0, 0, 0, 4, 6, 4, 0, 0, 0, 0], [0, 0, 0, 4, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 8, 3, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 8, 8, 8, 8, 0, 0], [0, 0, 0, 0, 0, 0, 8, 3, 3, 8, 0, 0], [0, ... | arc 1 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 8 8 8 0 0 0 0 0 0 0 0
8 3 3 3 8 0 0 0 0 0 0 0
8 3 8 3 8 0 0 0 0 0 0 0
8 3 3 3 8 0 0 0 0 0 0 0
0 8 8 8 0 0 8 8 8 8 0 0
0 0 0 0 0 0 8 8 8 8 0 0
0 0 0 0 8 8 3 3 3 3 8 8
0 0 0 0 8 8 3 8 8 3 8 8
0 0 0 0 8 8 3 8 8 3 8 8
0 0 0 0 8 8 3 3 3 3 8 8
0 0 0 0 0 0 8 8 8 8 0 0
0 0 0 0 0 0 8 8 8 8 0 0
``` | 1,754 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,320 | [
"<note1>\n<description>Check whether the transformation is a color permutation: every input color is replaced by exactly one output color in a consistent way. If so, you can treat the problem as a mapping f: input_color -> output_color that you must discover.</description>\n<example>Imagine a small grid where every... | [{"input": [[2, 4, 4, 3, 2], [4, 2, 3, 3, 2], [3, 3, 3, 1, 2], [2, 4, 1, 3, 3], [2, 3, 3, 1, 3]], "output": [[3, 5, 5, 1, 3], [5, 3, 1, 1, 3], [1, 1, 1, 4, 3], [3, 5, 4, 1, 1], [3, 1, 1, 4, 1]]}, {"input": [[3, 2, 3, 3, 4], [1, 4, 3, 2, 3], [2, 1, 1, 2, 1], [3, 2, 1, 2, 2], [4, 1, 4, 1, 1]], "output": [[1, 3, 1, 1, 5],... | [{"input": [[1, 1, 2, 2, 1], [2, 1, 3, 2, 4], [1, 1, 4, 3, 1], [1, 2, 1, 4, 2], [1, 2, 1, 4, 1]], "output": [[4, 4, 3, 3, 4], [3, 4, 1, 3, 5], [4, 4, 5, 1, 4], [4, 3, 4, 5, 3], [4, 3, 4, 5, 4]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
4 4 3 3 4
3 4 1 3 5
4 4 5 1 4
4 3 4 5 3
4 3 4 5 4
``` | 616 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,370 | [
"<note1>\n<description>Scan each training pair and mark the single changed cell in the output. That changed cell is the key to the transformation: it is not a new object but a relocation of an existing pixel.</description>\n<example>Imagine a grid where one colored pixel moves from (r2,c1) to (r2,c3) while all othe... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 7], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 7, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 9, 0, 0, 0], [0, 0, 0, 0, 8, 0, 0, 0, 0, 0], [0, 0, 7, 0, 0, 0, 3, 4, 8, 2], [0, 0, 3, 7, 6, 0, 3, 0, 0, 0], [0, 0, 0, 0, 4, 0, 0, 0, 0, 0], [0, 0, 0, 4, 0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 7, 9, 0, 0, 0], [9, 0, 5, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 2, 0], [0, 5, 0, 0, 0, 8, 0, 0, 0, 6], [0, 5, 0, 0, 0, 0, 0, 0, 0, 0], [0, 7, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 7 9 0 0 0
9 0 5 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 2 0
0 0 0 0 0 8 0 0 0 6
0 5 0 0 0 0 0 0 0 0
0 7 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
``` | 1,666 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,370 | [
"<note1>\n<description>Look for a single continuous ring or perimeter color that forms a closed rectangular border around a small interior region; that ring is usually preserved while the interior pixels are moved. Recognizing the ring isolates the interior contents you should track.</description>\n<example>Imagine... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 8, 8, 8, 8, 0, 0, 0], [0, 0, 0, 8, 4, 3, 8, 0, 0, 0], [0, 0, 0, 8, 0, 0, 8, 0, 0, 0], [0, 0, 0, 8, 2, 6, 8, 0, 0, 0], [0, 0, 0, 8, 8, 8, 8, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 3, 3, 3, 3, 3, 3, 0, 0], [0, 0, 3, 6, 0, 0, 4, 3, 0, 0], [0, 0, 3, 0, 0, 0, 0, 3, 0, 0], [0, 0, 3, 8, 0, 0, 2, 3, 0, 0], [0, 0, 3, 3, 3, 3, 3, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | arc 1 | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 2 0 0 0 0 0 0 8 0
0 0 3 3 3 3 3 3 0 0
0 0 3 0 0 0 0 3 0 0
0 0 3 0 0 0 0 3 0 0
0 0 3 0 0 0 0 3 0 0
0 0 3 3 3 3 3 3 0 0
0 4 0 0 0 0 0 0 6 0
0 0 0 0 0 0 0 0 0 0
``` | 1,666 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,910 | [
"<note1>\n<description>Look first for a single-cell translation: check whether every non-background pixel in the output appears one row lower and one column to the right compared to the input. If that holds consistently across examples, the transformation is a global shift of every colored pixel.</description>\n<ex... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 5, 0, 5, 5, 5, 1, 1, 1, 0], [0, 0, 5, 0, 0, 9, 9, 9, 1, 3, 3], [0, 0, 5, 0, 0, 9, 6, 9, 0, 4, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3], [0, 0, 2, 0, 0, 0, 1, 1, 1, 0, 0], [0, 0, 2, 0, 0, 0, 0, 0, 1, 1, 1], [8, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0], [8, 0, 0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [8, 8, 8, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 9, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0], [0, ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 4 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
1 1 1 0 0 8 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0
0 0 8 0 1 0 0 0 0 0 0 0
0 0 0 0 1 1 0 0 0 0 0 0
0 0 0 0 0 0 9 1 0 0 0 0
0 0 0 0 0 1 6 0 0 0 0 0
8 8 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
``` | 2,206 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,522 | [
"<note1>\n<description>Look first for a global reordering: does the same set of colored pixels appear in the output but in a different column order? If so, the transformation is likely a column-wise reassignment rather than a local move of shapes. This is effective because it preserves shapes while only changing wh... | [{"input": [[6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 6, 6, 2, 6, 2, 6, 6, 3, 6, 6, 6, 6, 6, 6, 6], [6, 2, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 6, 6, 6, 6, 2, 6, 2, 6, 6, 6, 6, 6, 6, 2], [2, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 6, 5, 0, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], ... | [{"input": [[7, 6, 7, 7, 6, 6, 6], [6, 7, 7, 6, 6, 6, 6], [6, 6, 6, 7, 7, 6, 6], [6, 7, 7, 7, 6, 7, 7], [7, 7, 6, 7, 6, 6, 6], [6, 6, 6, 7, 6, 7, 6], [6, 7, 6, 6, 7, 6, 1], [6, 6, 6, 6, 6, 6, 7], [1, 7, 6, 6, 7, 6, 6], [6, 7, 6, 1, 1, 6, 6], [6, 7, 6, 7, 6, 7, 7], [6, 6, 6, 6, 7, 6, 6], [7, 7, 7, 6, 6, 6, 7], [7, 6, 6,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 7 7 6 6 6
6 6 7 6 6 7 6
7 6 6 6 6 6 7
7 6 6 6 7 7 7
6 6 7 6 6 6 6
7 7 6 7 6 7 6
6 6 1 1 6 7 6
6 6 7 6 6 7 1
7 6 6 6 6 6 6
1 6 7 6 6 7 6
6 7 6 7 6 6 6
6 6 6 7 6 7 7
7 7 6 7 7 7 6
6 6 7 7 6 6 6
6 6 6 6 7 7 6
6 6 6 7 7 6 7
``` | 3,818 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 4,506 | [
"<note1>\n<description>Look for a single, compact object in the input that is treated differently from the rest of the grid. This object is usually the minority color and appears as a small connected cluster; it is the anchor for the transformation.</description>\n<example>Imagine a mostly blue grid with a single r... | [{"input": [[5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 5], [5, 5, 5, 5, 2, 5, 5, 5, 5, 2, 5, 5], [5, 5, 2, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 2, 5, 5]], "output": [[5, 5, 5, 1, 1, 1, 5, 5, 1, 1, 1, 1], [5, 1, 1, 1, 1, 1, 5, 5, 1, 1, 1, 1], [5, 1, 1, 1, 1, 1, 5, 5, 1, 1, 1, 5], [5, 1, 1, 1, 5, 5, 5, 5, 1, 1,... | [{"input": [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 7, 7, 7, 7, 7, 7, 7, 6], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
7 7 7 7 7 7 7 1 1 1 7 7 7 7 7 7 7 1 1 1 7
7 7 7 7 7 7 7 1 1 1 7 7 7 7 7 7 7 1 1 1 7
7 7 7 7 7 7 7 1 1 1 7 1 1 1 7 7 7 7 7 1 1
7 7 7 7 7 7 7 7 7 7 7 1 1 1 7 7 7 7 7 1 1
7 7 7 7 7 7 7 7 7 7 7 1 1 1 7 7 7 1 1 1 1
7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 7
7 7 7 7 7 7 7 7 7 7 7 7 7 7 1 1 1 1 1 1 7
7 7 7 7 7 7 7 7 7 7 7 ... | 3,802 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,836 | [
"<note1>\n<description>Isolate the object: find the contiguous non-background region and compute its minimal bounding box. Working with that box (height H, width W) lets you reason about how the object may be copied or tiled into the whole grid.</description>\n<example>Imagine a small 2×3 colored block on a black b... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]], "output": [[6, 6, 6, 2, 2, 6, 6, 6], [6, 6, 6, 2, 2, 6, 6, 6], [6, 6, 6, 2, 2, 6, 6, 6], [2, 2, 2, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[6, 6, 6, 2, 2, 2, 6, 6, 6], [6, 6,... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 6 2 2 2 6 6 6
6 6 6 2 2 2 6 6 6
6 6 6 2 2 2 6 6 6
2 2 2 2 2 2 2 2 2
2 2 2 2 2 2 2 2 2
2 2 2 2 2 2 2 2 2
6 6 6 2 2 2 6 6 6
6 6 6 2 2 2 6 6 6
6 6 6 2 2 2 6 6 6
``` | 1,132 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,790 | [
"<note1>\n<description>Look for a single, compact colored object that stands out from the uniform background; that object is usually the target of the transformation. Treat its pixels as a single unit (a mask) rather than individual isolated colors.</description>\n<example>Imagine a grid that is mostly black except... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 2, 4, 1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 6, 6, 4, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 6, 6, 2, 1, 0, 0, 0, 0, 0, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
2 2 2 2 2
2 2 2 2 2
2 2 2 2 2
2 2 2 2 2
2 2 2 2 2
``` | 2,086 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,970 | [
"<note1>\n<description>Look for vertical symmetry: check whether the left half of a row equals the right half when mirrored across the vertical center. This test is applied to every row independently and reveals whether the grid can be reduced by removing the redundant right side.</description>\n<example>Imagine a ... | [{"input": [[9, 3, 3, 3, 9, 5, 3, 3, 3, 3, 3, 3, 9, 0, 0, 8, 3, 5, 3, 3, 8, 7], [0, 9, 8, 8, 9, 3, 3, 2, 0, 3, 3, 0, 2, 3, 3, 8, 8, 3, 3, 3, 3, 3], [0, 3, 2, 3, 3, 3, 0, 3, 3, 9, 3, 3, 3, 8, 3, 0, 0, 3, 9, 3, 9, 3], [2, 9, 3, 9, 3, 3, 2, 3, 3, 3, 3, 3, 2, 3, 8, 9, 3, 0, 8, 3, 3, 3], [3, 3, 0, 2, 3, 3, 2, 3, 3, 2, 0, 0,... | [{"input": [[4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3], [0, 3, 0, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3], [3, 0, 0, 4, 3, 3, 0, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3], [4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3], [0, 3, 0, 3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3], [3, 0, 0, 4, 3, 3, 0, 3, 3, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
4 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 0 3
0 3 0 3 3 3 0 3 3 3 3 3 3 3 0 3 0 3
3 0 0 4 3 3 0 3 3 3 3 3 0 3 3 3 3 3
``` | 3,266 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,586 | [
"<note1>\n<description>Look for a small, contiguous block of non-background pixels that appears in the same place in every input. When that block is a compact square (two-by-two), it is a strong candidate for the transformation's source.</description>\n<example>Imagine a grid where a 2×2 colored square sits in the ... | [{"input": [[6, 6, 0, 0, 0, 0, 9], [6, 6, 0, 0, 0, 0, 5], [0, 0, 0, 0, 0, 0, 8], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 7], [9, 5, 8, 1, 7, 6, 6]], "output": [[6, 6, 0, 0, 0, 0, 9], [6, 6, 0, 0, 0, 0, 5], [0, 0, 2, 0, 0, 0, 8], [0, 0, 0, 2, 0, 0, 1], [0, 0, 0, 0, 2, 0, 7], [9, 5, 8, 1, 7, 6, 6]]}, {"input": [[7, 7, ... | [{"input": [[6, 6, 0, 0, 0, 5], [6, 6, 0, 0, 0, 8], [0, 0, 0, 0, 0, 9], [0, 0, 0, 0, 0, 7], [0, 0, 0, 0, 0, 6], [0, 0, 0, 0, 0, 2], [5, 8, 9, 7, 6, 4]], "output": [[6, 6, 0, 0, 0, 5], [6, 6, 0, 0, 0, 8], [0, 0, 2, 0, 0, 9], [0, 0, 0, 2, 0, 7], [0, 0, 0, 0, 2, 6], [0, 0, 0, 0, 0, 2], [5, 8, 9, 7, 6, 4]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
6 6 0 0 0 5
6 6 0 0 0 8
0 0 2 0 0 9
0 0 0 2 0 7
0 0 0 0 2 6
0 0 0 0 0 2
5 8 9 7 6 4
``` | 882 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 2,890 | [
"<note1>\n<description>Look for a single column or row that is entirely one color and runs across the whole grid; that uniform stripe usually acts as a clear separator. When you find it, treat the grid as two parts on either side and use that stripe as the boundary between the two regions to compare.</description>\... | [{"input": [[8, 0, 8, 8, 0, 8, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 8, 8, 8], [0, 0, 8, 8, 8, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 0, 8, 8, 8], [8, 0, 8, 8, 8, 8, 0, 8, 8, 8, 8, 0, 0, 8, 8, 8, 8, 8, 8, 8, 0], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 8, 8, 8, 8, 8, 8, 8], [8, 0, 8, 8, 8, 8, 8, 8, 0, 8, 8, 8, 8, 8, 8, 8,... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0], [0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0], [0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0], [0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1], [1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0], [1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [0, 0, 0, 0, 0, 0, 0, 0, 0, ... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 0 0 0 0 0 3 0 3 0
0 3 3 3 3 0 0 0 0 3 0
0 0 0 3 0 3 0 3 0 3 0
0 0 3 0 3 3 3 3 0 3 0
0 3 0 3 3 3 3 3 0 3 3
3 0 0 3 0 3 0 0 0 3 0
3 0 3 0 3 3 0 0 3 0 0
``` | 2,186 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,312 | [
"<note1>\n<description>Start by locating the single non-background color in the input and record its color value; this color is the candidate that determines the output. When there is exactly one such color across the whole grid, it usually serves as the key attribute for the transformation.</description>\n<example... | [{"input": [[8, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]], "output": [[8, 8], [8, 8]]}, {"input": [[0, 7, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0,... | [{"input": [[5, 5, 0, 0, 0, 0, 0], [0, 5, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 5, 5], [0, 0, 5, 5], [5, 5, 5, 5], [5, 5, 5, 5]]}] | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 5 5
0 0 5 5
5 5 5 5
5 5 5 5
``` | 608 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 1,672 | [
"<note1>\n<description>Look first for a continuous, uniform stripe that runs across an entire row or an entire column. Such a stripe is usually the structural divider that splits the grid into repeated blocks.</description>\n<example>Imagine a grid where every cell in row 3 is the same color while other rows vary. ... | [{"input": [[6, 1, 6, 6], [9, 1, 9, 9], [6, 1, 6, 6], [6, 1, 6, 6], [2, 1, 2, 2], [6, 1, 6, 6], [6, 1, 6, 6], [6, 1, 6, 6], [1, 1, 1, 1], [6, 1, 6, 6], [1, 1, 1, 1], [6, 1, 6, 6], [4, 1, 4, 4], [6, 1, 6, 6], [6, 1, 6, 6], [1, 1, 1, 1], [6, 1, 6, 6], [6, 1, 6, 6], [6, 1, 6, 6], [6, 1, 6, 6], [0, 1, 0, 0], [6, 1, 6, 6]],... | [{"input": [[3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [5, 5, 5, 5, 2, 5, 5, 2, 5, 5], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3], [4, 4, 4, 4, 2, 4, 4, 2, 4, 4], [3, 3, 3, 3, 2, 3, 3, 2, 3, 3]], "output": [[3, 3, 3... | rearc | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
3 3 3
3 3 3
3 3 3
3 3 3
``` | 968 |
<|im_start|>user
Developer: # ARC HINT GENERATOR
## Role & Goal
You are an expert ARC (Abstraction and Reasoning Corpus) analyst. Your task is to generate a concise, actionable hint for a user who is struggling with an ARC problem. Analyze the problem and its correct solution to produce a single standalone, targeted h... | 3,734 | [
"<note1>\n<description>Look for the single non-background color that forms the objects of interest. When the input has one dominant color against a uniform background, that color is the one the transformation targets; everything else (including the background) is left unchanged.</description>\n<example>Imagine a gr... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 2, 0, 2, 0, 0, 2, 0], [0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0], [0, 0, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, ... | [{"input": [[0, 0, 2, 2, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 2, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0], ... | barc_heavy | You will be given some number of paired example inputs and outputs grids. The outputs were produced by applying a transformation rule to the input grids. In addition to the paired example inputs and outputs, there is also one test input without a known output. The inputs and outputs are each “grids”. A grid is a rectan... | ```
0 0 6 6 0 6 6 0 0 0 0 0 0 0
0 0 6 6 6 6 6 0 0 4 4 0 0 0
0 0 0 0 0 0 0 0 0 4 4 0 0 0
6 6 0 0 0 0 0 0 0 4 4 0 0 0
6 6 0 0 0 0 0 0 0 0 0 0 0 0
6 6 0 0 0 0 0 0 0 0 0 0 0 0
6 6 0 0 0 0 0 0 0 0 6 0 6 0
0 0 0 0 0 0 0 0 0 6 6 6 6 6
0 0 0 0 0 0 6 6 0 0 0 0 0 0
0 0 0 0 0 0 6 6 0 0 0 0 0 0
0 6 6 0 0 0 6 6 0 0 0 0 0 0
6 6 0 0 ... | 3,030 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.