Isolate each occurrence by computing its bounding box (top, bottom, left, right). Treat each bounding box as a separate instance even if two instances touch or overlap in the input.</description>\n<example>If you see two 3×3 blocks in different columns, record each block's min/max row and column indices separately. This gives you the exact coordinates of the motif's center for each instance so you can reason about where to place a marker relative to each one.</example>\n</note2>\n\n<note3>\n<description>For every isolated motif, compute the motif center (the middle of its 3×3 bounding box). The transformation consistently marks a position relative to that center rather than relative to the whole grid or to the motif's edge.</description>\n<example>For a motif whose bounding box spans rows 2–4 and columns 5–7, the center is the cell at row 3, column 6. Use that single center coordinate as the reference point for the next step.</example>\n</note3>\n\n<note4>\n<description>Place the marker at the cell that is one row below and one column to the right of each motif center (i.e., (center_row + 1, center_col + 1)). That marker is a single new color and is placed on the background (it does not overwrite the motif).</description>\n<example>If a motif center is at (3,6), put the marker at (4,7). If two motifs are in different columns, you will get two separate markers at (center_row+1, center_col+1) for each center.</example>\n</note4>\n\n<note5>\n<description>Apply the rule for every detected motif and only add markers on empty background cells; do not alter existing colored pixels. If the computed marker cell already contains another non-background color, decide how to treat that conflict by checking whether the examples ever show such a case.</description>\n<example>Scan the grid for every 3×3 motif, compute the center for each, and place the marker at the predicted cell. If a marker would fall into an already-colored cell in the input, re-check whether the training examples ever encountered that situation—usually the examples avoid collisions so the marker is always on background.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Look for a small, repeated motif: many ARC tasks contain one or more tiny 3×3 patterns that share the same internal arrangement of filled pixels (a hollow square or ring). Recognizing that motif is the first step because the transformation usually targets that motif rather than individual pixels.</description>\\n<example>Imagine a grid where the same three-row pattern appears in three different columns: each 3×3 block has the same hollow square shape. By scanning each 3×3 window you can quickly spot those identical motifs and treat them as the objects of interest.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the motif's bounding box and extract its interior pattern; then compare that interior to the surrounding background to find the motif's center. The center is typically the cell that is not part of the hollow ring and is therefore a natural candidate for modification.</description>\\n<example>For a hollow 3×3 motif, the ring occupies the eight edge cells and the middle cell is the only one that is not part of the ring. Extracting that interior pattern and locating the middle cell makes it easy to see which cell is special.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide how many centers to mark: when several identical motifs exist, the output often marks the centers of every occurrence rather than just one. So the number of centers equals the number of detected motifs.</description>\\n<example>If you detect two identical hollow squares in different columns, you should plan to mark two centers (one for each square). Counting the occurrences gives you the expected number of new cells to change.</example>\\n</note3>\\n\\n<note4>\\n<description>Choose a consistent replacement color for the marked centers and keep the rest of the grid unchanged. The replacement color should be distinct from existing colors so the new marks are unambiguous and follow a consistent rule across examples.</description>\\n<example>When you find several identical hollow motifs, pick a single marker color and set the center of each motif to that color while leaving all other pixels exactly as they were. Using one consistent marker makes the transformation easy to verify.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple heuristics to avoid false positives: require the motif to be exactly 3×3 and to match the same interior pattern across occurrences, and only mark the interior center (not the border). If a candidate region differs in size, orientation, or interior arrangement, do not treat it as a motif.</description>\\n<example>Before marking, confirm each candidate is a 3×3 block with the same ring-and-center pattern as the others; if one candidate is a different shape or has a different interior, skip it. This prevents marking accidental pixels and keeps the rule consistent.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for repeated small objects: many ARC tasks use the same compact motif (same relative pattern of pixels) repeated in different places. Recognizing that motif is the first step because the transformation often targets those repeated objects.</description>\\n<example>Imagine a grid that contains two identical 3×3 stamps scattered in different locations. If the output shows changes only near those stamps, you should treat the stamps as the same object to be compared rather than as separate unrelated shapes.</example>\\n</note1>\\n\\n<note2>\\n<description>Check for a symmetry or pairing rule: repeated objects are frequently arranged symmetrically (mirror or rotate). If two objects match under a rotation or reflection, they are likely paired for a combined operation.</description>\\n<example>For example, two L-shaped motifs might appear as mirror images across a vertical axis; when you rotate one motif by 180° you would get the other. Recognizing that pairing explains why both are treated together.</example>\\n</note2>\\n\\n<note3>\\n<description>Consider a combined geometric operation: sometimes the transformation applies to both objects at once (e.g., a rotation or reflection of one object relative to the other). This produces a new motif that is not present in the input.</description>\\n<example>If one motif is at the top-left and its rotated version would appear at the bottom-right, the output may show the rotated motif placed in the bottom-right. Think “take object A, rotate it by the discovered angle, and place it relative to object B.”</example>\\n</note3>\\n\\n<note4>\\n<description>Identify the marker color: the added object is usually a single, distinct color not used for the repeated motifs. This marker is used to draw the result of the geometric operation so it stands out from the original shapes.</description>\\n<example>If the repeated motifs use colors A and B, the new object introduced in the output is a different color C. Use that color to draw the combined/transformed motif so it is visually separate from the originals.</example>\\n</note4>\\n\\n<note5>\\n<description>Validate placement and orientation: after rotating/reflection, place the marker motif so it occupies the same relative positions around the original objects (e.g., rotated by 180° about the center of a pair). Confirm the marker does not overwrite existing non-background pixels and keeps the same size as the original motif.</description>\\n<example>Suppose two identical stamps are separated by a gap; rotate one stamp by 180° and place it so the gap is filled between them. If the rotated stamp would land on a non-background cell, shift it until it fits and does not overwrite the originals.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for small, identical 3×3 motifs that are repeated across the grid. These motifs are usually compact, symmetric and appear in the same orientation in each example; recognizing them as a single object type is the first key step.</description>\\n<example>Imagine a grid with three 3×3 squares: one in the top-left, one in the top-right, and one in the bottom-right. Each of those squares has the same internal pattern (e.g., a center pixel and the four corner pixels of a different color). Treat each such 3×3 block as one object to analyze rather than as many independent pixels.</example>\\n</note1>\\n\\n<note2>\\n<description>Within each 3×3 object identify the single occupied center cell (the pixel that is not part of the 3×3 motif). The transformation is applied to those centers, not to the surrounding motif pixels.</description>\\n<example>For a 3×3 block that has the center pixel as color A and the corners as color B, mark the center cell (the A) as the target. If you see multiple such blocks, you will have several center cells to consider for the next step.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide which centers to change by comparing their positions relative to the grid edges: the rule targets the centers that lie strictly inside the grid (not on the outermost row or column). In other words, ignore centers that are on the top/bottom or left/right edges and act on the interior ones.</description>\\n<example>If three centers are located at (row 1, col 1), (row 1, col 6) and (row 4, col 4), only the center at (row 4, col 4) is strictly interior and should be targeted by the transformation; the other two are on the border and are left unchanged.</example>\\n</note3>\\n\\n<note4>\\n<description>When you act on a chosen center, recolor it to a single distinct marker color (the same marker for all centers). Do not alter any other cells in the grid—only the selected center pixels are changed.</description>\\n<example>Suppose the selected interior center is color X; replace that cell with a new color Y (different from X and the motif colors). After the change, every other cell in the grid remains exactly as it was.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the rule independently for each 3×3 object and use a consistent tie-breaker if multiple interior centers appear (for example, prefer the center that is not on the outermost row). Always verify that the output preserves all other pixels and only the targeted centers are recolored.</description>\\n<example>If there are two interior centers, recolor both to the marker color. If there were only one interior center, recolor that single center. A common pitfall is to recolor the surrounding motif pixels instead of just the center—double-check you only modify the center cell.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the repeated motif: many ARC tasks place the same small shape multiple times in the grid. When you find the same arrangement of colored pixels repeated, treat that arrangement as the object to analyze rather than as independent noise.</description>\\n<example>Imagine a grid that contains two identical 3×3 blocks, each with the same colored pattern. Instead of treating each block separately, consider them as two instances of the same object so you can compare their positions and orientations.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the blocks' coordinates and orientations: determine whether they are identical in placement (same relative coordinates) or whether one is shifted or rotated. The transformation often depends on how one object differs from the other.</description>\\n<example>If two blocks are identical except one has its top row shifted one cell down and the other is unchanged, note that shift and orientation difference — that relative offset is usually the key to the operation.</example>\\n</note2>\\n\\n<note3>\\n<description>Identify the \\\"anchor\\\" object: in many puzzles one instance of the repeated object is used as a reference (it is not transformed). The other instance is then adjusted relative to that anchor to form the output.</description>\\n<example>Given two identical 3×3 blocks, pick the one that remains in place as the anchor, then compute how the other block must move so it aligns with the anchor (for example, shift it down by one row and left by one column).</example>\\n</note3>\\n\\n<note4>\\n<description>Decide how to mark the alignment: after moving the block to match the anchor, the task often highlights the cells where the moved block overlaps the anchor by drawing a single marker (a new color) on those overlapping cells.</description>\\n<example>If you translate a block down and left until it sits on top of the anchor, then paint the cells that coincide between the translated block and the anchor with a distinct marker color; that painted region is the visible change in the output.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle multiple occurrences and overlaps carefully: if there are more than two instances, align each instance to the anchor and paint overlapping cells; if instances are already in place, you may only need to add the marker where they would overlap. Avoid recoloring the original anchor pixels.</description>\\n<example>When three identical blocks exist, move each block to line up with the anchor and mark the overlapping cells with the marker; if two blocks are already aligned, simply mark their overlapping cells with the marker color rather than altering the anchor.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for small, identical 3×3 motifs that are repeated across the grid. When the same shape appears multiple times, treat each occurrence as an independent unit to analyze rather than as a single object.</description>\\n<example>Imagine a grid with two identical 3×3 blocks: one near the top and one near the bottom. Even though the blocks are the same shape, mark each as a separate motif so you can reason about their positions and relationships independently.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the motifs are arranged with equal spacing and whether their centers lie on the same row or column. Equal spacing and alignment suggest a regular, repeatable pattern (for example, equally spaced rows or columns).</description>\\n<example>If you find three identical blocks whose centers sit on the same row and are separated by the same number of empty cells, that indicates a horizontal repeating pattern rather than random placement.</example>\\n</note2>\\n\\n<note3>\\n<description>Focus on the motif’s interior: many such puzzles use a small hollow or frame-like 3×3 (a ring) rather than a solid block. Identifying that hollow center is the key feature to test for repeats.</description>\\n<example>For instance, a 3×3 with a 1×1 empty center surrounded by the same color is a hollow motif; if you see the same hollow shape in multiple places, those are the motifs you should compare.</example>\\n</note3>\\n\\n<note4>\\n<description>When you detect repeated hollow motifs, place a single marker at the motif’s center (one cell) in each motif. Use a color distinct from the motif color so the markers are unambiguous and do not overwrite the motif.</description>\\n<example>With three hollow 3×3 rings in a row, put one marker at the center of each ring; because the rings are hollow, the center cell is available and the marker will sit clearly inside each ring.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful about orientation and multiple colors: ensure the motif you compare is the same orientation and that you only mark centers of hollow rings. If a color appears in different forms (solid vs hollow) or in different orientations, do not treat them as the same motif.</description>\\n<example>If a color sometimes appears as a solid 3×3 and sometimes as a hollow 3×3, only the hollow ones are the repeating motif to mark; if the hollow rings are rotated, first confirm they are aligned before placing markers.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for small, identical L‑shaped clusters that repeat across the grid; these are the objects the task treats as a unit. Recognize them by a 3×3 bounding box that contains exactly three non-background pixels arranged in an L shape (one corner empty).</description>\\n<example>Imagine a 3×3 block where three pixels form a corner and the opposite corner is empty; that whole 3×3 block is the object. If you find the same pattern in multiple places, treat each 3×3 block as one instance to analyze.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide which axis each object lies on by checking which of its three pixels lies at a corner of the 3×3 box; that corner determines the object's orientation (horizontal or vertical). Orientation tells you where the new marker will be placed relative to the object.</description>\\n<example>If the empty corner is at the top‑right, the L points toward the left and the object is horizontal; if the empty corner is at the bottom‑left, the L points up and the object is vertical. Use that corner consistently when you place the marker.</example>\\n</note2>\\n\\n<note3>\\n<description>For each L‑shaped object, place a single marker in the cell that is one step away from the empty corner along the object's orientation — in other words, the cell that completes the missing corner of the L. The marker is added on an empty (zero) cell adjacent to the object.</description>\\n<example>For a horizontal L with empty top‑right corner, place a marker at the cell immediately below that empty corner (the cell that would complete the L). For a vertical L with empty bottom‑left corner, place the marker immediately to the right of that empty corner.</example>\\n</note3>\\n\\n<note4>\\n<description>Place markers only on cells that are currently background (zeros); do not overwrite any existing colored pixels. If a candidate marker cell is already occupied, the pattern typically does not place a marker there — this is a common constraint in ARC tasks.</description>\\n<example>If the cell you would place the marker into already contains another color, skip it. If it is zero, add the marker so the transformation remains additive and consistent with the examples.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the same rule independently to every detected L‑shaped object and use a single consistent marker color across all placements. The final output keeps the original objects unchanged and simply adds these new single‑pixel markers where they fit.</description>\\n<example>Scan the grid for all L shapes, compute the one‑step completion cell for each, and place the same marker color there for every valid cell. The result is a grid with the original L shapes intact and one marker added per object where applicable.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for repeated small motifs: a compact, identical arrangement of non-zero pixels that appears in multiple places. These motifs are usually small square clusters (often 3×3) and are the structural units the task uses.</description>\\n<example>Imagine a grid where you see three identical L-shaped clusters of colored pixels, each occupying a 3×3 area but in different places. Those repeated 3×3 clusters are the motifs you should focus on rather than isolated pixels.</example>\\n</note1>\\n\\n<note2>\\n<description>Characterize each motif by its bounding box and the relative coordinates of its colored pixels (e.g., the pattern of filled cells inside a 3×3 box). Treat identical relative patterns as the same motif even if they have different colors.</description>\\n<example>If one motif has colored pixels at the top row (left and right cells) and the middle row (left and right cells) while the bottom row is empty, that relative pattern is an L-shape. If another motif shows the same relative pattern but with a different color, it is the same motif type.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide whether the task asks you to preserve original motifs or to produce a canonical version: sometimes outputs keep original colors and only add markers; sometimes outputs replace original pixels with a single canonical color and place markers elsewhere. Check which behavior is consistent across examples.</description>\\n<example>For instance, if the input has two different colored L-shapes and the output still shows those two L-shapes but in different colors, the rule is “preserve originals and add markers.” If instead the output shows one color for every L-shape and new markers, the rule is “replace originals with a canonical color and add markers.”</example>\\n</note3>\\n\\n<note4>\\n<description>Find the marker placement rule: many tasks add a single marker at the motif’s center or at a fixed offset from the bounding box (for example, the cell immediately below the bounding box). Determine which fixed position is used across examples and apply it consistently.</description>\\n<example>If every training output has a marker in the same relative spot (e.g., the cell directly beneath the 3×3 motif), then for each motif in the test grid you should place a marker at that same relative position, using the same marker color.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle overlaps and edge cases carefully: if the marker position would fall outside the grid, skip it; if two motifs would require markers in the same cell, check examples to see whether markers are stacked or only one is kept. Also ensure you do not change the original motif pixels unless the examples explicitly show replacements.</description>\\n<example>If a motif’s marker spot lies outside the grid boundaries, simply do not place a marker there. If two motifs both map to the same cell, inspect the training pairs to see whether that cell is overwritten or left unchanged, and follow that same behavior.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a repeating local pattern: a small motif (often a 3×3 block) that appears multiple times across the grid. When such motifs are identical, the transformation is usually applied to each occurrence rather than to the whole grid.</description>\\n<example>Imagine a 3×3 blue motif at (row 1–3, col 1–3) and another identical 3×3 blue motif at (row 4–6, col 4–6). Treat those two 3×3 blue blocks as two separate instances of the same local pattern to be analyzed.</example>\\n</note1>\\n\\n<note2>\\n<description>Check which motif is being used as the template. The template is typically the first instance you encounter when scanning the grid (left-to-right, top-to-bottom). The rest of the grid is compared against that template.</description>\\n<example>Given two identical 3×3 red blocks, the one you find first (say the top-left) is the template; subsequent matching blocks are compared to that top-left block rather than to each other.</example>\\n</note2>\\n\\n<note3>\\n<description>Match occurrences by shape and position: for each candidate motif, check that it has the same bounding-box size and that its non-background pixels fall in the same relative coordinates inside that box. Exact alignment of those pixels is required for a match.</description>\\n<example>If the template is a 3×3 with holes in the center and two corners, a candidate is a match only when the candidate 3×3 also has holes in the same two corners and the same color pattern; partial matches (same shape but different color or shifted) are not valid.</example>\\n</note3>\\n\\n<note4>\\n<description>When a matching motif is found, mark the template’s center cell with a distinct marker color in the corresponding location. The marker is placed at the same relative center of each matching motif, not at a fixed absolute grid cell.</description>\\n<example>For a 3×3 template whose center is at (r,c), place the marker at (r,c) of every matching 3×3 block. If the template center is at row 2, column 5, then every matching block’s center at row 2, column 5 should receive the marker.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle edge cases: ignore motifs that are shifted, rotated, or partially occluded; if a motif is split by a border, treat it as a single object only when the whole motif fits. Also ensure you do not overwrite original non-background pixels.</description>\\n<example>If a 3×3 motif is only partly on the grid, do not treat it as two motifs; if a candidate differs by a single pixel or is rotated, it is not a match and should not be marked. If multiple candidates exist, mark each candidate center with the marker but do not alter the original motif pixels.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a small, repeated object that appears in every example: a compact cluster of one color that forms a symmetric 3×3-like motif (often with a center of that color and a ring of that color). This object is the trigger for the transformation.</description>\\n<example>Imagine a grid that contains the same 3×3 arrangement of color A several times at different places; each arrangement has A in the middle and in the four cardinal neighbors, producing a small symmetric block. Spotting that repeated 3×3-like block is the first step to understanding the rule.</example>\\n</note1>\\n\\n<note2>\\n<description>Inside each identified block, note the empty cell that sits exactly in the geometric center of the 3×3 (i.e., the cell not occupied by the block's color). That center is the location where a marker will be placed.</description>\\n<example>For a 3×3 block whose outer ring is color A and the center is empty, the center cell is the natural place to put a new pixel. If there are multiple such blocks, each will have its own center cell to consider.</example>\\n</note2>\\n\\n<note3>\\n<description>The transformation adds a single marker color at each block’s center; the marker is distinct from the block color and is placed on the background (zeros). Do not change any other pixels—only the empty centers are filled.</description>\\n<example>If color A forms several symmetric blocks, convert each block’s empty center to a new color B while leaving all A pixels and the rest of the grid unchanged. This keeps the original objects intact and simply highlights their centers.</example>\\n</note3>\\n\\n<note4>\\n<description>Handle multiple blocks independently: every block that matches the 3×3-like pattern yields one center marker. The same marker color is used for all centers across the grid.</description>\\n<example>When two different colors each form such blocks, you will place the same marker color at each of those centers; if a block is broken (center occupied or not symmetric), do not add a marker for that block.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple checks to avoid false positives: confirm the block is symmetric (the same color occupies the four cardinal neighbors and the center is empty), and ensure the marker is added only on background cells. If the center is already occupied by a different color, do not place the marker there.</description>\\n<example>Before marking, scan the 3×3 neighborhood around each candidate center: if the four adjacent cells are the same color and the center is empty, mark it. If the center is already non-empty or the pattern is asymmetric, skip it.</example>\\n</note5>\",\n \"<note1>\\n<description>Scan the grid for small, identical 3×3 patterns that repeat in a regular way (often separated by whole columns). These patterns are the objects the task usually acts on; identifying their bounding boxes (top, left, width, height) is the first step.</description>\\n<example>Imagine a grid where you see the same L-shaped 3×3 block at columns 0–2 and again at columns 6–8, each occupying rows 2–4. Treat each 3×3 box as one object and record its column index and top-left coordinates so you can compare them.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the column indices of the bounding boxes and measure the horizontal gaps between them. The transformation often uses a fixed spacing (for example, a constant gap between the left and middle object, and a different constant gap between the middle and right object).</description>\\n<example>If the left box starts at column 0, the middle at column 4, and the right at column 8, the gaps are 4 and 4 respectively; if instead the middle were at column 5, the gaps would be 5 and 3. Noting which gap is larger or smaller helps decide where to place additional markers.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide which gap is the “smaller” one (the one that doesn’t match the repeated spacing) and use that gap’s midpoint to place a marker. If the middle gap is smaller than the left-to-middle gap, place a marker at the middle gap’s midpoint; if the left-to-middle gap is smaller, place markers at both midpoints.</description>\\n<example>With boxes at columns 0, 4 and 8 the left-to-middle gap is 4 and the middle-to-right gap is 4, so there is no smaller gap and no marker is placed. With boxes at columns 0, 5 and 8 the left-to-middle gap is 5 and the middle-to-right gap is 3, so place a marker at column 6 (the midpoint of the 3-column gap).</example>\\n</note3>\\n\\n<note4>\\n<description>Place the marker at the exact midpoint column (use the center column of the gap, not the center of a 3×3 box). If the gap length is odd, the center is a single integer column; if it is even, the midpoint may fall between two integer columns—choose the column that is consistent with the examples (often the left-center of the gap).</description>\\n<example>For a 3-column gap between columns 5 and 8 the midpoint is column 6; for a 4-column gap between columns 3 and 7 the midpoint is column 5. Always pick the same rule for even gaps so your placements align with the pattern shown in examples.</example>\\n</note4>\\n\\n<note5>\\n<description>Use a single distinct color for the marker (a color not used by the repeated objects) and place it only in the empty cells (zeros) of the grid. If multiple midpoints are needed, place markers at those columns in the same column of the grid (or as the examples show), and do not overwrite any object pixels.</description>\\n<example>If you determine two midpoints, color those two empty cells with the marker color in the same row(s) where the objects lie; if only one midpoint is required, color that single empty cell. A common pitfall is placing the marker inside an object or using the same color as the objects—avoid both.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for small, identical 3×3 motifs composed of a single non-background color and a single empty center. These are compact objects whose shape is consistent across examples and are the most likely candidates for the transformation.</description>\\n<example>Imagine a 5×5 grid where a 3×3 block appears with one center cell empty and the eight surrounding cells are the same color. That whole 3×3 arrangement is a motif to isolate and examine further.</example>\\n</note1>\\n\\n<note2>\\n<description>Identify the object color by checking that the same color fills the eight surrounding cells of a 3×3 block and that the center is background. The object color is the one that repeats in a symmetric 8-cell ring around a center.</description>\\n<example>If a block has eight blue cells arranged in a ring and a single empty center, treat blue as the object color; do not confuse that with a different color that appears elsewhere in the grid.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide whether to act on every occurrence of that motif or only on a particular one. In these tasks the rule is consistent across examples: apply the same operation to each identified motif.</description>\\n<example>If you find two identical 3×3 blue rings in different parts of the grid, perform the same transformation on both rather than choosing one arbitrarily.</example>\\n</note3>\\n\\n<note4>\\n<description>When transforming, add a single marker in the center cell of each 3×3 motif while leaving the surrounding ring and the rest of the grid unchanged. The marker is a distinct color that does not conflict with existing non-background colors.</description>\\n<example>Take a 3×3 blue ring with an empty center and fill that center with a new color (e.g., green) so the motif becomes a filled 3×3 block of that new color, keeping the blue ring intact.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple checks to avoid false positives: require the motif to be a perfect 3×3 ring, not an irregular patch; the center must be background before filling; and if a center already contains a color, do not overwrite it.</description>\\n<example>If a nearby area has a different shape (an L or a broken ring), do not treat it as a 3×3 motif. If a center cell is already non-background, leave it as is rather than replacing it.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a small, compact non-background motif: many tasks use a repeated 3×3 pattern where the center is background and the eight surrounding cells form a continuous border. This motif is distinctive because it occupies exactly one 3×3 block and has a hole at the center.</description>\\n<example>Imagine a 5×5 grid where a 3×3 block has the center cell empty and the eight edge cells are the same color; that 3×3 region is the motif. If you see the same arrangement repeated elsewhere, treat each occurrence as an independent instance of the motif.</example>\\n</note1>\\n\\n<note2>\\n<description>Count how many such 3×3 motifs appear in the grid. The transformation often depends on the total number of complete motifs, not on their colors or positions.</description>\\n<example>If you find two separate 3×3 blocks (one in the top-left and one in the bottom-right) that both match the \\\"border with center hole\\\" pattern, then the count is 2. That numeric count is what the rule will use to decide how many marks to place.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide where to place the marks: choose a single, consistent anchor cell (often the top-left corner) and extend a straight line (horizontal, vertical, or diagonal) from that anchor toward the grid edge. The direction is chosen so that the line passes through the grid center and the line length is proportional to the motif count.</description>\\n<example>For example, if the count is 2, you might extend a horizontal line of length 2 from the top-left corner; if the count is 3, extend a horizontal line of length 3, and so on. Keep the same anchor and direction for every occurrence so the placement is predictable.</example>\\n</note3>\\n\\n<note4>\\n<description>Use a single new color to draw the marks and place exactly one mark per unit of the chosen length. Do not overwrite any existing non-background pixels — only place marks on background cells along the selected line.</description>\\n<example>If the motif count is 4, place four marks along the chosen line using a color not used by the motif colors. If the line would pass through a cell that already contains a non-background pixel, skip that cell and continue the line until you have placed the required number of marks.</example>\\n</note4>\\n\\n<note5>\\n<description>Validate your rule across all training examples: the same motif-count → line-length mapping and the same anchor/direction should reproduce each example. If any example fails, reconsider whether the motif is exactly the 3×3 border-with-hole pattern or whether a different anchor/direction is implied.</description>\\n<example>Apply your inferred rule to each training pair: count the 3×3 motifs, determine the anchor and direction, and draw a line of that length with the new color. If one example does not match, re-check for alternative motif shapes or a different consistent anchor/direction that would explain all examples.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for small, identical square motifs: a compact 3×3 block whose top-left cell is empty (background) and whose other eight cells are all the same non-background color. These empty corners are the anchors that the transformation uses. Recognizing this motif is the first step because it signals a local completion rule.</description>\\n<example>Imagine a 3×3 area where the nine cells are [0, A, A; A, A, A; A, A, 0]. That pattern is a 3×3 motif with A at the eight surrounding cells and 0 at the top-left corner. Spotting such a motif is easy because it has exactly one empty corner and eight identical neighbors.</example>\\n</note1>\\n\\n<note2>\\n<description>Find the motif’s center: the single cell that is not part of the surrounding eight. That center cell is the one that will be changed in the output. The center is always the same relative position inside the 3×3 bounding box (not the empty corner or the outer border cells).</description>\\n<example>In the 3×3 example above, the center cell is the one with value A in the middle row and middle column; it is distinct from the top-left zero. The transformation will target that center cell rather than any corner or border cell of the motif.</example>\\n</note2>\\n\\n<note3>\\n<description>Replace the center with a single distinct marker color (the same marker appears each time). This marker is not part of the original motif color and is used to indicate completion. Using one consistent marker makes the change unambiguous across examples.</description>\\n<example>For a motif whose surrounding cells are all A, change the center to a single marker color M so the 3×3 becomes [0, A, A; A, M, A; A, A, 0]. The marker M is different from A and is applied consistently wherever the motif appears.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the rule independently to every 3×3 motif present in the grid. If there are multiple motifs, perform the same center-marking for each one. The operation is local and does not alter other unrelated pixels.</description>\\n<example>If two identical 3×3 motifs appear at different places, mark the center of each with the same marker color. The result is two marked centers while the surrounding A cells remain unchanged in each motif.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful with edge cases: ensure the motif fits entirely inside the grid (no partial 3×3 at the border), and do not confuse this with other symmetric patterns (e.g., full filled squares or other corner configurations). Only the specific “empty corner + eight identical neighbors” pattern should trigger the center-marking. Also confirm the marker color is not already used by the motif so it stands out.</description>\\n<example>Do not try to mark a center when the motif would extend beyond the grid or when the surrounding cells are not all identical. If a candidate 3×3 has a different color or missing neighbors, leave it alone—only the exact motif pattern should be completed.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for small, identical square motifs (often 3×3) that repeat across the grid. These motifs are usually made of one non-background color and are the primary objects the transformation targets.</description>\\n<example>Imagine a grid with three separate 3×3 squares, each colored differently; those three 3×3 blocks are the motifs you should focus on rather than isolated single pixels. Spotting them first narrows the problem to a small set of consistent objects.</example>\\n</note1>\\n\\n<note2>\\n<description>Each motif is characterized by a central cell that is background (0) while the eight surrounding cells are the motif's color. That central zero is the only empty cell inside the 3×3 pattern.</description>\\n<example>For a 3×3 red motif, the middle cell is 0 and the eight neighbors are red; recognizing that pattern (color on the ring, 0 at the center) lets you identify every motif in the grid.</example>\\n</note2>\\n\\n<note3>\\n<description>When you find such a motif, the transformation fills the motif's central cell with a single, uniform marker color (the same marker for every motif). Do not change the surrounding motif pixels or other unrelated areas.</description>\\n<example>If the motif color is blue and the marker color is yellow, the rule is: keep the blue ring as it is and set the center cell to yellow. The marker is applied only to the center(s) of the detected motifs.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the marker independently for every detected motif, producing one marker cell per motif. The marker cells are placed at the geometric centers of the original 3×3 motifs, not shifted or merged.</description>\\n<example>If there are four distinct 3×3 motifs in different places, you will end up with four marker cells — one centered on each original 3×3 block — rather than combining or overlapping them.</example>\\n</note4>\\n\\n<note5>\\n<description>Before finalizing, verify that each motif is a complete 3×3 and that the center is truly background; ignore partial shapes or other colors that do not match the motif pattern. This prevents accidental marking of non-motif cells.</description>\\n<example>If a shape looks like a 3×3 but has a different center color or missing corners, treat it as not a motif and do not mark it. Confirming these properties keeps the transformation consistent and unambiguous.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a repeated local motif: a small block of cells where a color appears in a distinctive arrangement (for example, three pixels in a row with the middle cell empty). Such motifs are often the element the task expects you to detect and act on.</description>\\n<example>Imagine a grid where the same three‑pixel pattern occurs three times but in different places. Spotting that repeated arrangement is the first step—once you see it, treat each occurrence as an object to consider rather than as isolated noise.</example>\\n</note1>\\n\\n<note2>\\n<description>Identify the motif’s bounding box and its vertical span: record the top and bottom row indices that contain the motif so you can reason about alignment across multiple instances. The vertical span is the key property used to decide where to add new elements.</description>\\n<example>If three motifs appear in rows 0–2, 3–5 and 6–8, their vertical spans are 3 rows each; note that span length so you can compare how many rows each motif occupies and whether they share the same span.</example>\\n</note2>\\n\\n<note3>\\n<description>Use the motif’s vertical span to place a marker: in the rows that lie outside the motif’s span (specifically the row immediately below the motif’s bottom row), place a marker cell. This places the marker consistently relative to each motif’s vertical position.</description>\\n<example>For a motif occupying rows 0–2, place the marker in row 3; for a motif occupying rows 3–5, place the marker in row 6. In general: marker_row = motif_bottom_row + 1.</example>\\n</note3>\\n\\n<note4>\\n<description>Place markers only in empty (zero) cells and use a single distinct color for all markers so they are visually unambiguous. Do not overwrite any existing non-zero pixels when adding the marker.</description>\\n<example>If a motif is at the top, put the marker in an empty cell just below it; if a motif is in the middle, put the marker below its bottom row in an empty cell. Using the same marker color for every placement keeps the result consistent.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle multiple motifs independently and check for overlaps: apply the same “bottom-row+1” rule to every motif, and if two markers would fall in the same cell, verify the examples to see whether the task expects one or both. Always ensure the placement stays inside the grid.</description>\\n<example>When two motifs are separated by empty rows, you will add one marker per motif at their respective bottom+1 positions; if the examples show only one marker per motif, prefer placing one marker per motif and avoid overwriting existing colored cells.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the motif: a compact, multi-pixel shape that repeats across examples (often a 3×3 pattern with a single center cell). The motif is usually a single color and is visually distinct from the background and other colors.</description>\\n<example>Imagine a grid that contains several small 3×3 blocks of the same color; each block has a center cell and eight surrounding cells. Recognizing that repeated 3×3 block as the motif is the first step because the transformation targets that shape specifically.</example>\\n</note1>\\n\\n<note2>\\n<description>Isolate each occurrence by computing its bounding box (top, bottom, left, right). Treat each bounding box as a separate instance even if two instances touch or overlap in the input.</description>\\n<example>If you see two 3×3 blocks in different columns, record each block's min/max row and column indices separately. This gives you the exact coordinates of the motif's center for each instance so you can reason about where to place a marker relative to each one.</example>\\n</note2>\\n\\n<note3>\\n<description>For every isolated motif, compute the motif center (the middle of its 3×3 bounding box). The transformation consistently marks a position relative to that center rather than relative to the whole grid or to the motif's edge.</description>\\n<example>For a motif whose bounding box spans rows 2–4 and columns 5–7, the center is the cell at row 3, column 6. Use that single center coordinate as the reference point for the next step.</example>\\n</note3>\\n\\n<note4>\\n<description>Place the marker at the cell that is one row below and one column to the right of each motif center (i.e., (center_row + 1, center_col + 1)). That marker is a single new color and is placed on the background (it does not overwrite the motif).</description>\\n<example>If a motif center is at (3,6), put the marker at (4,7). If two motifs are in different columns, you will get two separate markers at (center_row+1, center_col+1) for each center.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the rule for every detected motif and only add markers on empty background cells; do not alter existing colored pixels. If the computed marker cell already contains another non-background color, decide how to treat that conflict by checking whether the examples ever show such a case.</description>\\n<example>Scan the grid for every 3×3 motif, compute the center for each, and place the marker at the predicted cell. If a marker would fall into an already-colored cell in the input, re-check whether the training examples ever encountered that situation—usually the examples avoid collisions so the marker is always on background.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[0, 6, 6, 6, 0, 0, 0, 0], [0, 6, 0, 6, 0, 0, 0, 0], [0, 0, 0, 0, 0, 6, 6, 6], [0, 0, 0, 0, 0, 6, 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\": [[0, 6, 6, 6, 0, 0, 0, 0], [0, 6, 0, 6, 0, 0, 0, 0], [0, 0, 0, 0, 0, 6, 6, 6], [0, 0, 0, 0, 0, 6, 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, 4, 0, 0, 0, 4, 0]]}, {\"input\": [[0, 3, 3, 3, 0], [0, 3, 0, 3, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]], \"output\": [[0, 3, 3, 3, 0], [0, 3, 0, 3, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 4, 0, 0]]}, {\"input\": [[0, 0, 0, 0, 0, 0, 0], [0, 8, 8, 8, 0, 0, 0], [0, 8, 0, 8, 6, 6, 6], [0, 0, 0, 0, 6, 0, 6], [0, 0, 0, 0, 0, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 0], [0, 8, 8, 8, 0, 0, 0], [0, 8, 0, 8, 6, 6, 6], [0, 0, 0, 0, 6, 0, 6], [0, 0, 4, 0, 0, 4, 0]]}]"},"test":{"kind":"string","value":"[{\"input\": [[0, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0], [0, 5, 0, 5, 0, 8, 8, 8, 0, 0, 0], [0, 0, 0, 0, 0, 8, 0, 8, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 3, 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]], \"output\": [[0, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0], [0, 5, 0, 5, 0, 8, 8, 8, 0, 0, 0], [0, 0, 0, 0, 0, 8, 0, 8, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 3, 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, 4, 0, 0, 0, 4, 0, 0, 4, 0]]}]"},"source":{"kind":"string","value":"arc 1"},"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 6 6 6 0 0 0 0\n0 6 0 6 0 0 0 0\n0 0 0 0 0 6 6 6\n0 0 0 0 0 6 0 6\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 6 6 6 0 0 0 0\n0 6 0 6 0 0 0 0\n0 0 0 0 0 6 6 6\n0 0 0 0 0 6 0 6\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 4 0 0 0 4 0\n```\n\n## Example 2\nInput:\n```\n0 3 3 3 0\n0 3 0 3 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 0 0 0\n```\n\nOutput:\n```\n0 3 3 3 0\n0 3 0 3 0\n0 0 0 0 0\n0 0 0 0 0\n0 0 4 0 0\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0\n0 8 8 8 0 0 0\n0 8 0 8 6 6 6\n0 0 0 0 6 0 6\n0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0\n0 8 8 8 0 0 0\n0 8 0 8 6 6 6\n0 0 0 0 6 0 6\n0 0 4 0 0 4 0\n```\n\n# Test Problem:\n```\n0 5 5 5 0 0 0 0 0 0 0\n0 5 0 5 0 8 8 8 0 0 0\n0 0 0 0 0 8 0 8 3 3 3\n0 0 0 0 0 0 0 0 3 0 3\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n```"},"answer":{"kind":"string","value":"```\n0 5 5 5 0 0 0 0 0 0 0\n0 5 0 5 0 8 8 8 0 0 0\n0 0 0 0 0 8 0 8 3 3 3\n0 0 0 0 0 0 0 0 3 0 3\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 4 0 0 0 4 0 0 4 0\n```"},"num_tokens":{"kind":"number","value":916,"string":"916"}}},{"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```\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n6 1 0 6 0 0 6 5 5\n```\n\nOutput:\n```\n5 0 0 0 0 0 0 0 6\n0 0 0 0 0 0 0 0 0\n6 5 5 0 0 0 6 1 0\n0 0 0 0 0 0 0 0 0\n0 0 6 5 5 1 0 6 0\n0 0 0 0 0 0 0 0 0\n0 6 6 1 6 5 5 0 6\n0 0 0 0 0 0 0 0 0\n6 1 0 6 0 0 6 5 5\n```\n\n## Example 2\nInput:\n```\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n3 1 4 9 2 3 1 1 3 5 0 7 5\n```\n\nOutput:\n```\n5 0 0 0 0 0 0 0 0 0 0 0 3\n0 0 0 0 0 0 0 0 0 0 0 0 0\n0 7 5 0 0 0 0 0 0 0 3 1 4\n0 0 0 0 0 0 0 0 0 0 0 0 0\n3 5 0 7 5 0 0 0 3 1 4 9 2\n0 0 0 0 0 0 0 0 0 0 0 0 0\n1 1 3 5 0 7 5 1 4 9 2 3 1\n0 0 0 0 0 0 0 0 0 0 0 0 0\n2 3 1 1 3 5 4 7 5 3 1 1 3\n0 0 0 0 0 0 0 0 0 0 0 0 0\n4 9 2 3 1 1 3 5 1 7 5 5 0\n0 0 0 0 0 0 0 0 0 0 0 0 0\n3 1 4 9 2 3 1 1 3 5 0 7 5\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 5 0 0 3 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 3 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n5 0 0 3 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 5 0 0 3 0 0 0 0 5\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 5 0 0 3 5 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 5 0 0 3 0\n```\n\n# Test Problem:\n```\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\n1 7 6 3 9 0 0\n```\n\n---\n\n\n# Generated Hint<|im_end|>\n<|im_start|>assistant\n"},"abstraction_prompt_length":{"kind":"number","value":2552,"string":"2,552"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>Look for a single horizontal band that contains all non-black pixels: many ARC tasks use a bottom row (or a contiguous horizontal stripe) as the source pattern. Isolating that band simplifies the rest of the transformation because the rest of the grid is treated as background.</description>\n<example>Imagine a grid whose only colored pixels are on the last row: treat that row as the source pattern and ignore the empty rows above. You will then only need to reason about how that one-row pattern is copied or transformed into the upper rows, rather than worrying about many scattered pixels.</example>\n</note1>\n\n<note2>\n<description>Compare the source row with the nearest non-empty row above it to find the horizontal offset: the output copies the source row but shifted left by a fixed amount (the number of empty columns between the source and that nearest non-empty row). This offset is the same for every row above the source.</description>\n<example>For instance, if the source row sits two columns above the nearest filled row, then every upper row will show the source pattern shifted two columns to the left. That consistent shift tells you how much to move the pattern for each level.</example>\n</note2>\n\n<note3>\n<description>Apply the same shifted copy repeatedly upward until the top of the grid is reached. Each successive row is the previous row's shifted copy (with the same leftward shift), producing a stepped, stair-like arrangement of the source pattern.</description>\n<example>Starting from the source row, copy it shifted by the offset to the row above, then copy that shifted row again shifted the same amount to the next row, and so on. This creates a sequence of identical rows but each one further to the left than the one before.</example>\n</note3>\n\n<note4>\n<description>Preserve the original colors and relative order of the source row when copying; do not recolor or reorder pixels. The transformation is a translation of the source row (and its copies), not a rotation or reflection.</description>\n<example>If the source row reads [A, B, C, D, E] from left to right, every copied row should also read [A, B, C, D, E] in the same order, just placed at the shifted horizontal position. This keeps the pattern recognizable across all rows.</example>\n</note4>\n\n<note5>\n<description>Handle truncated copies at the grid edges and decide how to treat the source row itself: copies that would extend beyond the right edge are clipped; the source row itself may be left in place or duplicated. Use the examples to infer which behavior is intended (e.g., whether the original row is also included in the stepped copies).</description>\n<example>If a shifted copy would write past the rightmost column, only the visible portion appears on the grid. If the source row is not included in the upward copies, you will see a single original row plus the stepped copies above it; if it is included, you will see an extra copy at the very top.</example>\n</note5>","<note1>\n<description>Look for a single horizontal row that contains every non-background color; this row acts as the source of all colored information. When that row is unique and spans the full width, it is the natural place to start any transformation because every colored pixel in the output can be traced back to it.</description>\n<example>Imagine a grid where only the bottom row has colored pixels and every other row is background. Treat that bottom row as the source: the output will contain colored pixels that are derived from those bottom-row values, while other rows remain mostly background.</example>\n</note1>\n\n<note2>\n<description>Work column-by-column: each column’s colored pixels form a vertical sequence that repeats in a consistent way. Recognize that the same sequence of colors appears in multiple columns at different offsets rather than as independent isolated pixels.</description>\n<example>For instance, if a particular column shows [A,B,C] from top to bottom, you should expect to see A,B,C appearing in other columns but shifted downward by the same rule (not in arbitrary positions).</example>\n</note2>\n\n<note3>\n<description>Observe the vertical step size: colored pixels appear every k rows (k is constant across columns). In these examples k is two (a step of two rows), so the pattern is “every second row.” This regular step explains why the colored pixels form a repeated staircase rather than a random placement.</description>\n<example>With k=2, a sequence in one column will show up in the same relative positions in neighboring columns two rows lower; if you find two colored pixels in a column, the next column’s colored pixels will be in the same columns but two rows down.</example>\n</note3>\n\n<note4>\n<description>Reconstruct the sequence by moving left-to-right: copy the source row’s colored pixels into the first column, then shift the sequence two rows down and repeat for the next column, continuing until the right edge. This preserves the left-to-right order of the source row while creating the stepped repetition.</description>\n<example>Take a source row [x,y,z] (left to right). Place x,y,z into column 1; place x,y,z into column 2 but two rows lower; place x,y,z into column 3 two rows lower than that, and so on, until you reach the rightmost column.</example>\n</note4>\n\n<note5>\n<description>Watch for edge cases and consistency: the rightmost column may be truncated (the last copy placed may extend past the grid), and every column must use the same sequence and step. Verify the same step and ordering across all columns to avoid misaligning the pattern.</description>\n<example>If the source row is [a,b,c,d] and the grid has few columns, you may not be able to place all four values in every column (the last copy will be clipped). Also ensure every column uses the same two-row step and the same left-to-right ordering—any deviation indicates an incorrect placement.</example>\n</note5>","<note1>\n<description>Look for the single row that contains non-black pixels; that row is the source pattern for the whole transformation. Treat that row as a sequence of colored tokens (ignore zeros inside it) and use their left-to-right order when you reason about placement.</description>\n<example>Imagine a grid whose only colored row is [A B C 0 D]. Consider the tokens [A,B,C,D] in that order rather than individual cells. Everything you place later should be based on that sequence, not on scattered isolated pixels elsewhere.</example>\n</note1>\n\n<note2>\n<description>Decide the target offset by measuring how far the pattern sits from the right edge. The target is the column index equal to the number of columns minus the source row’s column index; this gives a fixed horizontal placement for the first copy.</description>\n<example>If the pattern is at the bottom and the grid has 9 columns while the pattern’s first colored cell is at column 4, the target column is 9 - 4 = 5. Place the first copy so its leftmost colored cell is at column 5.</example>\n</note2>\n\n<note3>\n<description>Place the source row into the chosen target column but keep its vertical order intact. Do not rotate or flip the sequence — copy it exactly as it appears in the source row, starting at the target column.</description>\n<example>For a source row [X Y Z] and target column 5, put X at (row,5), Y at (row+1,5), Z at (row+2,5). The relative order (X then Y then Z) must remain unchanged.</example>\n</note3>\n\n<note4>\n<description>Recreate the pattern for each row above the source using the same column offset but shifted upward by one row each time. This produces a stepped diagonal of repeated copies that move one column to the right as they go up.</description>\n<example>If the source is at the bottom, create a copy at the row above with the same offset, then another at the row above that with the same offset, and so on. Each successive copy is placed one row higher and one column to the right, preserving the sequence order.</example>\n</note4>\n\n<note5>\n<description>Handle overlaps and edge cases by copying only where the target cell is black; when a target cell is already non-black, the copy’s cell should overwrite it. This keeps the final pattern consistent even if copies would collide.</description>\n<example>If two copies would write to the same cell, the later (higher) copy overwrites the earlier one. If the target column is outside the grid, do not attempt to place a copy there — only place copies where the target cell is within bounds.</example>\n</note5>","<note1>\n<description>Look for a single horizontal row that contains all the non-background pixels; that row is the “seed” for the transformation. When only one row carries color, treat that entire row as the template to be copied and shifted rather than as isolated pixels.</description>\n<example>Imagine a 6×6 grid where every colored pixel lies in the bottom row [A B C]. That bottom row is your seed: it is the only source of color you will copy and move elsewhere in the grid.</example>\n</note1>\n\n<note2>\n<description>Decide the vertical spacing between copies by counting how many rows lie between the seed and the nearest filled row in the outputs. Use that same step size for all copies so the pattern repeats regularly.</description>\n<example>If the seed is at the bottom and the nearest filled row above it in the output is two rows away, then copies will appear at the seed, two rows up, four rows up, and so on—consistent step size is key.</example>\n</note2>\n\n<note3>\n<description>Horizontal placement is a cyclic shift: the seed’s rightmost element becomes the leftmost in the next copy, the next-right element becomes the next-left, and so on. This preserves the left-to-right order but wraps it around the row.</description>\n<example>For a seed [X Y Z], the next copy will be [Z X Y] (rightmost → leftmost), the next [Y Z X], etc. Each successive copy is a one-step cyclic rotation of the seed.</example>\n</note3>\n\n<note4>\n<description>Apply the same cyclic shift and vertical spacing to every color value in the seed, not just one color. If the seed contains several colors, each color will be copied with its own cyclic offset relative to the seed.</description>\n<example>If the seed is [A B C], then the first copy will have A at the left, B next, C at the right; the next copy will shift each color one position cyclically, producing [C A B], [B C A], etc.</example>\n</note4>\n\n<note5>\n<description>Use a single consistent direction for rotation (always shifting the seed’s rightmost toward the left when you place copies) and stop when you reach the top of the grid or when you would overlap the seed. If the grid height is odd, the seed itself will remain unchanged.</description>\n<example>With an odd number of rows the seed stays at the bottom unchanged; with an even number of rows you will have an extra copy above the seed. Always rotate the seed in the same direction when making each copy to keep the pattern unambiguous.</example>\n</note5>","<note1>\n<description>Look first for a single non-background row that contains all meaningful colors. When one row is the only source of colored pixels, many tasks copy that row (or its pattern) into other rows rather than inventing new colors.</description>\n<example>Imagine a 6×6 grid whose only colored row is the bottom row. If the output shows the same set of colors appearing in other rows, treat that bottom row as the source pattern to be propagated upward.</example>\n</note1>\n\n<note2>\n<description>Check the vertical relationship between input and output rows: the bottom row is often left unchanged and the rows above it are copies of the bottom row at increasing offsets. This suggests a simple arithmetic rule: row k (counting from the bottom) is a shifted version of the bottom row.</description>\n<example>For instance, if the bottom row is A B C, you might observe row 2 above the bottom equal to B C A (shifted by one), row 1 equal to C A B (shifted by two), and the bottom unchanged. That indicates a consistent offset pattern rather than random placement.</example>\n</note2>\n\n<note3>\n<description>Identify the horizontal offset used for each copy: it is typically a fixed number of columns (commonly the row’s offset from the bottom). The offset is applied cyclically (wrap around) when a shift would go past the right edge.</description>\n<example>With a 7-column row labeled 1 2 3 4 5 6 7, a shift of +2 would map 1→3, 2→4, 3→5, … and 7→1 (wrapping). If the same shift is used repeatedly for each row above, the pattern is deterministic.</example>\n</note3>\n\n<note4>\n<description>Confirm how the shift is computed for each row: count rows from the bottom (bottom = 0, next = 1, etc.). The horizontal offset equals that count, so each row above is the bottom row shifted by its distance from the bottom.</description>\n<example>In a 9-row grid the bottom row is offset 0, the row above offset 1, the row above that offset 2, and so on. Apply that same offset to the bottom-row pattern to reproduce the corresponding row.</example>\n</note4>\n\n<note5>\n<description>Watch for pitfalls: only copy colored pixels (do not invent new colors), preserve the original bottom row, and always wrap the shift around the right edge. Use these checks to avoid off-by-one or direction errors when reconstructing the output.</description>\n<example>If a color appears only in the bottom row, expect only copies of that color in the constructed rows; if a shift would try to write past the last column, continue the sequence from the first column. Also double-check whether the shift direction is consistent across examples (e.g., always to the right).</example>\n</note5>","<note1>\n<description>Locate the single row that contains non-background pixels and treat it as the “source” row. That row is the only horizontal reference used to place pixels elsewhere; everything else is background. This reduces the problem to copying and repositioning a short sequence of colors.</description>\n<example>Imagine a 7×7 grid where only row 6 contains colors A B C D E. You should focus on that row as the template for all other rows rather than searching for new horizontal patterns elsewhere.</example>\n</note1>\n\n<note2>\n<description>Think in terms of a one-dimensional sequence: the source row gives you a left-to-right order of colors (a sequence). The transformation reuses that order but places the same color at different offsets (positions) on other rows, so the sequence is preserved but shifted horizontally. This is a horizontal permutation of the sequence, not a recoloring or vertical stacking.</description>\n<example>For a short source sequence [X, Y, Z], you might place X at column 0 on some rows, Y at column 2 on another, and Z at column 4 on another, keeping X→Y→Z in order while their columns change.</example>\n</note2>\n\n<note3>\n<description>Use the last column (rightmost) as the anchor for horizontal placement: copy the rightmost color of the source row into that column on every row. This gives a consistent right-side anchor and determines the horizontal offset for the other colors. In other words, the last element of the source row is mirrored to the far right on all rows.</description>\n<example>If the source ends with color M, then on every output row you should see M in the last column; that placement fixes where the other colors will be shifted relative to it.</example>\n</note3>\n\n<note4>\n<description>For each non-last color in the source, place it one column to the left of the anchor on the rows below the source; repeat this one-step left-shift for each subsequent row. This produces a stepped pattern: colors appear at progressively smaller horizontal offsets as you move down the grid. The leftmost color from the source will appear in the first row immediately to the left of the anchor.</description>\n<example>With a source [A, B, C] and anchor C at the right, row 6 (the source) keeps A at column 0, row 7 places A at column 1, row 8 places A at column 2, and so on—each non-anchor color is shifted one column left per row as you go down.</example>\n</note4>\n\n<note5>\n<description>Keep the source row itself unchanged and do not overwrite existing non-background pixels—only fill background cells with the copied colors. If a placement would land on a non-background cell, leave that cell as-is. This prevents accidental destruction of original colored pixels and keeps the transformation local to background areas.</description>\n<example>If a target cell already contains a non-zero color, skip overwriting it when placing a copied color; only write into cells that are currently background so the original structure is preserved.</example>\n</note5>","<note1>\n<description>Start by isolating the row that contains the colored pixels in the input (the “source row”). Treat that row as a single object to be duplicated and transformed rather than as isolated pixels scattered in the grid. This reduces the problem to moving and copying a single horizontal sequence.</description>\n<example>Imagine a 5×5 grid whose only nonzero row is row 4: [0,2,0,7,0]. You should view [2,7] as the object to be transformed; everything else is background and can be ignored for the transformation.</example>\n</note1>\n\n<note2>\n<description>Look for a vertical translation of the source row: the output often shows the source row appearing in the same columns but at different row indices (e.g., at regular offsets). Identifying these offsets reveals the vertical period of the pattern. The period is the spacing between consecutive copies along the vertical axis.</description>\n<example>If you see the same column pattern in rows 4, 7 and 10 of the output, the vertical period is 3 (rows increase by 3 each time). Use that spacing to place copies of the source row consistently across the grid.</example>\n</note2>\n\n<note3>\n<description>Inspect how the left-to-right order of colors is preserved or reversed when the row is copied. Many tasks use a consistent mirroring (left↔right) for each copy, so check whether the sequence in one copy is the reverse of the source row. Determine which copy uses the reversed sequence and apply that rule consistently.</description>\n<example>Given source [A,B,C], a mirrored copy at a lower row might appear as [C,B,A]; a non-mirrored copy remains [A,B,C]. If you find one mirrored copy, expect the same mirror behavior for all copies.</example>\n</note3>\n\n<note4>\n<description>Check for horizontal anchoring: copies are often placed with their rightmost cell aligned to the same column index as the source row’s rightmost cell. This means the source’s last non-background column becomes the anchor for every copy, and you should align new copies to that same column. Anchoring fixes where copies start horizontally.</description>\n<example>If the source ends at column 4, then each copied row should also end at column 4 (so the sequence is placed so its last element occupies column 4). Use that anchor to position every mirrored and non-mirrored copy.</example>\n</note4>\n\n<note5>\n<description>Decide which copy to place at the original source row (top vs bottom) and whether the original row should be mirrored or not. The training examples usually show a single copy at the source row; if the original row is mirrored there, then every copy should be mirrored. Apply that choice consistently across all copies.</description>\n<example>If the example output shows the source row mirrored at its original location, mirror every copy you place. If it shows the source row unchanged, then keep the original row as-is and mirror only the copies placed elsewhere.</example>\n</note5>","<note1>\n<description>Focus on the single non-empty row: many ARC tasks use a one-row seed that is copied into the rest of the grid. The first step is to isolate that row and treat it as the source pattern for all other rows.</description>\n<example>Imagine a grid whose only non-zero row is [A B C D] at the bottom. Before making any changes, record that sequence as the pattern you will reuse elsewhere in the grid.</example>\n</note1>\n\n<note2>\n<description>Look for a consistent vertical translation: the pattern may be copied upward in steps of a fixed distance (often half the grid height). This produces multiple shifted copies of the seed, one for each step.</description>\n<example>If the grid height is 9 and the seed sits at row 8, try placing shifted copies at rows 6, 4, 2 (i.e., stepping up by 2 each time). Each placement keeps the same left-to-right order of the seed elements.</example>\n</note2>\n\n<note3>\n<description>Check for a horizontal mirror at each copy: many tasks mirror the seed across the vertical center so each shifted copy appears on the opposite side of the grid. This creates left/right symmetry in the final layout.</description>\n<example>With a seed [x y z], a mirrored copy would be [z y x]. When you place mirrored copies at different vertical offsets, you will see the original and its horizontal reverse appearing at symmetric row positions.</example>\n</note3>\n\n<note4>\n<description>Respect boundaries when mirroring and shifting: if a mirrored copy would extend past the left or right edge, clip it so it only occupies the cells that actually fit. The clipped fragment is what appears in that row.</description>\n<example>If the seed is 4 columns wide and the grid width is 7, a mirrored copy that would start at column 0 and extend 4 columns right will be truncated at the right edge; only the columns that lie inside the grid will be shown.</example>\n</note4>\n\n<note5>\n<description>Decide which rows receive copies by checking parity and the seed's vertical position: copies often land on rows that have the same parity as the seed row, or on the rows immediately above the seed. Use the examples to infer which rule is consistent.</description>\n<example>If the seed sits on an even-numbered row, try placing copies on other even-numbered rows; if the seed sits on an odd row, try odd rows. If the seed is on the last row, the rule may instead place copies on the rows immediately above it (one step up).</example>\n</note5>","<note1>\n<description>Look for a single horizontal anchor: many tasks start from one row that contains the non-background pixels. Treat that row as the source of colors and their left-to-right order, and record its length (how many colored cells it has). This anchor is the reference for where copies will appear.</description>\n<example>Imagine a 1×5 row [A B C D E]. You would note the anchor is that row and its length is 5; every subsequent placement will use A..E in that order and only those colors.</example>\n</note1>\n\n<note2>\n<description>Think in terms of a diagonal sweep: the output is produced by moving one cell down and one cell right per step. In other words, each copy of the anchor is placed at (r+1,c+1), (r+2,c+2), (r+3,c+3), ... until you leave the grid. This creates a continuous down-right diagonal of repeated segments.</description>\n<example>If the anchor is at the bottom row and you step down-right, you will see the anchor sequence appear again at the row above and one column to the right, then again one more down-right step, and so on.</example>\n</note2>\n\n<note3>\n<description>Preserve left-to-right order when copying: each diagonal placement copies the anchor's sequence exactly (no reversal). The relative order of colors within each copy stays the same as in the original anchor.</description>\n<example>For a short anchor [X Y Z], the next diagonal copy will also be [X Y Z] in that same left-to-right order, aligned with the diagonal position.</example>\n</note3>\n\n<note4>\n<description>Handle partial copies at the grid edges: if a diagonal placement would require a color that lies beyond the right edge, simply stop placing that color there and do not wrap or shift the sequence. Each copy is truncated at the grid boundary rather than rotated or reflected.</description>\n<example>If an anchor of length 4 is placed near the right edge and the next diagonal position would try to place a color past the last column, you only place the available colors (the prefix) at that diagonal location.</example>\n</note4>\n\n<note5>\n<description>Do not invent new colors: only colors that already exist in the anchor can appear in the copies. If a copy would require a color not present in the anchor, that color should not be introduced; copies remain limited to the anchor's palette.</description>\n<example>If the anchor contains colors {A,B,C}, every diagonal copy will contain only A, B, and C; you should never add a color D that is absent from the anchor.</example>\n</note5>","<note1>\n<description>Find the anchor line: in these tasks the only non-background pixels lie in a single row (the bottom row). Treat that whole row as the template to be propagated rather than analyzing isolated pixels.</description>\n<example>Imagine a grid where only the bottom row contains any colored pixels; that bottom row is the seed. Before trying any transformations, verify that every colored cell in the input belongs to that bottom row so you can treat it as a single object to copy or rearrange.</example>\n</note1>\n\n<note2>\n<description>Think in terms of horizontal repetition: the pattern is not rotated or reflected but copied side-by-side across the grid, producing a sequence of identical horizontal stripes. Each stripe is the full width of the grid.</description>\n<example>For a 4-column seed [A B C D], copying it horizontally will produce stripes [A B C D], [A B C D], [A B C D], [A B C D] across the grid. The key is that each stripe is the entire row copied, not just a rotated or reversed version.</example>\n</note2>\n\n<note3>\n<description>Decide how many copies: the number of horizontal stripes equals the number of columns in the grid (N). This gives a fixed, predictable layout without additional vertical scaling.</description>\n<example>On a 6-column grid you will produce 6 stripes (one per column). On a 9-column grid you will produce 9 stripes. Counting columns is the reliable way to determine how many times to repeat the seed horizontally.</example>\n</note3>\n\n<note4>\n<description>Preserve left-to-right order within each stripe: when you copy the seed, keep its original left-to-right sequence. Do not reverse or shuffle the column order when placing copies.</description>\n<example>If the seed is [X Y Z], every stripe should be [X Y Z] as well. If you accidentally reversed it to [Z Y X], the pattern would be different and would not match the examples.</example>\n</note4>\n\n<note5>\n<description>Place stripes consistently along the bottom: the examples place copies so that the stripe for column c occupies the bottom row at columns 0..(N−1) in a fixed cyclic way (often c mod N). This creates a repeating pattern anchored at the bottom edge.</description>\n<example>With N=4, the seed [A B C D] placed cyclically yields stripes at columns 0..3 in the bottom row in the order A,B,C,D,A,B,C,D,...; a stripe that starts at column 1 would then appear at columns 1..3,0,1,2, etc. Use modulo arithmetic to determine where each copy lands.</example>\n</note5>","<note1>\n<description>Locate the seed row: the transformation always begins with the single non‑empty row in the input. That row is the source of colors and their left‑to‑right order, so treat it as a fixed template to be reused.</description>\n<example>Imagine a 6×7 grid whose only non‑empty row is row 5: [A B C D E]. That row is your seed. All subsequent placements use the colors A..E in that left‑to‑right order when you build copies of the pattern.</example>\n</note1>\n\n<note2>\n<description>Copy the seed as a vertical tile: the seed is not just copied into the output as a horizontal band but is stacked repeatedly down the grid. Each copy preserves the seed’s left‑to‑right order and the same color values.</description>\n<example>With seed [A B C], the output will contain vertical stacks like [A B C] at the top, then another [A B C] below it, and so on. Each stack is a full vertical copy of the seed rather than a partial or shifted version.</example>\n</note2>\n\n<note3>\n<description>Place each copy at a fixed horizontal offset: every vertical copy is aligned to the same column index (the same column of the seed). That column index is constant across all copies, so the pattern’s vertical alignment is rigid.</description>\n<example>If the seed’s first colored cell sits in column 2, then every vertical stack will begin at column 2. So you will see the same column index occupied by the seed’s leftmost color in each stacked copy.</example>\n</note3>\n\n<note4>\n<description>Preserve the original row as a reference: the seed row itself appears in the output at the same position as in the input and does not change. Use that unchanged row as the anchor for measuring offsets when you place other copies.</description>\n<example>If the seed is row 4 in the input, row 4 remains exactly as it was in the output. When you place other vertical copies, use that unchanged row as the baseline to decide how far down to place subsequent copies.</example>\n</note4>\n\n<note5>\n<description>Decide copy order and count by comparing the input’s seed row to the output’s topmost occurrence of the seed’s first color: the copies are stacked downward in the same order as that first color appears across examples. Count how many times the seed’s leftmost color appears in the output to determine how many vertical copies to place.</description>\n<example>If the seed’s first color appears three times in the output (once at the seed row and twice below), that indicates three stacked copies. Place the seed vertically at the seed row, then place identical vertical stacks below it in the same column, and stop when the required number of copies is reached.</example>\n</note5>","<note1>\n<description>Start by isolating the active row: most ARC tasks use a single non-background row as the source pattern. Treat that row as the \"seed\" and ignore other rows for now to simplify the search for a repeating motif.</description>\n<example>Imagine a 7×7 grid where only the bottom row contains colored pixels and every other row is background. Focus on that bottom row as the pattern you will copy and transform; other rows are empty so you can concentrate on how that seed is duplicated.</example>\n</note1>\n\n<note2>\n<description>Look for a vertical repetition: the output often shows the seed row repeated in the same left-to-right order at multiple row positions. The vertical spacing between repeats is a constant offset that you should measure across examples.</description>\n<example>If the bottom row is the seed and you see the same colored sequence again at some rows above, note how many rows separate those copies. That separation is the vertical period you will use when placing copies of the seed.</example>\n</note2>\n\n<note3>\n<description>Examine how the seed is shifted horizontally when copied: often the copies are shifted by a fixed number of columns (for example, by one column) and the sequence is reversed on each step. This creates a regular horizontal pattern as you step up the grid.</description>\n<example>Take a short row [A B C]. If you shift it one column left and reverse it you get [C B A]; shifting again produces [A B C] again. If you observe that pattern repeatedly, you have found the horizontal rule.</example>\n</note3>\n\n<note4>\n<description>Combine the vertical spacing and horizontal shift into a compact rule: pick a base copy (for example the original seed), then place copies at the vertical offset, applying the horizontal shift and reversal on each subsequent copy. Keep other rows background unless a copy would overwrite them.</description>\n<example>For instance, if the vertical period is two rows and each copy is shifted one column left and reversed, you can write a small loop: copy the seed, move up by the period, shift and reverse, and repeat until you reach the top. This produces the same alternating left/right pattern seen in the examples.</example>\n</note4>\n\n<note5>\n<description>Watch for collisions and edge effects: when shifted copies overlap, determine whether the examples preserve the original row or overwrite it. Also check whether the final row of the grid stays identical to the original seed—this tells you where to stop the copying.</description>\n<example>If two shifted copies would write to the same cell, look at the training outputs to see which color remains; that tells you the overwrite behavior. If the bottom row is left unchanged, then do not overwrite it when placing copies—stop at the row above it.</example>\n</note5>","<note1>\n<description>Identify the seed row: many tasks start with a single non‑empty row at the bottom (or top) and use that row as the source of all patterned pixels. Treat that row as a sequence of colors to be propagated upward (or downward) rather than treating it as a separate object.</description>\n<example>Imagine a 7×7 grid whose only non‑zero row is row 6: [0,2,0,3,0,1,0]. That row is the seed — every other row’s pattern is derived from copying or transforming that row, so first locate and isolate that row before looking for other placements.</example>\n</note1>\n\n<note2>\n<description>Look for a fixed vertical spacing: the repeated patterns in the output are not adjacent but occur at equal intervals. Compute the spacing as the difference between the row indices of the topmost and next occurrence; that spacing is the period you will use for copying.</description>\n<example>For example, if the seed appears at row 6 and the next identical occurrence is at row 3, the spacing is 3 (rows 3, 6, ...). Use that same offset to place additional copies of the seed at rows that are multiples of the spacing.</example>\n</note2>\n\n<note3>\n<description>Check how the seed is shifted horizontally when copied: the pattern is usually translated by the same fixed horizontal offset each time. The offset is the difference between the seed’s leftmost colored column and the leftmost colored column of the copied pattern.</description>\n<example>If the seed’s leftmost colored pixel is at column 2 and the first copy’s leftmost colored pixel is at column 4, the horizontal offset is +2; every subsequent copy is then placed 2 columns to the right (unless constrained by the grid edge).</example>\n</note3>\n\n<note4>\n<description>Handle boundaries and overlaps: when copying you may run out of columns or encounter another copy, so the sequence of colored pixels is truncated at the grid edge and overlapping placements are simply merged. This explains why some colors appear only in a subset of the rows.</description>\n<example>On a 10‑column grid, a seed that starts at column 3 and has a horizontal offset of +2 will produce a copy that begins at column 5; if the next copy would start at column 7 but the grid ends at column 9, only the visible portion of that copy is drawn, and overlaps are combined into the final grid.</example>\n</note4>\n\n<note5>\n<description>Reconstruct the output by iterating: start from the seed row, compute its row index (topmost occurrence), and then place copies at successive offsets equal to the spacing, each time shifting the seed by the horizontal offset and truncating at edges. Repeating this step produces the full pattern seen in the examples.</description>\n<example>Practically, for a spacing of 3 and a horizontal offset of +2, begin at the seed row and place copies at rows 3, 6, 9, …; for each copy, shift the seed’s colored columns by +2 and stop drawing where the grid ends, then combine overlapping placements to get the final grid.</example>\n</note5>","<note1>\n<description>Look for a single non-background row that contains the pattern to be propagated; this row is the source of all colors in the transformation. When one row carries the meaningful information and all other cells are background, treat that row as the seed for the rest of the grid.</description>\n<example>Imagine a grid where every cell is background except the bottom row: that bottom row is the only place you must read colors from. You will not invent new colors from elsewhere—everything you place comes from that bottom row.</example>\n</note1>\n\n<note2>\n<description>Examine the bottom row as a sequence of colors left-to-right and think in terms of a cyclic permutation: the pattern is being rotated so that each copy of the row is shifted by one column relative to the previous copy. Each successive row is a one-step rotation of the seed row.</description>\n<example>For a seed row [A B C D], the next row down would be [D A B C] (shifted one left), then [C D A B], and so on. This produces a consistent, repeating pattern of the same colors at different offsets.</example>\n</note2>\n\n<note3>\n<description>Keep the seed row itself unchanged and place each rotated copy immediately above it (so the seed sits at the bottom). The top row will be the first rotated copy, the row above that the second, etc., producing a vertical sequence of rotated copies.</description>\n<example>If the seed is at the bottom, the row just above it is the first rotated copy, the next row above is the second rotated copy, and so on. This keeps the original seed intact while building the rest of the grid from it.</example>\n</note3>\n\n<note4>\n<description>Do not introduce or duplicate colors that are not present in the seed row—only reposition the existing colors. Also do not change the row order or flip the sequence; rotations keep colors in the same relative order (left-to-right) but shift them along the row.</description>\n<example>If the seed contains only {X, Y, Z}, every rotated copy must use only those colors. A common mistake is to mirror or repeat colors elsewhere; the correct operation is to rotate the seed and place copies in order.</example>\n</note4>\n\n<note5>\n<description>Use the width of the grid to determine how many rotated copies fit vertically and be mindful of the grid’s height when placing copies. The pattern repeats every width steps, so the number of full rotations you can place is limited by how many rows are available.</description>\n<example>For a 7-column seed you will produce 7 distinct rotated versions before repeating; if the grid has only 3 rows, you can place at most 3 of those rotated copies and stop when you reach the top. Always preserve the original seed row at the bottom.</example>\n</note5>","<note1>\n<description>Locate the anchor: many ARC tasks use the bottom row as the single source of colored information. Treat that row as the template or “seed” that gets copied and transformed into the rest of the grid.</description>\n<example>Imagine a grid whose only non-background row is the bottom row [A B C]. That bottom row is the anchor: every other row will be derived from copying and shifting this sequence rather than from independent scattered pixels elsewhere.</example>\n</note1>\n\n<note2>\n<description>Think in terms of tiling: the output is often built by repeating the anchor row across columns and stacking those repeats down rows. Each horizontal repeat is a shifted copy of the anchor, so the sequence appears in multiple columns at once.</description>\n<example>For a short anchor [X Y Z], a tiling view shows the same three symbols reappearing in different column positions in successive rows; you can imagine the grid as many copies of that short sequence arranged in a regular lattice.</example>\n</note2>\n\n<note3>\n<description>Observe the vertical step and the mirror property: the repeats are placed with a fixed vertical interval (commonly every other row), and each repeat is a left-right mirror of the previous one. This alternation produces a palindromic, symmetric arrangement.</description>\n<example>If the first repeat appears at row 0, the next repeat appears two rows down and is the reverse of the first (e.g., [X Y Z] then [Z Y X]); continuing this pattern yields a vertically alternating, mirrored structure.</example>\n</note3>\n\n<note4>\n<description>Use the last non-background row as the final anchor and anchor it to the bottom: the bottom row itself remains unchanged and serves as the base for the tiling above it. Everything else is built by copying that bottom row (and its mirrored variants) upward.</description>\n<example>Given a bottom row [P Q R], keep that row exactly where it is and then place mirrored copies of it above it, so the bottom row is preserved and the pattern grows upward from it.</example>\n</note4>\n\n<note5>\n<description>Practical checks and pitfalls: confirm the anchor is indeed the bottom row (not a small isolated cluster), verify the horizontal step between repeats, and ensure you mirror each repeat when placing the next one. If multiple candidate rows exist, prefer the one that is contiguous and at the bottom.</description>\n<example>Before filling the grid, list candidate rows and pick the longest contiguous non-background row at the bottom. Then place copies with a fixed horizontal shift (commonly one cell) and alternate direction (original → reversed → original → ...) until the whole grid is filled.</example>\n</note5>","<note1>\n<description>Find the single row that contains any non-zero pixels; that row is the seed for the transformation. Treat this row as the source of colors and positions used to generate other rows.</description>\n<example>Imagine a 7×7 grid whose only colored cells are in row 6: [0 2 0 4 0 5 0]. That row is the only source of color information; all subsequent colored cells in the output come from copying or reusing values from this row.</example>\n</note1>\n\n<note2>\n<description>Decide which column of the seed row is used as the anchor for each new row: the rightmost colored cell in the seed row determines the horizontal alignment for every copied row. All copied rows will place their first colored pixel at that same column.</description>\n<example>If the seed row ends with a colored cell at column 5, then every row that receives a copy will start with its colored pixel at column 5. So a copy of the seed row will appear at column 5 in every row where it appears.</example>\n</note2>\n\n<note3>\n<description>Copy the entire seed row into every row of the grid; do not rotate or reverse the row. The copy preserves the left-to-right order of colors and their relative positions.</description>\n<example>Given a seed row [A B C D], copying it into another row produces [A B C D] in that row as well. If the seed row has zeros, those zeros remain in the same relative positions after copying.</example>\n</note3>\n\n<note4>\n<description>When you place a copy, overwrite any non-zero cells that already exist at the same coordinates; do not overwrite zeros. This means colors from the seed can replace existing colored pixels but cannot create new colors.</description>\n<example>If a target row already has a colored pixel at column 2 and the seed row has color X at column 2, the target row will show X at column 2 after the copy. If the target has a zero at that column, the copy will write X there.</example>\n</note4>\n\n<note5>\n<description>Use the seed row as a stencil to reproduce itself across the grid: the transformation is a uniform placement of the full seed row into every row, anchored to the seed’s rightmost colored column. This reproduces the repeated pattern seen in the examples.</description>\n<example>Start with a seed row [0 1 0 2 0]; place that exact row into every row and align its first colored pixel at the seed’s rightmost colored column. The result is a vertical repetition of the seed row across the grid, preserving order and overwriting where necessary.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Look for a single horizontal band that contains all non-black pixels: many ARC tasks use a bottom row (or a contiguous horizontal stripe) as the source pattern. Isolating that band simplifies the rest of the transformation because the rest of the grid is treated as background.</description>\\n<example>Imagine a grid whose only colored pixels are on the last row: treat that row as the source pattern and ignore the empty rows above. You will then only need to reason about how that one-row pattern is copied or transformed into the upper rows, rather than worrying about many scattered pixels.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the source row with the nearest non-empty row above it to find the horizontal offset: the output copies the source row but shifted left by a fixed amount (the number of empty columns between the source and that nearest non-empty row). This offset is the same for every row above the source.</description>\\n<example>For instance, if the source row sits two columns above the nearest filled row, then every upper row will show the source pattern shifted two columns to the left. That consistent shift tells you how much to move the pattern for each level.</example>\\n</note2>\\n\\n<note3>\\n<description>Apply the same shifted copy repeatedly upward until the top of the grid is reached. Each successive row is the previous row's shifted copy (with the same leftward shift), producing a stepped, stair-like arrangement of the source pattern.</description>\\n<example>Starting from the source row, copy it shifted by the offset to the row above, then copy that shifted row again shifted the same amount to the next row, and so on. This creates a sequence of identical rows but each one further to the left than the one before.</example>\\n</note3>\\n\\n<note4>\\n<description>Preserve the original colors and relative order of the source row when copying; do not recolor or reorder pixels. The transformation is a translation of the source row (and its copies), not a rotation or reflection.</description>\\n<example>If the source row reads [A, B, C, D, E] from left to right, every copied row should also read [A, B, C, D, E] in the same order, just placed at the shifted horizontal position. This keeps the pattern recognizable across all rows.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle truncated copies at the grid edges and decide how to treat the source row itself: copies that would extend beyond the right edge are clipped; the source row itself may be left in place or duplicated. Use the examples to infer which behavior is intended (e.g., whether the original row is also included in the stepped copies).</description>\\n<example>If a shifted copy would write past the rightmost column, only the visible portion appears on the grid. If the source row is not included in the upward copies, you will see a single original row plus the stepped copies above it; if it is included, you will see an extra copy at the very top.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single horizontal row that contains every non-background color; this row acts as the source of all colored information. When that row is unique and spans the full width, it is the natural place to start any transformation because every colored pixel in the output can be traced back to it.</description>\\n<example>Imagine a grid where only the bottom row has colored pixels and every other row is background. Treat that bottom row as the source: the output will contain colored pixels that are derived from those bottom-row values, while other rows remain mostly background.</example>\\n</note1>\\n\\n<note2>\\n<description>Work column-by-column: each column’s colored pixels form a vertical sequence that repeats in a consistent way. Recognize that the same sequence of colors appears in multiple columns at different offsets rather than as independent isolated pixels.</description>\\n<example>For instance, if a particular column shows [A,B,C] from top to bottom, you should expect to see A,B,C appearing in other columns but shifted downward by the same rule (not in arbitrary positions).</example>\\n</note2>\\n\\n<note3>\\n<description>Observe the vertical step size: colored pixels appear every k rows (k is constant across columns). In these examples k is two (a step of two rows), so the pattern is “every second row.” This regular step explains why the colored pixels form a repeated staircase rather than a random placement.</description>\\n<example>With k=2, a sequence in one column will show up in the same relative positions in neighboring columns two rows lower; if you find two colored pixels in a column, the next column’s colored pixels will be in the same columns but two rows down.</example>\\n</note3>\\n\\n<note4>\\n<description>Reconstruct the sequence by moving left-to-right: copy the source row’s colored pixels into the first column, then shift the sequence two rows down and repeat for the next column, continuing until the right edge. This preserves the left-to-right order of the source row while creating the stepped repetition.</description>\\n<example>Take a source row [x,y,z] (left to right). Place x,y,z into column 1; place x,y,z into column 2 but two rows lower; place x,y,z into column 3 two rows lower than that, and so on, until you reach the rightmost column.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for edge cases and consistency: the rightmost column may be truncated (the last copy placed may extend past the grid), and every column must use the same sequence and step. Verify the same step and ordering across all columns to avoid misaligning the pattern.</description>\\n<example>If the source row is [a,b,c,d] and the grid has few columns, you may not be able to place all four values in every column (the last copy will be clipped). Also ensure every column uses the same two-row step and the same left-to-right ordering—any deviation indicates an incorrect placement.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the single row that contains non-black pixels; that row is the source pattern for the whole transformation. Treat that row as a sequence of colored tokens (ignore zeros inside it) and use their left-to-right order when you reason about placement.</description>\\n<example>Imagine a grid whose only colored row is [A B C 0 D]. Consider the tokens [A,B,C,D] in that order rather than individual cells. Everything you place later should be based on that sequence, not on scattered isolated pixels elsewhere.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide the target offset by measuring how far the pattern sits from the right edge. The target is the column index equal to the number of columns minus the source row’s column index; this gives a fixed horizontal placement for the first copy.</description>\\n<example>If the pattern is at the bottom and the grid has 9 columns while the pattern’s first colored cell is at column 4, the target column is 9 - 4 = 5. Place the first copy so its leftmost colored cell is at column 5.</example>\\n</note2>\\n\\n<note3>\\n<description>Place the source row into the chosen target column but keep its vertical order intact. Do not rotate or flip the sequence — copy it exactly as it appears in the source row, starting at the target column.</description>\\n<example>For a source row [X Y Z] and target column 5, put X at (row,5), Y at (row+1,5), Z at (row+2,5). The relative order (X then Y then Z) must remain unchanged.</example>\\n</note3>\\n\\n<note4>\\n<description>Recreate the pattern for each row above the source using the same column offset but shifted upward by one row each time. This produces a stepped diagonal of repeated copies that move one column to the right as they go up.</description>\\n<example>If the source is at the bottom, create a copy at the row above with the same offset, then another at the row above that with the same offset, and so on. Each successive copy is placed one row higher and one column to the right, preserving the sequence order.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle overlaps and edge cases by copying only where the target cell is black; when a target cell is already non-black, the copy’s cell should overwrite it. This keeps the final pattern consistent even if copies would collide.</description>\\n<example>If two copies would write to the same cell, the later (higher) copy overwrites the earlier one. If the target column is outside the grid, do not attempt to place a copy there — only place copies where the target cell is within bounds.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single horizontal row that contains all the non-background pixels; that row is the “seed” for the transformation. When only one row carries color, treat that entire row as the template to be copied and shifted rather than as isolated pixels.</description>\\n<example>Imagine a 6×6 grid where every colored pixel lies in the bottom row [A B C]. That bottom row is your seed: it is the only source of color you will copy and move elsewhere in the grid.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide the vertical spacing between copies by counting how many rows lie between the seed and the nearest filled row in the outputs. Use that same step size for all copies so the pattern repeats regularly.</description>\\n<example>If the seed is at the bottom and the nearest filled row above it in the output is two rows away, then copies will appear at the seed, two rows up, four rows up, and so on—consistent step size is key.</example>\\n</note2>\\n\\n<note3>\\n<description>Horizontal placement is a cyclic shift: the seed’s rightmost element becomes the leftmost in the next copy, the next-right element becomes the next-left, and so on. This preserves the left-to-right order but wraps it around the row.</description>\\n<example>For a seed [X Y Z], the next copy will be [Z X Y] (rightmost → leftmost), the next [Y Z X], etc. Each successive copy is a one-step cyclic rotation of the seed.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the same cyclic shift and vertical spacing to every color value in the seed, not just one color. If the seed contains several colors, each color will be copied with its own cyclic offset relative to the seed.</description>\\n<example>If the seed is [A B C], then the first copy will have A at the left, B next, C at the right; the next copy will shift each color one position cyclically, producing [C A B], [B C A], etc.</example>\\n</note4>\\n\\n<note5>\\n<description>Use a single consistent direction for rotation (always shifting the seed’s rightmost toward the left when you place copies) and stop when you reach the top of the grid or when you would overlap the seed. If the grid height is odd, the seed itself will remain unchanged.</description>\\n<example>With an odd number of rows the seed stays at the bottom unchanged; with an even number of rows you will have an extra copy above the seed. Always rotate the seed in the same direction when making each copy to keep the pattern unambiguous.</example>\\n</note5>\",\n \"<note1>\\n<description>Look first for a single non-background row that contains all meaningful colors. When one row is the only source of colored pixels, many tasks copy that row (or its pattern) into other rows rather than inventing new colors.</description>\\n<example>Imagine a 6×6 grid whose only colored row is the bottom row. If the output shows the same set of colors appearing in other rows, treat that bottom row as the source pattern to be propagated upward.</example>\\n</note1>\\n\\n<note2>\\n<description>Check the vertical relationship between input and output rows: the bottom row is often left unchanged and the rows above it are copies of the bottom row at increasing offsets. This suggests a simple arithmetic rule: row k (counting from the bottom) is a shifted version of the bottom row.</description>\\n<example>For instance, if the bottom row is A B C, you might observe row 2 above the bottom equal to B C A (shifted by one), row 1 equal to C A B (shifted by two), and the bottom unchanged. That indicates a consistent offset pattern rather than random placement.</example>\\n</note2>\\n\\n<note3>\\n<description>Identify the horizontal offset used for each copy: it is typically a fixed number of columns (commonly the row’s offset from the bottom). The offset is applied cyclically (wrap around) when a shift would go past the right edge.</description>\\n<example>With a 7-column row labeled 1 2 3 4 5 6 7, a shift of +2 would map 1→3, 2→4, 3→5, … and 7→1 (wrapping). If the same shift is used repeatedly for each row above, the pattern is deterministic.</example>\\n</note3>\\n\\n<note4>\\n<description>Confirm how the shift is computed for each row: count rows from the bottom (bottom = 0, next = 1, etc.). The horizontal offset equals that count, so each row above is the bottom row shifted by its distance from the bottom.</description>\\n<example>In a 9-row grid the bottom row is offset 0, the row above offset 1, the row above that offset 2, and so on. Apply that same offset to the bottom-row pattern to reproduce the corresponding row.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for pitfalls: only copy colored pixels (do not invent new colors), preserve the original bottom row, and always wrap the shift around the right edge. Use these checks to avoid off-by-one or direction errors when reconstructing the output.</description>\\n<example>If a color appears only in the bottom row, expect only copies of that color in the constructed rows; if a shift would try to write past the last column, continue the sequence from the first column. Also double-check whether the shift direction is consistent across examples (e.g., always to the right).</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the single row that contains non-background pixels and treat it as the “source” row. That row is the only horizontal reference used to place pixels elsewhere; everything else is background. This reduces the problem to copying and repositioning a short sequence of colors.</description>\\n<example>Imagine a 7×7 grid where only row 6 contains colors A B C D E. You should focus on that row as the template for all other rows rather than searching for new horizontal patterns elsewhere.</example>\\n</note1>\\n\\n<note2>\\n<description>Think in terms of a one-dimensional sequence: the source row gives you a left-to-right order of colors (a sequence). The transformation reuses that order but places the same color at different offsets (positions) on other rows, so the sequence is preserved but shifted horizontally. This is a horizontal permutation of the sequence, not a recoloring or vertical stacking.</description>\\n<example>For a short source sequence [X, Y, Z], you might place X at column 0 on some rows, Y at column 2 on another, and Z at column 4 on another, keeping X→Y→Z in order while their columns change.</example>\\n</note2>\\n\\n<note3>\\n<description>Use the last column (rightmost) as the anchor for horizontal placement: copy the rightmost color of the source row into that column on every row. This gives a consistent right-side anchor and determines the horizontal offset for the other colors. In other words, the last element of the source row is mirrored to the far right on all rows.</description>\\n<example>If the source ends with color M, then on every output row you should see M in the last column; that placement fixes where the other colors will be shifted relative to it.</example>\\n</note3>\\n\\n<note4>\\n<description>For each non-last color in the source, place it one column to the left of the anchor on the rows below the source; repeat this one-step left-shift for each subsequent row. This produces a stepped pattern: colors appear at progressively smaller horizontal offsets as you move down the grid. The leftmost color from the source will appear in the first row immediately to the left of the anchor.</description>\\n<example>With a source [A, B, C] and anchor C at the right, row 6 (the source) keeps A at column 0, row 7 places A at column 1, row 8 places A at column 2, and so on—each non-anchor color is shifted one column left per row as you go down.</example>\\n</note4>\\n\\n<note5>\\n<description>Keep the source row itself unchanged and do not overwrite existing non-background pixels—only fill background cells with the copied colors. If a placement would land on a non-background cell, leave that cell as-is. This prevents accidental destruction of original colored pixels and keeps the transformation local to background areas.</description>\\n<example>If a target cell already contains a non-zero color, skip overwriting it when placing a copied color; only write into cells that are currently background so the original structure is preserved.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by isolating the row that contains the colored pixels in the input (the “source row”). Treat that row as a single object to be duplicated and transformed rather than as isolated pixels scattered in the grid. This reduces the problem to moving and copying a single horizontal sequence.</description>\\n<example>Imagine a 5×5 grid whose only nonzero row is row 4: [0,2,0,7,0]. You should view [2,7] as the object to be transformed; everything else is background and can be ignored for the transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a vertical translation of the source row: the output often shows the source row appearing in the same columns but at different row indices (e.g., at regular offsets). Identifying these offsets reveals the vertical period of the pattern. The period is the spacing between consecutive copies along the vertical axis.</description>\\n<example>If you see the same column pattern in rows 4, 7 and 10 of the output, the vertical period is 3 (rows increase by 3 each time). Use that spacing to place copies of the source row consistently across the grid.</example>\\n</note2>\\n\\n<note3>\\n<description>Inspect how the left-to-right order of colors is preserved or reversed when the row is copied. Many tasks use a consistent mirroring (left↔right) for each copy, so check whether the sequence in one copy is the reverse of the source row. Determine which copy uses the reversed sequence and apply that rule consistently.</description>\\n<example>Given source [A,B,C], a mirrored copy at a lower row might appear as [C,B,A]; a non-mirrored copy remains [A,B,C]. If you find one mirrored copy, expect the same mirror behavior for all copies.</example>\\n</note3>\\n\\n<note4>\\n<description>Check for horizontal anchoring: copies are often placed with their rightmost cell aligned to the same column index as the source row’s rightmost cell. This means the source’s last non-background column becomes the anchor for every copy, and you should align new copies to that same column. Anchoring fixes where copies start horizontally.</description>\\n<example>If the source ends at column 4, then each copied row should also end at column 4 (so the sequence is placed so its last element occupies column 4). Use that anchor to position every mirrored and non-mirrored copy.</example>\\n</note4>\\n\\n<note5>\\n<description>Decide which copy to place at the original source row (top vs bottom) and whether the original row should be mirrored or not. The training examples usually show a single copy at the source row; if the original row is mirrored there, then every copy should be mirrored. Apply that choice consistently across all copies.</description>\\n<example>If the example output shows the source row mirrored at its original location, mirror every copy you place. If it shows the source row unchanged, then keep the original row as-is and mirror only the copies placed elsewhere.</example>\\n</note5>\",\n \"<note1>\\n<description>Focus on the single non-empty row: many ARC tasks use a one-row seed that is copied into the rest of the grid. The first step is to isolate that row and treat it as the source pattern for all other rows.</description>\\n<example>Imagine a grid whose only non-zero row is [A B C D] at the bottom. Before making any changes, record that sequence as the pattern you will reuse elsewhere in the grid.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a consistent vertical translation: the pattern may be copied upward in steps of a fixed distance (often half the grid height). This produces multiple shifted copies of the seed, one for each step.</description>\\n<example>If the grid height is 9 and the seed sits at row 8, try placing shifted copies at rows 6, 4, 2 (i.e., stepping up by 2 each time). Each placement keeps the same left-to-right order of the seed elements.</example>\\n</note2>\\n\\n<note3>\\n<description>Check for a horizontal mirror at each copy: many tasks mirror the seed across the vertical center so each shifted copy appears on the opposite side of the grid. This creates left/right symmetry in the final layout.</description>\\n<example>With a seed [x y z], a mirrored copy would be [z y x]. When you place mirrored copies at different vertical offsets, you will see the original and its horizontal reverse appearing at symmetric row positions.</example>\\n</note3>\\n\\n<note4>\\n<description>Respect boundaries when mirroring and shifting: if a mirrored copy would extend past the left or right edge, clip it so it only occupies the cells that actually fit. The clipped fragment is what appears in that row.</description>\\n<example>If the seed is 4 columns wide and the grid width is 7, a mirrored copy that would start at column 0 and extend 4 columns right will be truncated at the right edge; only the columns that lie inside the grid will be shown.</example>\\n</note4>\\n\\n<note5>\\n<description>Decide which rows receive copies by checking parity and the seed's vertical position: copies often land on rows that have the same parity as the seed row, or on the rows immediately above the seed. Use the examples to infer which rule is consistent.</description>\\n<example>If the seed sits on an even-numbered row, try placing copies on other even-numbered rows; if the seed sits on an odd row, try odd rows. If the seed is on the last row, the rule may instead place copies on the rows immediately above it (one step up).</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single horizontal anchor: many tasks start from one row that contains the non-background pixels. Treat that row as the source of colors and their left-to-right order, and record its length (how many colored cells it has). This anchor is the reference for where copies will appear.</description>\\n<example>Imagine a 1×5 row [A B C D E]. You would note the anchor is that row and its length is 5; every subsequent placement will use A..E in that order and only those colors.</example>\\n</note1>\\n\\n<note2>\\n<description>Think in terms of a diagonal sweep: the output is produced by moving one cell down and one cell right per step. In other words, each copy of the anchor is placed at (r+1,c+1), (r+2,c+2), (r+3,c+3), ... until you leave the grid. This creates a continuous down-right diagonal of repeated segments.</description>\\n<example>If the anchor is at the bottom row and you step down-right, you will see the anchor sequence appear again at the row above and one column to the right, then again one more down-right step, and so on.</example>\\n</note2>\\n\\n<note3>\\n<description>Preserve left-to-right order when copying: each diagonal placement copies the anchor's sequence exactly (no reversal). The relative order of colors within each copy stays the same as in the original anchor.</description>\\n<example>For a short anchor [X Y Z], the next diagonal copy will also be [X Y Z] in that same left-to-right order, aligned with the diagonal position.</example>\\n</note3>\\n\\n<note4>\\n<description>Handle partial copies at the grid edges: if a diagonal placement would require a color that lies beyond the right edge, simply stop placing that color there and do not wrap or shift the sequence. Each copy is truncated at the grid boundary rather than rotated or reflected.</description>\\n<example>If an anchor of length 4 is placed near the right edge and the next diagonal position would try to place a color past the last column, you only place the available colors (the prefix) at that diagonal location.</example>\\n</note4>\\n\\n<note5>\\n<description>Do not invent new colors: only colors that already exist in the anchor can appear in the copies. If a copy would require a color not present in the anchor, that color should not be introduced; copies remain limited to the anchor's palette.</description>\\n<example>If the anchor contains colors {A,B,C}, every diagonal copy will contain only A, B, and C; you should never add a color D that is absent from the anchor.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the anchor line: in these tasks the only non-background pixels lie in a single row (the bottom row). Treat that whole row as the template to be propagated rather than analyzing isolated pixels.</description>\\n<example>Imagine a grid where only the bottom row contains any colored pixels; that bottom row is the seed. Before trying any transformations, verify that every colored cell in the input belongs to that bottom row so you can treat it as a single object to copy or rearrange.</example>\\n</note1>\\n\\n<note2>\\n<description>Think in terms of horizontal repetition: the pattern is not rotated or reflected but copied side-by-side across the grid, producing a sequence of identical horizontal stripes. Each stripe is the full width of the grid.</description>\\n<example>For a 4-column seed [A B C D], copying it horizontally will produce stripes [A B C D], [A B C D], [A B C D], [A B C D] across the grid. The key is that each stripe is the entire row copied, not just a rotated or reversed version.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide how many copies: the number of horizontal stripes equals the number of columns in the grid (N). This gives a fixed, predictable layout without additional vertical scaling.</description>\\n<example>On a 6-column grid you will produce 6 stripes (one per column). On a 9-column grid you will produce 9 stripes. Counting columns is the reliable way to determine how many times to repeat the seed horizontally.</example>\\n</note3>\\n\\n<note4>\\n<description>Preserve left-to-right order within each stripe: when you copy the seed, keep its original left-to-right sequence. Do not reverse or shuffle the column order when placing copies.</description>\\n<example>If the seed is [X Y Z], every stripe should be [X Y Z] as well. If you accidentally reversed it to [Z Y X], the pattern would be different and would not match the examples.</example>\\n</note4>\\n\\n<note5>\\n<description>Place stripes consistently along the bottom: the examples place copies so that the stripe for column c occupies the bottom row at columns 0..(N−1) in a fixed cyclic way (often c mod N). This creates a repeating pattern anchored at the bottom edge.</description>\\n<example>With N=4, the seed [A B C D] placed cyclically yields stripes at columns 0..3 in the bottom row in the order A,B,C,D,A,B,C,D,...; a stripe that starts at column 1 would then appear at columns 1..3,0,1,2, etc. Use modulo arithmetic to determine where each copy lands.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the seed row: the transformation always begins with the single non‑empty row in the input. That row is the source of colors and their left‑to‑right order, so treat it as a fixed template to be reused.</description>\\n<example>Imagine a 6×7 grid whose only non‑empty row is row 5: [A B C D E]. That row is your seed. All subsequent placements use the colors A..E in that left‑to‑right order when you build copies of the pattern.</example>\\n</note1>\\n\\n<note2>\\n<description>Copy the seed as a vertical tile: the seed is not just copied into the output as a horizontal band but is stacked repeatedly down the grid. Each copy preserves the seed’s left‑to‑right order and the same color values.</description>\\n<example>With seed [A B C], the output will contain vertical stacks like [A B C] at the top, then another [A B C] below it, and so on. Each stack is a full vertical copy of the seed rather than a partial or shifted version.</example>\\n</note2>\\n\\n<note3>\\n<description>Place each copy at a fixed horizontal offset: every vertical copy is aligned to the same column index (the same column of the seed). That column index is constant across all copies, so the pattern’s vertical alignment is rigid.</description>\\n<example>If the seed’s first colored cell sits in column 2, then every vertical stack will begin at column 2. So you will see the same column index occupied by the seed’s leftmost color in each stacked copy.</example>\\n</note3>\\n\\n<note4>\\n<description>Preserve the original row as a reference: the seed row itself appears in the output at the same position as in the input and does not change. Use that unchanged row as the anchor for measuring offsets when you place other copies.</description>\\n<example>If the seed is row 4 in the input, row 4 remains exactly as it was in the output. When you place other vertical copies, use that unchanged row as the baseline to decide how far down to place subsequent copies.</example>\\n</note4>\\n\\n<note5>\\n<description>Decide copy order and count by comparing the input’s seed row to the output’s topmost occurrence of the seed’s first color: the copies are stacked downward in the same order as that first color appears across examples. Count how many times the seed’s leftmost color appears in the output to determine how many vertical copies to place.</description>\\n<example>If the seed’s first color appears three times in the output (once at the seed row and twice below), that indicates three stacked copies. Place the seed vertically at the seed row, then place identical vertical stacks below it in the same column, and stop when the required number of copies is reached.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by isolating the active row: most ARC tasks use a single non-background row as the source pattern. Treat that row as the \\\"seed\\\" and ignore other rows for now to simplify the search for a repeating motif.</description>\\n<example>Imagine a 7×7 grid where only the bottom row contains colored pixels and every other row is background. Focus on that bottom row as the pattern you will copy and transform; other rows are empty so you can concentrate on how that seed is duplicated.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a vertical repetition: the output often shows the seed row repeated in the same left-to-right order at multiple row positions. The vertical spacing between repeats is a constant offset that you should measure across examples.</description>\\n<example>If the bottom row is the seed and you see the same colored sequence again at some rows above, note how many rows separate those copies. That separation is the vertical period you will use when placing copies of the seed.</example>\\n</note2>\\n\\n<note3>\\n<description>Examine how the seed is shifted horizontally when copied: often the copies are shifted by a fixed number of columns (for example, by one column) and the sequence is reversed on each step. This creates a regular horizontal pattern as you step up the grid.</description>\\n<example>Take a short row [A B C]. If you shift it one column left and reverse it you get [C B A]; shifting again produces [A B C] again. If you observe that pattern repeatedly, you have found the horizontal rule.</example>\\n</note3>\\n\\n<note4>\\n<description>Combine the vertical spacing and horizontal shift into a compact rule: pick a base copy (for example the original seed), then place copies at the vertical offset, applying the horizontal shift and reversal on each subsequent copy. Keep other rows background unless a copy would overwrite them.</description>\\n<example>For instance, if the vertical period is two rows and each copy is shifted one column left and reversed, you can write a small loop: copy the seed, move up by the period, shift and reverse, and repeat until you reach the top. This produces the same alternating left/right pattern seen in the examples.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for collisions and edge effects: when shifted copies overlap, determine whether the examples preserve the original row or overwrite it. Also check whether the final row of the grid stays identical to the original seed—this tells you where to stop the copying.</description>\\n<example>If two shifted copies would write to the same cell, look at the training outputs to see which color remains; that tells you the overwrite behavior. If the bottom row is left unchanged, then do not overwrite it when placing copies—stop at the row above it.</example>\\n</note5>\",\n \"<note1>\\n<description>Identify the seed row: many tasks start with a single non‑empty row at the bottom (or top) and use that row as the source of all patterned pixels. Treat that row as a sequence of colors to be propagated upward (or downward) rather than treating it as a separate object.</description>\\n<example>Imagine a 7×7 grid whose only non‑zero row is row 6: [0,2,0,3,0,1,0]. That row is the seed — every other row’s pattern is derived from copying or transforming that row, so first locate and isolate that row before looking for other placements.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a fixed vertical spacing: the repeated patterns in the output are not adjacent but occur at equal intervals. Compute the spacing as the difference between the row indices of the topmost and next occurrence; that spacing is the period you will use for copying.</description>\\n<example>For example, if the seed appears at row 6 and the next identical occurrence is at row 3, the spacing is 3 (rows 3, 6, ...). Use that same offset to place additional copies of the seed at rows that are multiples of the spacing.</example>\\n</note2>\\n\\n<note3>\\n<description>Check how the seed is shifted horizontally when copied: the pattern is usually translated by the same fixed horizontal offset each time. The offset is the difference between the seed’s leftmost colored column and the leftmost colored column of the copied pattern.</description>\\n<example>If the seed’s leftmost colored pixel is at column 2 and the first copy’s leftmost colored pixel is at column 4, the horizontal offset is +2; every subsequent copy is then placed 2 columns to the right (unless constrained by the grid edge).</example>\\n</note3>\\n\\n<note4>\\n<description>Handle boundaries and overlaps: when copying you may run out of columns or encounter another copy, so the sequence of colored pixels is truncated at the grid edge and overlapping placements are simply merged. This explains why some colors appear only in a subset of the rows.</description>\\n<example>On a 10‑column grid, a seed that starts at column 3 and has a horizontal offset of +2 will produce a copy that begins at column 5; if the next copy would start at column 7 but the grid ends at column 9, only the visible portion of that copy is drawn, and overlaps are combined into the final grid.</example>\\n</note4>\\n\\n<note5>\\n<description>Reconstruct the output by iterating: start from the seed row, compute its row index (topmost occurrence), and then place copies at successive offsets equal to the spacing, each time shifting the seed by the horizontal offset and truncating at edges. Repeating this step produces the full pattern seen in the examples.</description>\\n<example>Practically, for a spacing of 3 and a horizontal offset of +2, begin at the seed row and place copies at rows 3, 6, 9, …; for each copy, shift the seed’s colored columns by +2 and stop drawing where the grid ends, then combine overlapping placements to get the final grid.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single non-background row that contains the pattern to be propagated; this row is the source of all colors in the transformation. When one row carries the meaningful information and all other cells are background, treat that row as the seed for the rest of the grid.</description>\\n<example>Imagine a grid where every cell is background except the bottom row: that bottom row is the only place you must read colors from. You will not invent new colors from elsewhere—everything you place comes from that bottom row.</example>\\n</note1>\\n\\n<note2>\\n<description>Examine the bottom row as a sequence of colors left-to-right and think in terms of a cyclic permutation: the pattern is being rotated so that each copy of the row is shifted by one column relative to the previous copy. Each successive row is a one-step rotation of the seed row.</description>\\n<example>For a seed row [A B C D], the next row down would be [D A B C] (shifted one left), then [C D A B], and so on. This produces a consistent, repeating pattern of the same colors at different offsets.</example>\\n</note2>\\n\\n<note3>\\n<description>Keep the seed row itself unchanged and place each rotated copy immediately above it (so the seed sits at the bottom). The top row will be the first rotated copy, the row above that the second, etc., producing a vertical sequence of rotated copies.</description>\\n<example>If the seed is at the bottom, the row just above it is the first rotated copy, the next row above is the second rotated copy, and so on. This keeps the original seed intact while building the rest of the grid from it.</example>\\n</note3>\\n\\n<note4>\\n<description>Do not introduce or duplicate colors that are not present in the seed row—only reposition the existing colors. Also do not change the row order or flip the sequence; rotations keep colors in the same relative order (left-to-right) but shift them along the row.</description>\\n<example>If the seed contains only {X, Y, Z}, every rotated copy must use only those colors. A common mistake is to mirror or repeat colors elsewhere; the correct operation is to rotate the seed and place copies in order.</example>\\n</note4>\\n\\n<note5>\\n<description>Use the width of the grid to determine how many rotated copies fit vertically and be mindful of the grid’s height when placing copies. The pattern repeats every width steps, so the number of full rotations you can place is limited by how many rows are available.</description>\\n<example>For a 7-column seed you will produce 7 distinct rotated versions before repeating; if the grid has only 3 rows, you can place at most 3 of those rotated copies and stop when you reach the top. Always preserve the original seed row at the bottom.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the anchor: many ARC tasks use the bottom row as the single source of colored information. Treat that row as the template or “seed” that gets copied and transformed into the rest of the grid.</description>\\n<example>Imagine a grid whose only non-background row is the bottom row [A B C]. That bottom row is the anchor: every other row will be derived from copying and shifting this sequence rather than from independent scattered pixels elsewhere.</example>\\n</note1>\\n\\n<note2>\\n<description>Think in terms of tiling: the output is often built by repeating the anchor row across columns and stacking those repeats down rows. Each horizontal repeat is a shifted copy of the anchor, so the sequence appears in multiple columns at once.</description>\\n<example>For a short anchor [X Y Z], a tiling view shows the same three symbols reappearing in different column positions in successive rows; you can imagine the grid as many copies of that short sequence arranged in a regular lattice.</example>\\n</note2>\\n\\n<note3>\\n<description>Observe the vertical step and the mirror property: the repeats are placed with a fixed vertical interval (commonly every other row), and each repeat is a left-right mirror of the previous one. This alternation produces a palindromic, symmetric arrangement.</description>\\n<example>If the first repeat appears at row 0, the next repeat appears two rows down and is the reverse of the first (e.g., [X Y Z] then [Z Y X]); continuing this pattern yields a vertically alternating, mirrored structure.</example>\\n</note3>\\n\\n<note4>\\n<description>Use the last non-background row as the final anchor and anchor it to the bottom: the bottom row itself remains unchanged and serves as the base for the tiling above it. Everything else is built by copying that bottom row (and its mirrored variants) upward.</description>\\n<example>Given a bottom row [P Q R], keep that row exactly where it is and then place mirrored copies of it above it, so the bottom row is preserved and the pattern grows upward from it.</example>\\n</note4>\\n\\n<note5>\\n<description>Practical checks and pitfalls: confirm the anchor is indeed the bottom row (not a small isolated cluster), verify the horizontal step between repeats, and ensure you mirror each repeat when placing the next one. If multiple candidate rows exist, prefer the one that is contiguous and at the bottom.</description>\\n<example>Before filling the grid, list candidate rows and pick the longest contiguous non-background row at the bottom. Then place copies with a fixed horizontal shift (commonly one cell) and alternate direction (original → reversed → original → ...) until the whole grid is filled.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the single row that contains any non-zero pixels; that row is the seed for the transformation. Treat this row as the source of colors and positions used to generate other rows.</description>\\n<example>Imagine a 7×7 grid whose only colored cells are in row 6: [0 2 0 4 0 5 0]. That row is the only source of color information; all subsequent colored cells in the output come from copying or reusing values from this row.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide which column of the seed row is used as the anchor for each new row: the rightmost colored cell in the seed row determines the horizontal alignment for every copied row. All copied rows will place their first colored pixel at that same column.</description>\\n<example>If the seed row ends with a colored cell at column 5, then every row that receives a copy will start with its colored pixel at column 5. So a copy of the seed row will appear at column 5 in every row where it appears.</example>\\n</note2>\\n\\n<note3>\\n<description>Copy the entire seed row into every row of the grid; do not rotate or reverse the row. The copy preserves the left-to-right order of colors and their relative positions.</description>\\n<example>Given a seed row [A B C D], copying it into another row produces [A B C D] in that row as well. If the seed row has zeros, those zeros remain in the same relative positions after copying.</example>\\n</note3>\\n\\n<note4>\\n<description>When you place a copy, overwrite any non-zero cells that already exist at the same coordinates; do not overwrite zeros. This means colors from the seed can replace existing colored pixels but cannot create new colors.</description>\\n<example>If a target row already has a colored pixel at column 2 and the seed row has color X at column 2, the target row will show X at column 2 after the copy. If the target has a zero at that column, the copy will write X there.</example>\\n</note4>\\n\\n<note5>\\n<description>Use the seed row as a stencil to reproduce itself across the grid: the transformation is a uniform placement of the full seed row into every row, anchored to the seed’s rightmost colored column. This reproduces the repeated pattern seen in the examples.</description>\\n<example>Start with a seed row [0 1 0 2 0]; place that exact row into every row and align its first colored pixel at the seed’s rightmost colored column. The result is a vertical repetition of the seed row across the grid, preserving order and overwriting where necessary.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"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], [6, 1, 0, 6, 0, 0, 6, 5, 5]], \"output\": [[5, 0, 0, 0, 0, 0, 0, 0, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0], [6, 5, 5, 0, 0, 0, 6, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 5, 5, 1, 0, 6, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 6, 6, 1, 6, 5, 5, 0, 6], [0, 0, 0, 0, 0, 0, 0, 0, 0], [6, 1, 0, 6, 0, 0, 6, 5, 5]]}, {\"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, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 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, 1, 4, 9, 2, 3, 1, 1, 3, 5, 0, 7, 5]], \"output\": [[5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 7, 5, 0, 0, 0, 0, 0, 0, 0, 3, 1, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [3, 5, 0, 7, 5, 0, 0, 0, 3, 1, 4, 9, 2], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 3, 5, 0, 7, 5, 1, 4, 9, 2, 3, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 3, 1, 1, 3, 5, 4, 7, 5, 3, 1, 1, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 9, 2, 3, 1, 1, 3, 5, 1, 7, 5, 5, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [3, 1, 4, 9, 2, 3, 1, 1, 3, 5, 0, 7, 5]]}, {\"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], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 5, 0, 0, 3, 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, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 5, 0, 0, 3, 0, 0, 0, 0, 5], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 5, 0, 0, 3, 5, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 5, 0, 0, 3, 0]]}]"},"test":{"kind":"string","value":"[{\"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], [1, 7, 6, 3, 9, 0, 0]], \"output\": [[0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0], [9, 0, 0, 0, 1, 7, 6], [0, 0, 0, 0, 0, 0, 0], [6, 3, 9, 7, 6, 3, 9], [0, 0, 0, 0, 0, 0, 0], [1, 7, 6, 3, 9, 0, 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\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n6 1 0 6 0 0 6 5 5\n```\n\nOutput:\n```\n5 0 0 0 0 0 0 0 6\n0 0 0 0 0 0 0 0 0\n6 5 5 0 0 0 6 1 0\n0 0 0 0 0 0 0 0 0\n0 0 6 5 5 1 0 6 0\n0 0 0 0 0 0 0 0 0\n0 6 6 1 6 5 5 0 6\n0 0 0 0 0 0 0 0 0\n6 1 0 6 0 0 6 5 5\n```\n\n## Example 2\nInput:\n```\n0 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\n0 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\n0 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\n0 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\n0 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\n0 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\n3 1 4 9 2 3 1 1 3 5 0 7 5\n```\n\nOutput:\n```\n5 0 0 0 0 0 0 0 0 0 0 0 3\n0 0 0 0 0 0 0 0 0 0 0 0 0\n0 7 5 0 0 0 0 0 0 0 3 1 4\n0 0 0 0 0 0 0 0 0 0 0 0 0\n3 5 0 7 5 0 0 0 3 1 4 9 2\n0 0 0 0 0 0 0 0 0 0 0 0 0\n1 1 3 5 0 7 5 1 4 9 2 3 1\n0 0 0 0 0 0 0 0 0 0 0 0 0\n2 3 1 1 3 5 4 7 5 3 1 1 3\n0 0 0 0 0 0 0 0 0 0 0 0 0\n4 9 2 3 1 1 3 5 1 7 5 5 0\n0 0 0 0 0 0 0 0 0 0 0 0 0\n3 1 4 9 2 3 1 1 3 5 0 7 5\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 5 0 0 3 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 3 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n5 0 0 3 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 5 0 0 3 0 0 0 0 5\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 5 0 0 3 5 0 0\n0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 5 0 0 3 0\n```\n\n# Test Problem:\n```\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\n1 7 6 3 9 0 0\n```"},"answer":{"kind":"string","value":"```\n0 0 0 0 0 0 1\n0 0 0 0 0 0 0\n9 0 0 0 1 7 6\n0 0 0 0 0 0 0\n6 3 9 7 6 3 9\n0 0 0 0 0 0 0\n1 7 6 3 9 0 0\n```"},"num_tokens":{"kind":"number","value":1848,"string":"1,848"}}},{"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```\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 6 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 5 6 6 6\n0 0 0 0 6 0 0 0\n0 0 0 0 6 0 0 0\n0 0 0 0 6 0 0 0\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 4 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```\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 5 4 4 4\n0 0 0 4 0 0 0\n0 0 0 4 0 0 0\n0 0 0 4 0 0 0\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 9 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 5 9 9 9 9\n0 0 0 0 9 0 0 0 0\n0 0 0 0 9 0 0 0 0\n0 0 0 0 9 0 0 0 0\n```\n\n# Test Problem:\n```\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 6 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 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":1836,"string":"1,836"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>Start by locating the single non-background pixel in the input and treat it as the anchor of the transformation. Its row and column index determine where any new structure will be placed relative to the grid.</description>\n<example>Imagine a 7×7 grid with one blue pixel at (row 3, column 4). Record that coordinate — it will be the pivot for where the output pattern is anchored and where you measure distances.</example>\n</note1>\n\n<note2>\n<description>Measure the anchor's distance from the left edge (column index) and from the top edge (row index). Those two distances (column and row) are the key numbers that control the shape and size of the added pattern.</description>\n<example>If the anchor is at column 3 and row 4, note distances 3 (from left) and 4 (from top). Those two numbers will be used to determine how wide and how tall the added shape should be.</example>\n</note2>\n\n<note3>\n<description>Construct a filled rectangle whose width equals the column distance and whose height equals the row distance, and place that rectangle so its bottom-right corner coincides with the anchor. This turns the two distances into a rectangular block anchored at the original pixel.</description>\n<example>With column distance 3 and row distance 4, draw a 3×4 filled rectangle whose bottom-right corner sits on the anchor. The rectangle will extend leftward and upward from the anchor.</example>\n</note3>\n\n<note4>\n<description>Inside that rectangle, fill every cell that is not on the anchor's column or the anchor's row with a single contrasting color (a color distinct from the anchor and the background). The anchor's original color should remain on its column and row, while the rest of the rectangle is overwritten by the contrasting color.</description>\n<example>For a 3×4 rectangle anchored at the anchor, the anchor's column and row are left as the anchor color; every other cell inside the rectangle is set to the contrasting color, producing a two‑color rectangular motif.</example>\n</note4>\n\n<note5>\n<description>Preserve the grid size and all other cells; the added rectangle should not overlap the anchor's original color in unintended places. If the computed rectangle would extend outside the grid, clip it to the grid bounds.</description>\n<example>If the computed rectangle would reach beyond the right edge, simply draw the rectangle only within the grid. Also ensure the contrasting color does not accidentally overwrite other non-background pixels elsewhere in the grid.</example>\n</note5>","<note1>\n<description>Locate the seed: many ARC tasks use a single non-background pixel as the anchor for the transformation. Treat that pixel as the center of the operation rather than as an isolated outlier.</description>\n<example>Imagine a 7×7 grid with one colored pixel at (3,3). In the output you will see a new cluster of cells arranged around that same (3,3) position; start your reasoning from that single pixel.</example>\n</note1>\n\n<note2>\n<description>Check for a consistent extension: the seed is often extended into a vertical line downward and a horizontal line to the right. The seed itself typically remains the same color in the output.</description>\n<example>If the seed is at column c and row r, expect to see the same color in cells (r, c), (r+1, c), (r+2, c), ... and also in cells (r, c+1), (r, c+2), (r, c+3), ... — the seed is the starting point of both arms.</example>\n</note2>\n\n<note3>\n<description>Observe the diagonal band: between the vertical and horizontal arms there is a contiguous diagonal (cells with row−column = constant). That diagonal is filled with a different color from the seed and forms a triangular block.</description>\n<example>With seed at (r,c), the diagonal cells satisfy row−column = r−c. Those cells become a uniform color distinct from the seed; this creates a triangular region whose corner is at the seed.</example>\n</note3>\n\n<note4>\n<description>Identify the anchor offset (the corner): the diagonal and the arms meet at a corner that is a fixed offset from the seed in the examples. Find that offset by comparing where the diagonal first appears in the outputs relative to the seed.</description>\n<example>If the diagonal in the examples begins two rows below and two columns to the right of the seed, then for a new seed you should place the diagonal at those same offsets so the triangular region is aligned consistently.</example>\n</note4>\n\n<note5>\n<description>Watch for clipping and avoid overwriting: the arms and diagonal are truncated if they would fall outside the grid, and the seed is preserved. Use the training examples to infer which arm or diagonal is truncated and which color is used for the diagonal.</description>\n<example>When a seed is near an edge the downward arm will stop at the bottom row and the horizontal arm will stop at the rightmost column; the diagonal likewise stops where it would go out of bounds. Make sure you pick the diagonal color that is different from the seed and that the triangular region is not overwritten by other operations.</example>\n</note5>","<note1>\n<description>Locate the anchor: find the single non-background cell in the input. That cell's row and column index are the pivot for the transformation and determine where the new pattern will sit relative to the grid.</description>\n<example>Imagine a 6×6 grid with one red pixel at (row 2, column 3). Treat that coordinate as the anchor — everything you draw or place will be anchored at that location rather than at the grid center or another arbitrary point.</example>\n</note1>\n\n<note2>\n<description>Look for a directional extension: the examples show a vertical extension of the anchor's color that continues downward from the anchor. The anchor itself becomes the start of a straight downward column in that color.</description>\n<example>For a solitary blue pixel at (3,1), the output contains a vertical column of blue cells starting at row 3 and extending downward until the column reaches the grid bottom (or until a stopping condition is met).</example>\n</note2>\n\n<note3>\n<description>Identify the horizontal anchor: the anchor's column is also the leftmost column of a horizontal segment that spans to the right. That horizontal segment is aligned with the anchor's column and begins at the anchor's row.</description>\n<example>If the anchor is at (4,2), expect a horizontal run of the anchor color starting at row 4 and extending to the right, occupying cells in that row at columns 2, 3, 4, … until the run stops.</example>\n</note3>\n\n<note4>\n<description>Check for a fixed horizontal length: the horizontal extension is not arbitrary — it is always the same number of cells in width across the examples. Use that fixed width to determine how far to extend to the right from the anchor.</description>\n<example>Across the training pairs the horizontal run is the same length; if you see that length in the examples, replicate it when drawing the horizontal segment starting at the anchor's row and column.</example>\n</note4>\n\n<note5>\n<description>Observe the corner cell and color substitution: the cell at the anchor's coordinates is recolored to a distinct color (the examples use one consistent replacement color) and that replacement color is used only for that corner cell (not for the vertical or horizontal runs). This is a deliberate marker, not a continuation of the anchor color.</description>\n<example>When the anchor is at (5,0), change that single cell to the special marker color while leaving the vertical and horizontal runs in the original anchor color. Do not extend the marker color beyond that corner cell.</example>\n</note5>","<note1>\n<description>Start by locating the single non-background pixel in each input and treat it as the anchor of the transformation. Knowing that pixel's color and coordinates gives you the reference point for all subsequent operations.</description>\n<example>Imagine a 7×7 grid with one red pixel at (3,2). Record that color and coordinate; the rest of the transformation is built relative to that red pixel rather than to the grid edges.</example>\n</note1>\n\n<note2>\n<description>Look for a vertical extension: in the outputs the anchor is always part of a vertical run of the same color that extends downward. The length of that run is determined by the anchor's row and the grid's bottom edge.</description>\n<example>For example, if the anchor sits three rows from the bottom in a 7-row grid, the vertical run in the output will include that anchor plus the two cells immediately below it (so a 3-cell vertical segment).</example>\n</note2>\n\n<note3>\n<description>Observe that a horizontal segment is appended to the right of the vertical run and that this segment's length is one less than the vertical run. The horizontal segment is filled with a distinct marker color that is different from the anchor color.</description>\n<example>Continuing the previous example, with a 3-cell vertical run you would place a 2-cell horizontal run immediately to the right of the last vertical cell, using a second color (different from the anchor).</example>\n</note3>\n\n<note4>\n<description>Preserve the original anchor pixel's color and do not overwrite other non-background pixels. The vertical and horizontal additions are placed adjacent to the anchor so the original pixel remains unchanged and visible.</description>\n<example>If the anchor is blue, keep that blue cell intact; only add the vertical blue run and the horizontal marker run adjacent to it, leaving any other colored pixels as they were.</example>\n</note4>\n\n<note5>\n<description>Use simple counting rules to determine sizes: vertical run length = (distance from anchor to bottom) + 1, horizontal run length = vertical run length − 1. Apply these counts consistently to the test case to produce the same kind of modification.</description>\n<example>For a grid with the anchor two rows from the bottom, the vertical run will be three cells long and the horizontal run will be two cells long; place those runs adjacent to the anchor using the same relative layout seen in the examples.</example>\n</note5>","<note1>\n<description>Locate the anchor: the transformation is driven by a single non-background pixel in the input. Treat that pixel as the reference point for all subsequent steps.</description>\n<example>Imagine a grid with one isolated green pixel. In the output you will always see something positioned relative to that green pixel — so first identify that pixel before trying to infer the rest of the change.</example>\n</note1>\n\n<note2>\n<description>Observe the vertical extension: the anchor’s row is extended downward by a fixed number of cells (the examples always add three rows). The anchor’s column remains the same for those added cells.</description>\n<example>For example, if the anchor sits at row 4, the output will show three additional cells in row 4 (rows 4, 5, 6) occupying the same column as the anchor. That creates a vertical run anchored at the original position.</example>\n</note2>\n\n<note3>\n<description>Look for a horizontal run to the right: starting immediately to the right of the anchor, the anchor’s color is repeated a number of times that depends on the grid width (examples use the width minus 2). That horizontal run begins right next to the anchor and ends at the grid boundary.</description>\n<example>In a 7×7 grid you would repeat the anchor color 4 cells to its right (because 7−2 = 5, but the run length equals width−2). In a 9×9 grid you would repeat it 7 cells to the right.</example>\n</note3>\n\n<note4>\n<description>Check the connector color: the examples introduce a single new color that links the vertical and horizontal runs. That connector color is used to fill the cells between the anchor and the end of the horizontal run (i.e., the cells immediately adjacent to the anchor on the right side).</description>\n<example>If the anchor is blue and the connector is red, then the cell directly to the right of the anchor becomes red, and any connector-colored cells that lie between the anchor and the horizontal run’s end are also red — they visually join the vertical and horizontal components.</example>\n</note4>\n\n<note5>\n<description>Assemble the result by combining the anchor’s original vertical run, the horizontal run of the anchor color, and the connector-colored cells between them; leave all other cells unchanged. This produces a compact L-shaped motif centered on the original anchor.</description>\n<example>Practically, first draw the three vertical anchor-colored cells at the anchor’s column, then draw the horizontal run of the anchor color starting immediately to the right of the anchor, and finally fill the intervening cells (between the anchor and the horizontal end) with the connector color so the two runs meet smoothly.</example>\n</note5>","<note1>\n<description>Find the anchor: many ARC tasks start from a single non-background pixel. This pixel is usually the reference point for the transformation and is treated as the center or pivot of the change. Identifying that unique non-zero cell tells you where to look for the added structure.</description>\n<example>Imagine a mostly-empty grid with one blue pixel. That blue pixel is the anchor: the rest of the output pattern is built relative to that cell rather than to the grid edges. So first locate that unique colored pixel before trying to reconstruct the whole grid.</example>\n</note1>\n\n<note2>\n<description>Look for a consistent small motif: the output often shows a tiny, fixed pattern added around the anchor (a corner, a short arm, or a small L-shape). Determine the motif's orientation and how it is placed relative to the anchor. The motif is not arbitrary — it repeats the same shape in every example.</description>\n<example>For instance, if the outputs always show a short horizontal bar plus a vertical bar meeting at the anchor, treat that combined corner motif as the added element. Once you see it in one example, expect the same motif in others rather than inventing a new shape.</example>\n</note2>\n\n<note3>\n<description>Check color rules: the added motif uses one color that is distinct from the anchor and the background, while the anchor itself may be recolored in the outputs. Recognize that a single color is reused for the motif across examples, and the anchor is consistently replaced by a different color.</description>\n<example>If the input has a green anchor and the outputs show a red motif, then you should add the red motif and change the original green anchor to the other color. This separation of anchor and motif colors is a reliable clue for how to recolor cells.</example>\n</note3>\n\n<note4>\n<description>Verify placement rules: the motif is anchored at the original cell and its arms extend along the two orthogonal directions (for example, left and down). The motif's extent (how many cells along each arm) is constant across examples and is the same for every anchor. Use that fixed size to draw the motif.</description>\n<example>Suppose every example shows a motif that occupies three cells to the left and three cells downward from the anchor. Then for a new anchor you would place the same three-left, three-down cells (not more or fewer) relative to the anchor.</example>\n</note4>\n\n<note5>\n<description>Handle edge cases and preserve background: if the motif would extend beyond the grid, it is clipped; otherwise the motif is drawn and the original anchor is removed (replaced by the other color). Also, do not alter any other cells — only the motif and the anchor should change. This keeps the transformation unambiguous.</description>\n<example>If the anchor sits on the top row, the motif cannot extend upward and only the downward portion appears; the rest of the grid stays background. If the anchor is interior, the full motif appears and the original anchor color is replaced by the second color while the motif uses the motif color.</example>\n</note5>","<note1>\n<description>Start by isolating the unique colored pixel in the input: it acts as the anchor for the transformation. Its color and coordinates are the reference that the rest of the change is built around.</description>\n<example>Imagine a grid with one red pixel. Treat that red pixel as the center of the operation — note its color and its row/column — because the rest of the output is positioned relative to that single pixel.</example>\n</note1>\n\n<note2>\n<description>Look for a single-column vertical bar whose top cell is directly above the anchor and whose bottom cell is directly below it. That bar is placed flush with the anchor's column and spans the full vertical extent of the grid.</description>\n<example>If the anchor is at row r in column c, imagine a column of pixels extending from row 0 to the last row: its top cell is at (0,c) and its bottom cell is at (last_row,c). This full-height column is the vertical connector used in the examples.</example>\n</note2>\n\n<note3>\n<description>Next, place a horizontal segment of identical color immediately to the right of the anchor. The length of that horizontal segment is determined by the anchor's row index (counting upward from the bottom): the higher the anchor, the longer the horizontal run.</description>\n<example>For example, if the anchor is two rows from the bottom, you would draw a horizontal run of two cells to its right; if it is three rows from the bottom, draw three cells. The run always starts at the anchor's column and extends rightward.</example>\n</note3>\n\n<note4>\n<description>Combine the two elements: the full-height vertical bar and the horizontal run share the same color as the anchor. In the outputs these two pieces are contiguous — the horizontal bar sits immediately adjacent to the vertical bar.</description>\n<example>So you would color the vertical column (top to bottom) and color the horizontal segment next to it, using the anchor's color. The result is a clear vertical connector with a horizontal extension placed at the anchor's right edge.</example>\n</note4>\n\n<note5>\n<description>Handle edge cases and validate: the horizontal segment cannot exceed the grid width, and the anchor's color is reused for both bars (not a new color). Also, the top of the vertical bar is always at the top of the grid.</description>\n<example>If the anchor is on the last row, the horizontal run is just one cell (the anchor itself). If the anchor is very high up, the horizontal run can be long but must still be drawn immediately to the right of the anchor and cannot overwrite other non-background pixels.</example>\n</note5>","<note1>\n<description>Look first for the unique non-background cell: when a grid contains exactly one colored pixel, that pixel is usually the anchor for the transformation. Treat that pixel as the reference point for all subsequent placement decisions.</description>\n<example>Imagine a 7×7 grid with a single red pixel at some coordinate. In many tasks that red pixel is not erased but is the starting point for creating additional colored cells around it; so locate that pixel before you try to place any new shapes.</example>\n</note1>\n\n<note2>\n<description>Check whether the anchor is preserved and whether it is also the color of a new connected region. If the anchor remains visible and also appears elsewhere in the output, the anchor color is likely reused to form a larger object rather than being replaced by a different color.</description>\n<example>For instance, if a single green pixel appears again as a contiguous block in the output, that suggests you should use the same green color to build the larger shape while keeping the original green pixel as part of that shape.</example>\n</note2>\n\n<note3>\n<description>Examine the local neighborhood of the anchor for a consistent geometric pattern: the added pixels often form a short, straight run (a small horizontal or vertical line) adjacent to the anchor and then continue in a consistent diagonal direction (down‑right or down‑left). This creates a small right‑angled or L‑shaped motif.</description>\n<example>Picture a single blue pixel and then observe a few blue pixels immediately to its right and then further blue pixels below those right‑adjacent ones; that pattern indicates a horizontal arm followed by a downward diagonal arm.</example>\n</note3>\n\n<note4>\n<description>Observe the color used for the new cells: the added motif is frequently a single color distinct from the anchor color and is consistent across examples. That secondary color is applied to the new pixels and is not used for the anchor itself.</description>\n<example>If the anchor is yellow and the output shows a new contiguous cluster of a different color (say, purple) around it, then purple is the motif color to use when you recreate the same local pattern elsewhere.</example>\n</note4>\n\n<note5>\n<description>Apply the same relative placement and orientation to the test input: use the anchor's coordinate as the origin, draw the horizontal segment of the motif immediately adjacent to the anchor, then continue the motif in the same diagonal direction until you reach the grid edge or until the motif stops (examples usually show it stopping at the border).</description>\n<example>For example, if the anchor is at (r,c), place the motif’s first cell at (r,c+1), then place subsequent motif cells at (r+1,c+2), (r+2,c+3), etc., stopping when you run out of grid space—this reproduces the same local L‑shape seen in the examples.</example>\n</note5>","<note1>\n<description>Locate the anchor: every example begins with a single non-black pixel. That pixel is the reference point for the transformation and should be treated as the center of the change.</description>\n<example>Imagine a grid with one blue pixel at (row 3, col 4). Mark that cell as the anchor and do not move it — all subsequent additions will be positioned relative to it.</example>\n</note1>\n\n<note2>\n<description>Identify the marker color: the outputs introduce a new color that does not appear in the inputs. This marker is used to draw the new shape and is distinct from the anchor color.</description>\n<example>If the input contains only black and one red pixel, the output will add a green marker to form the new pattern. Treat green as the marker color and do not confuse it with the red anchor.</example>\n</note2>\n\n<note3>\n<description>Decide the orientation: the marker is placed along the row immediately above the anchor, and the marker extends to the right from the anchor's column. In other words, the new shape is a horizontal run anchored at the anchor's column, starting at the row above.</description>\n<example>With an anchor at (r,c), place marker pixels at (r-1,c), (r-1,c+1), (r-1,c+2), … until the grid edge; the anchor itself remains at (r,c).</example>\n</note3>\n\n<note4>\n<description>Use a fixed-length rule: the run of marker pixels has a consistent length across examples (three pixels). That length is independent of the grid size and should be applied uniformly.</description>\n<example>From the anchor at (r,c) you will always place three marker pixels to the right of the anchor's column in the row above, regardless of how many columns are available.</example>\n</note4>\n\n<note5>\n<description>Handle boundaries and preserve the anchor: if the marker run would extend past the grid edge, stop at the edge. The original anchor pixel is not removed and remains as part of the output.</description>\n<example>If the anchor is at the leftmost column, you can only place markers to the right that fit inside the grid; if the grid has more columns, place the full three markers as shown above. Always keep the anchor pixel unchanged.</example>\n</note5>","<note1>\n<description>Locate the anchor: many ARC tasks start from a single non-background pixel. Treat that pixel as the pivot or reference point for the transformation.</description>\n<example>Imagine a grid with one colored pixel at (r,c). Before changing anything, record its color and coordinates — this pixel is what the rule will expand or use as a reference to build the output.</example>\n</note1>\n\n<note2>\n<description>Look for a fixed offset: the transformation often places a new pixel one cell away from the anchor in the same row. In other words, the new pixel is at the same row but one column to the right.</description>\n<example>For an anchor at column c, expect a new pixel at (r, c+1). If the grid is wide enough, that right-side placement is consistent across examples; if not, the rule may be constrained by boundaries.</example>\n</note2>\n\n<note3>\n<description>Examine the horizontal run: the cell immediately to the right of the anchor is usually filled with the anchor's own color, forming a contiguous horizontal segment of length 4. The anchor's original cell is the leftmost of that run.</description>\n<example>If the anchor is red, you should see a horizontal run red-red-red-red starting at the anchor and extending to its right. The anchor's color is preserved at its original location and duplicated to the right.</example>\n</note3>\n\n<note4>\n<description>Check the vertical extension: below the anchor, a vertical column of the anchor's color is added, aligned under the anchor's column. This column typically has a fixed height (commonly 3 cells) and sits directly below the anchor.</description>\n<example>With an anchor at row r, expect a vertical stripe of the anchor color at column c, occupying rows r+1, r+2, r+3 (if those rows exist). That vertical stripe is distinct from the horizontal run and uses the same color.</example>\n</note4>\n\n<note5>\n<description>Use a distinct marker for the pivot: the anchor's original position is recolored to a single other color (different from the anchor's color) so it stands out as the pivot. This helps separate the pivot from the duplicated horizontal and vertical segments.</description>\n<example>If the anchor is blue, change the original blue pixel to a different color (for example, a marker color) while leaving the horizontal run and vertical stripe in blue. The marker makes the pivot visually distinct from the repeated pattern.</example>\n</note5>","<note1>\n<description>Look for a single non-background pixel that acts as the anchor. When an input has exactly one colored cell, that cell is usually the pivot around which the output is built and should be preserved.</description>\n<example>If a 6×6 grid contains one green pixel at (2,2), treat (2,2) as the center of the transformation. The rest of the output will be constructed relative to that same coordinate rather than being a new, unrelated shape.</example>\n</note1>\n\n<note2>\n<description>Check whether the output contains a uniform one-pixel-wide vertical band that runs from the top of the grid to the anchor row. This band is a consistent vertical feature that appears in the outputs.</description>\n<example>On a 7-row grid, if the anchor is at row 4, the output will show a continuous vertical column of the same color occupying rows 0–4 (a 5-row vertical band) and that column will be at the same column as the anchor.</example>\n</note2>\n\n<note3>\n<description>Observe the horizontal extension: the anchor's column is expanded to the right by a fixed number of adjacent cells, forming a contiguous horizontal block. The block's length is constant across examples and independent of the grid width.</description>\n<example>If the anchor is at column 3, the output will include the original anchor cell plus three cells to its right, so the horizontal run is 4 cells long; if the anchor is near the right edge, the block simply uses available cells.</example>\n</note3>\n\n<note4>\n<description>Verify color consistency: the vertical band and the horizontal run are the same color, while the original anchor keeps its original color. The transformation uses two distinct colors — one for the vertical band and one for the horizontal run — and the anchor's color is preserved.</description>\n<example>Suppose the anchor is red and the new color used for the band is blue; the vertical column is blue and the horizontal run is also blue, but the anchor cell remains red. Identifying these two roles helps you apply the rule correctly.</example>\n</note4>\n\n<note5>\n<description>Handle boundaries and preserve the original grid size: if the horizontal run would exceed the grid width, it is truncated to the available cells; the vertical band is always anchored at the anchor's column and is clipped at the grid's top and bottom as needed.</description>\n<example>If the anchor is at the rightmost column, the horizontal run cannot extend further right and is simply left as a single cell; the vertical band still starts at the top and runs down to the anchor row.</example>\n</note5>","<note1>\n<description>Locate the anchor: the transformation is driven by a single colored pixel in the input. Treat that pixel as the pivot point for the change and ignore other zeros or stray colors.</description>\n<example>If an input contains exactly one green pixel, that green pixel is the anchor. All subsequent edits in the output are positioned relative to that green pixel rather than to other colors or the grid edges.</example>\n</note1>\n<note2>\n<description>Look for a small, symmetric motif around the anchor: the examples show a 3×3 square centered on the anchor. That motif is not a simple enlargement of the original pixel but a consistent local shape centered on the anchor.</description>\n<example>Imagine a lone red pixel; the output shows a small square of red cells surrounding the red pixel (with the red pixel at the motif center). The motif is the same relative pattern in each example regardless of the original color.</example>\n</note2>\n<note3>\n<description>One cell of the motif is replaced by a distinct marker color: the output contains a single cell of a new color adjacent to the anchor (the same marker in every example). This marker is not the anchor color and is used to highlight the motif's placement.</description>\n<example>For a blue anchor, the motif in the output has one blue cell turned into a different color (call it marker M) so the motif becomes visually distinct. That marker M appears in the same relative position in every example.</example>\n</note3>\n<note4>\n<description>Decide which side of the anchor receives the marker by comparing examples: the marker is placed on the same side of the anchor in all training pairs. Use that consistent side to place the marker in the test case.</description>\n<example>If in every example the marker is always on the anchor's right (positive column direction), then when you place the 3×3 motif on the test anchor you must put the marker in the same right-side cell of that motif.</example>\n</note4>\n<note5>\n<description>Apply the motif and marker to the test input: center a 3×3 motif on the anchor, recolor one motif cell to the marker, and leave all other cells unchanged. If the motif would extend beyond the grid, the transformation still uses the same relative placement rule.</description>\n<example>On a new input with a lone yellow pixel, build the 3×3 centered on that pixel, change the designated adjacent cell to the marker color, and keep the rest of the grid as it was. If the grid is smaller, the motif is clipped by the grid boundary but the rule of centering and marker placement remains.</example>\n</note5>","<note1>\n<description>Find the anchor: when a grid contains exactly one non-background pixel, that pixel is usually the reference point for the transformation. Treat it as the pivot around which new structure is built.</description>\n<example>Imagine a 5×5 grid with a single red pixel at (2,2). In many tasks that red pixel is the center of the change rather than an isolated noise; so first record its coordinates and color before looking at the rest of the grid.</example>\n</note1>\n\n<note2>\n<description>Look for a fixed offset (a constant vector) that is added to the anchor in the outputs: the anchor is often moved by the same small displacement in every example. Finding that offset tells you where the original pixel ends up.</description>\n<example>If in several examples the single pixel is consistently one cell down and one cell left from where it was in the inputs, then the transformation includes a translation by (−1,−1). Use that observed vector to predict the new location of the anchor in the test case.</example>\n</note2>\n\n<note3>\n<description>Check whether the anchor’s color is reused to form a new object: the original color is frequently used to draw a contiguous block (a filled rectangle or similar) anchored at the translated position. The block’s shape and extent are consistent across examples.</description>\n<example>For instance, if the anchor color is blue, you may see a small filled rectangle of blue pixels centered at the translated anchor location in every output. That suggests the rule is “repaint a block using the anchor color at the translated position.”</example>\n</note3>\n\n<note4>\n<description>Use the anchor’s row as a horizontal anchor for the block: the block’s width (and often its left edge) is determined by the anchor’s row index rather than by the grid width. This gives a simple formula for how many columns the block will occupy.</description>\n<example>If the anchor sits in row r, then the block’s width (or the column where it begins) can be computed from r (for example, width = 5 − r). Apply that same relationship to the test anchor’s row to decide how wide the block should be.</example>\n</note4>\n\n<note5>\n<description>Handle overlaps and edge cases consistently: if the computed block would extend outside the grid, clip it; if it would overlap the original anchor, decide whether to overwrite it or keep both colors according to the examples. Always apply the same clipping/overwriting rule to the test case.</description>\n<example>If the block would start at column −1 because of a small r, simply start at column 0. If the block would cover the original anchor cell, check the training outputs to see whether the original color was overwritten by the block or preserved—then use that same rule when building the test block.</example>\n</note5>","<note1>\n<description>Spot the anchor: many tasks start from a single non-background pixel. That pixel is the reference point for the transformation and usually remains the same color in the output.</description>\n<example>Imagine a grid with one blue pixel on a black background. In the output you should still see a blue pixel in the same place — treat that blue pixel as the center or anchor of the change.</example>\n</note1>\n\n<note2>\n<description>Look for a one-cell extension in the anchor’s row: the anchor’s row often gains one additional cell immediately to its right. This is a consistent horizontal change you can detect across examples.</description>\n<example>For a solitary red pixel at column c in row r, check whether the output shows a red pixel at (r, c+1). If so, that extra red cell is part of the transformation and should be included when you recreate the output.</example>\n</note2>\n\n<note3>\n<description>Observe the anchor’s column becoming a vertical bar: the column of the anchor is filled with the same color downward from the anchor. This produces a vertical segment anchored at the original pixel.</description>\n<example>If the anchor is green at (r,c), examine the output for green pixels at (r+1,c), (r+2,c), etc. Those consecutive green cells form the vertical bar and are added to the grid.</example>\n</note3>\n\n<note4>\n<description>Check for a horizontal run extending to the right from the anchor: one cell to the right of the anchor is usually expanded into a contiguous horizontal block of the anchor color that reaches the grid edge. Think “extend one cell to the right and fill the rest.”</description>\n<example>With a yellow anchor at (r,c), you might find a horizontal run of yellow cells starting at (r,c+1) and continuing until the rightmost column. That run is continuous and ends at the grid boundary.</example>\n</note4>\n\n<note5>\n<description>Combine the pieces and watch for overlap rules: the anchor, its right-neighbor, and the vertical bar are all the same color; if the vertical bar and the horizontal run meet, they form a T-like shape. Always use the anchor’s color for all added cells.</description>\n<example>When the anchor is orange, expect orange cells at the anchor, orange at (r,c+1), and orange cells below the anchor on its column. If the horizontal run and vertical bar cross, the intersection remains orange; do not introduce a different color there.</example>\n</note5>","<note1>\n<description>Locate the anchor: in these examples there is exactly one non‑black cell that serves as the reference point for the whole transformation. Its coordinates (row, column) determine where the new structure is placed and oriented.</description>\n<example>Imagine a grid with a single red pixel. That pixel is not merely decorative; it is the pivot for everything that follows. Treat its row and column as the origin when you reason about where to draw any new shape.</example>\n</note1>\n\n<note2>\n<description>Look for a one‑pixel vertical extension: the output always adds one pixel directly above the anchor. This vertical segment is consistent across examples and establishes the top anchor for the rest of the pattern.</description>\n<example>If the anchor is at (r,c), you should add a pixel at (r−1,c) in the same column. That single top pixel is the first element of the structure and is always present in the outputs.</example>\n</note2>\n\n<note3>\n<description>Extend the anchor's color to the right into a contiguous horizontal run: the anchor's color is propagated to several adjacent columns on its same row, forming a horizontal bar that begins immediately to the right of the top anchor.</description>\n<example>With the anchor at (r,c), color the cells (r,c+1), (r,c+2), ... up to some length L until you stop. The bar is contiguous and starts right next to the newly added top pixel.</example>\n</note3>\n\n<note4>\n<description>Build a vertical column of the anchor color to the left of the top anchor: a straight column (same column, successive rows) is drawn starting at the top anchor and extending downward, using the anchor's original color.</description>\n<example>From the top anchor at (r,c), color (r+1,c), (r+2,c), ... down the grid until you reach the grid boundary. This creates a downward vertical stripe adjacent to the top anchor.</example>\n</note4>\n\n<note5>\n<description>Combine the pieces and check invariants: the final pattern is the union of the top anchor, the horizontal bar, and the downward vertical column; these three elements meet at the anchor and form a compact motif. Preserve the anchor's original color for the bar and vertical column and do not change other colors.</description>\n<example>Imagine placing the top pixel, then the horizontal run to its right, and then the vertical column below it — together they form a small, consistent shape anchored at the original cell. After assembling, verify the motif matches the examples' layout and that the anchor color was used consistently for the bar and column.</example>\n</note5>","<note1>\n<description>Locate the anchor: many tasks start from a single non-background pixel. That pixel is usually the pivot or reference point for the transformation and is rarely moved or removed.</description>\n<example>Imagine a 7×7 grid with one red pixel at (row 3, column 4). In the output that red pixel remains at the same coordinates and serves as the center of the change; everything else is built around it rather than replacing it.</example>\n</note1>\n\n<note2>\n<description>Look for a vertical bar: the output often adds a straight vertical segment that extends downward from the anchor. The bar’s length is determined by the anchor’s column and the grid’s bottom edge, not by the original pixel’s color.</description>\n<example>For example, if the anchor sits in column 3 of an 8-row grid, the output will place a vertical bar in column 3 that reaches from the anchor down to the last row, forming a continuous column of the bar color.</example>\n</note2>\n\n<note3>\n<description>Observe a horizontal extension: immediately to the right of the anchor a contiguous horizontal segment of a different color appears. The length of that horizontal segment is a fixed offset from the anchor (the same offset across examples), and it is always placed to the anchor’s right.</description>\n<example>If the anchor is in column 4, the output shows a horizontal run of length 4 starting at column 5 and extending to the right (e.g., columns 5–8). If the anchor were in column 2, the horizontal run would start at column 3 and extend right by the same fixed amount.</example>\n</note3>\n\n<note4>\n<description>Check the colors used: the vertical bar is a single distinct color, the horizontal run uses a second distinct color, and the anchor keeps its original color. These color roles are consistent across examples and should be treated as fixed roles rather than derived from the anchor’s value.</description>\n<example>Suppose the anchor is blue; you should place a vertical bar of one consistent color (say green) and a horizontal run of another consistent color (say yellow), leaving the original blue pixel unchanged. The important point is the role of colors, not which numeric color happens to be chosen.</example>\n</note4>\n\n<note5>\n<description>Preserve the background and handle edges: leave all other cells as the background color (usually 0), and clip any added segments to the grid boundaries. If the horizontal run would extend beyond the right edge, it simply occupies whatever columns remain.</description>\n<example>If the horizontal run would need to span 5 columns but only 3 columns are available to the right of the anchor, place the run on the available columns only; the vertical bar is always anchored at the anchor’s column and extends down to the grid bottom.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Start by locating the single non-background pixel in the input and treat it as the anchor of the transformation. Its row and column index determine where any new structure will be placed relative to the grid.</description>\\n<example>Imagine a 7×7 grid with one blue pixel at (row 3, column 4). Record that coordinate — it will be the pivot for where the output pattern is anchored and where you measure distances.</example>\\n</note1>\\n\\n<note2>\\n<description>Measure the anchor's distance from the left edge (column index) and from the top edge (row index). Those two distances (column and row) are the key numbers that control the shape and size of the added pattern.</description>\\n<example>If the anchor is at column 3 and row 4, note distances 3 (from left) and 4 (from top). Those two numbers will be used to determine how wide and how tall the added shape should be.</example>\\n</note2>\\n\\n<note3>\\n<description>Construct a filled rectangle whose width equals the column distance and whose height equals the row distance, and place that rectangle so its bottom-right corner coincides with the anchor. This turns the two distances into a rectangular block anchored at the original pixel.</description>\\n<example>With column distance 3 and row distance 4, draw a 3×4 filled rectangle whose bottom-right corner sits on the anchor. The rectangle will extend leftward and upward from the anchor.</example>\\n</note3>\\n\\n<note4>\\n<description>Inside that rectangle, fill every cell that is not on the anchor's column or the anchor's row with a single contrasting color (a color distinct from the anchor and the background). The anchor's original color should remain on its column and row, while the rest of the rectangle is overwritten by the contrasting color.</description>\\n<example>For a 3×4 rectangle anchored at the anchor, the anchor's column and row are left as the anchor color; every other cell inside the rectangle is set to the contrasting color, producing a two‑color rectangular motif.</example>\\n</note4>\\n\\n<note5>\\n<description>Preserve the grid size and all other cells; the added rectangle should not overlap the anchor's original color in unintended places. If the computed rectangle would extend outside the grid, clip it to the grid bounds.</description>\\n<example>If the computed rectangle would reach beyond the right edge, simply draw the rectangle only within the grid. Also ensure the contrasting color does not accidentally overwrite other non-background pixels elsewhere in the grid.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the seed: many ARC tasks use a single non-background pixel as the anchor for the transformation. Treat that pixel as the center of the operation rather than as an isolated outlier.</description>\\n<example>Imagine a 7×7 grid with one colored pixel at (3,3). In the output you will see a new cluster of cells arranged around that same (3,3) position; start your reasoning from that single pixel.</example>\\n</note1>\\n\\n<note2>\\n<description>Check for a consistent extension: the seed is often extended into a vertical line downward and a horizontal line to the right. The seed itself typically remains the same color in the output.</description>\\n<example>If the seed is at column c and row r, expect to see the same color in cells (r, c), (r+1, c), (r+2, c), ... and also in cells (r, c+1), (r, c+2), (r, c+3), ... — the seed is the starting point of both arms.</example>\\n</note2>\\n\\n<note3>\\n<description>Observe the diagonal band: between the vertical and horizontal arms there is a contiguous diagonal (cells with row−column = constant). That diagonal is filled with a different color from the seed and forms a triangular block.</description>\\n<example>With seed at (r,c), the diagonal cells satisfy row−column = r−c. Those cells become a uniform color distinct from the seed; this creates a triangular region whose corner is at the seed.</example>\\n</note3>\\n\\n<note4>\\n<description>Identify the anchor offset (the corner): the diagonal and the arms meet at a corner that is a fixed offset from the seed in the examples. Find that offset by comparing where the diagonal first appears in the outputs relative to the seed.</description>\\n<example>If the diagonal in the examples begins two rows below and two columns to the right of the seed, then for a new seed you should place the diagonal at those same offsets so the triangular region is aligned consistently.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for clipping and avoid overwriting: the arms and diagonal are truncated if they would fall outside the grid, and the seed is preserved. Use the training examples to infer which arm or diagonal is truncated and which color is used for the diagonal.</description>\\n<example>When a seed is near an edge the downward arm will stop at the bottom row and the horizontal arm will stop at the rightmost column; the diagonal likewise stops where it would go out of bounds. Make sure you pick the diagonal color that is different from the seed and that the triangular region is not overwritten by other operations.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the anchor: find the single non-background cell in the input. That cell's row and column index are the pivot for the transformation and determine where the new pattern will sit relative to the grid.</description>\\n<example>Imagine a 6×6 grid with one red pixel at (row 2, column 3). Treat that coordinate as the anchor — everything you draw or place will be anchored at that location rather than at the grid center or another arbitrary point.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a directional extension: the examples show a vertical extension of the anchor's color that continues downward from the anchor. The anchor itself becomes the start of a straight downward column in that color.</description>\\n<example>For a solitary blue pixel at (3,1), the output contains a vertical column of blue cells starting at row 3 and extending downward until the column reaches the grid bottom (or until a stopping condition is met).</example>\\n</note2>\\n\\n<note3>\\n<description>Identify the horizontal anchor: the anchor's column is also the leftmost column of a horizontal segment that spans to the right. That horizontal segment is aligned with the anchor's column and begins at the anchor's row.</description>\\n<example>If the anchor is at (4,2), expect a horizontal run of the anchor color starting at row 4 and extending to the right, occupying cells in that row at columns 2, 3, 4, … until the run stops.</example>\\n</note3>\\n\\n<note4>\\n<description>Check for a fixed horizontal length: the horizontal extension is not arbitrary — it is always the same number of cells in width across the examples. Use that fixed width to determine how far to extend to the right from the anchor.</description>\\n<example>Across the training pairs the horizontal run is the same length; if you see that length in the examples, replicate it when drawing the horizontal segment starting at the anchor's row and column.</example>\\n</note4>\\n\\n<note5>\\n<description>Observe the corner cell and color substitution: the cell at the anchor's coordinates is recolored to a distinct color (the examples use one consistent replacement color) and that replacement color is used only for that corner cell (not for the vertical or horizontal runs). This is a deliberate marker, not a continuation of the anchor color.</description>\\n<example>When the anchor is at (5,0), change that single cell to the special marker color while leaving the vertical and horizontal runs in the original anchor color. Do not extend the marker color beyond that corner cell.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by locating the single non-background pixel in each input and treat it as the anchor of the transformation. Knowing that pixel's color and coordinates gives you the reference point for all subsequent operations.</description>\\n<example>Imagine a 7×7 grid with one red pixel at (3,2). Record that color and coordinate; the rest of the transformation is built relative to that red pixel rather than to the grid edges.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a vertical extension: in the outputs the anchor is always part of a vertical run of the same color that extends downward. The length of that run is determined by the anchor's row and the grid's bottom edge.</description>\\n<example>For example, if the anchor sits three rows from the bottom in a 7-row grid, the vertical run in the output will include that anchor plus the two cells immediately below it (so a 3-cell vertical segment).</example>\\n</note2>\\n\\n<note3>\\n<description>Observe that a horizontal segment is appended to the right of the vertical run and that this segment's length is one less than the vertical run. The horizontal segment is filled with a distinct marker color that is different from the anchor color.</description>\\n<example>Continuing the previous example, with a 3-cell vertical run you would place a 2-cell horizontal run immediately to the right of the last vertical cell, using a second color (different from the anchor).</example>\\n</note3>\\n\\n<note4>\\n<description>Preserve the original anchor pixel's color and do not overwrite other non-background pixels. The vertical and horizontal additions are placed adjacent to the anchor so the original pixel remains unchanged and visible.</description>\\n<example>If the anchor is blue, keep that blue cell intact; only add the vertical blue run and the horizontal marker run adjacent to it, leaving any other colored pixels as they were.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple counting rules to determine sizes: vertical run length = (distance from anchor to bottom) + 1, horizontal run length = vertical run length − 1. Apply these counts consistently to the test case to produce the same kind of modification.</description>\\n<example>For a grid with the anchor two rows from the bottom, the vertical run will be three cells long and the horizontal run will be two cells long; place those runs adjacent to the anchor using the same relative layout seen in the examples.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the anchor: the transformation is driven by a single non-background pixel in the input. Treat that pixel as the reference point for all subsequent steps.</description>\\n<example>Imagine a grid with one isolated green pixel. In the output you will always see something positioned relative to that green pixel — so first identify that pixel before trying to infer the rest of the change.</example>\\n</note1>\\n\\n<note2>\\n<description>Observe the vertical extension: the anchor’s row is extended downward by a fixed number of cells (the examples always add three rows). The anchor’s column remains the same for those added cells.</description>\\n<example>For example, if the anchor sits at row 4, the output will show three additional cells in row 4 (rows 4, 5, 6) occupying the same column as the anchor. That creates a vertical run anchored at the original position.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a horizontal run to the right: starting immediately to the right of the anchor, the anchor’s color is repeated a number of times that depends on the grid width (examples use the width minus 2). That horizontal run begins right next to the anchor and ends at the grid boundary.</description>\\n<example>In a 7×7 grid you would repeat the anchor color 4 cells to its right (because 7−2 = 5, but the run length equals width−2). In a 9×9 grid you would repeat it 7 cells to the right.</example>\\n</note3>\\n\\n<note4>\\n<description>Check the connector color: the examples introduce a single new color that links the vertical and horizontal runs. That connector color is used to fill the cells between the anchor and the end of the horizontal run (i.e., the cells immediately adjacent to the anchor on the right side).</description>\\n<example>If the anchor is blue and the connector is red, then the cell directly to the right of the anchor becomes red, and any connector-colored cells that lie between the anchor and the horizontal run’s end are also red — they visually join the vertical and horizontal components.</example>\\n</note4>\\n\\n<note5>\\n<description>Assemble the result by combining the anchor’s original vertical run, the horizontal run of the anchor color, and the connector-colored cells between them; leave all other cells unchanged. This produces a compact L-shaped motif centered on the original anchor.</description>\\n<example>Practically, first draw the three vertical anchor-colored cells at the anchor’s column, then draw the horizontal run of the anchor color starting immediately to the right of the anchor, and finally fill the intervening cells (between the anchor and the horizontal end) with the connector color so the two runs meet smoothly.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the anchor: many ARC tasks start from a single non-background pixel. This pixel is usually the reference point for the transformation and is treated as the center or pivot of the change. Identifying that unique non-zero cell tells you where to look for the added structure.</description>\\n<example>Imagine a mostly-empty grid with one blue pixel. That blue pixel is the anchor: the rest of the output pattern is built relative to that cell rather than to the grid edges. So first locate that unique colored pixel before trying to reconstruct the whole grid.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a consistent small motif: the output often shows a tiny, fixed pattern added around the anchor (a corner, a short arm, or a small L-shape). Determine the motif's orientation and how it is placed relative to the anchor. The motif is not arbitrary — it repeats the same shape in every example.</description>\\n<example>For instance, if the outputs always show a short horizontal bar plus a vertical bar meeting at the anchor, treat that combined corner motif as the added element. Once you see it in one example, expect the same motif in others rather than inventing a new shape.</example>\\n</note2>\\n\\n<note3>\\n<description>Check color rules: the added motif uses one color that is distinct from the anchor and the background, while the anchor itself may be recolored in the outputs. Recognize that a single color is reused for the motif across examples, and the anchor is consistently replaced by a different color.</description>\\n<example>If the input has a green anchor and the outputs show a red motif, then you should add the red motif and change the original green anchor to the other color. This separation of anchor and motif colors is a reliable clue for how to recolor cells.</example>\\n</note3>\\n\\n<note4>\\n<description>Verify placement rules: the motif is anchored at the original cell and its arms extend along the two orthogonal directions (for example, left and down). The motif's extent (how many cells along each arm) is constant across examples and is the same for every anchor. Use that fixed size to draw the motif.</description>\\n<example>Suppose every example shows a motif that occupies three cells to the left and three cells downward from the anchor. Then for a new anchor you would place the same three-left, three-down cells (not more or fewer) relative to the anchor.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle edge cases and preserve background: if the motif would extend beyond the grid, it is clipped; otherwise the motif is drawn and the original anchor is removed (replaced by the other color). Also, do not alter any other cells — only the motif and the anchor should change. This keeps the transformation unambiguous.</description>\\n<example>If the anchor sits on the top row, the motif cannot extend upward and only the downward portion appears; the rest of the grid stays background. If the anchor is interior, the full motif appears and the original anchor color is replaced by the second color while the motif uses the motif color.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by isolating the unique colored pixel in the input: it acts as the anchor for the transformation. Its color and coordinates are the reference that the rest of the change is built around.</description>\\n<example>Imagine a grid with one red pixel. Treat that red pixel as the center of the operation — note its color and its row/column — because the rest of the output is positioned relative to that single pixel.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a single-column vertical bar whose top cell is directly above the anchor and whose bottom cell is directly below it. That bar is placed flush with the anchor's column and spans the full vertical extent of the grid.</description>\\n<example>If the anchor is at row r in column c, imagine a column of pixels extending from row 0 to the last row: its top cell is at (0,c) and its bottom cell is at (last_row,c). This full-height column is the vertical connector used in the examples.</example>\\n</note2>\\n\\n<note3>\\n<description>Next, place a horizontal segment of identical color immediately to the right of the anchor. The length of that horizontal segment is determined by the anchor's row index (counting upward from the bottom): the higher the anchor, the longer the horizontal run.</description>\\n<example>For example, if the anchor is two rows from the bottom, you would draw a horizontal run of two cells to its right; if it is three rows from the bottom, draw three cells. The run always starts at the anchor's column and extends rightward.</example>\\n</note3>\\n\\n<note4>\\n<description>Combine the two elements: the full-height vertical bar and the horizontal run share the same color as the anchor. In the outputs these two pieces are contiguous — the horizontal bar sits immediately adjacent to the vertical bar.</description>\\n<example>So you would color the vertical column (top to bottom) and color the horizontal segment next to it, using the anchor's color. The result is a clear vertical connector with a horizontal extension placed at the anchor's right edge.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle edge cases and validate: the horizontal segment cannot exceed the grid width, and the anchor's color is reused for both bars (not a new color). Also, the top of the vertical bar is always at the top of the grid.</description>\\n<example>If the anchor is on the last row, the horizontal run is just one cell (the anchor itself). If the anchor is very high up, the horizontal run can be long but must still be drawn immediately to the right of the anchor and cannot overwrite other non-background pixels.</example>\\n</note5>\",\n \"<note1>\\n<description>Look first for the unique non-background cell: when a grid contains exactly one colored pixel, that pixel is usually the anchor for the transformation. Treat that pixel as the reference point for all subsequent placement decisions.</description>\\n<example>Imagine a 7×7 grid with a single red pixel at some coordinate. In many tasks that red pixel is not erased but is the starting point for creating additional colored cells around it; so locate that pixel before you try to place any new shapes.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the anchor is preserved and whether it is also the color of a new connected region. If the anchor remains visible and also appears elsewhere in the output, the anchor color is likely reused to form a larger object rather than being replaced by a different color.</description>\\n<example>For instance, if a single green pixel appears again as a contiguous block in the output, that suggests you should use the same green color to build the larger shape while keeping the original green pixel as part of that shape.</example>\\n</note2>\\n\\n<note3>\\n<description>Examine the local neighborhood of the anchor for a consistent geometric pattern: the added pixels often form a short, straight run (a small horizontal or vertical line) adjacent to the anchor and then continue in a consistent diagonal direction (down‑right or down‑left). This creates a small right‑angled or L‑shaped motif.</description>\\n<example>Picture a single blue pixel and then observe a few blue pixels immediately to its right and then further blue pixels below those right‑adjacent ones; that pattern indicates a horizontal arm followed by a downward diagonal arm.</example>\\n</note3>\\n\\n<note4>\\n<description>Observe the color used for the new cells: the added motif is frequently a single color distinct from the anchor color and is consistent across examples. That secondary color is applied to the new pixels and is not used for the anchor itself.</description>\\n<example>If the anchor is yellow and the output shows a new contiguous cluster of a different color (say, purple) around it, then purple is the motif color to use when you recreate the same local pattern elsewhere.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the same relative placement and orientation to the test input: use the anchor's coordinate as the origin, draw the horizontal segment of the motif immediately adjacent to the anchor, then continue the motif in the same diagonal direction until you reach the grid edge or until the motif stops (examples usually show it stopping at the border).</description>\\n<example>For example, if the anchor is at (r,c), place the motif’s first cell at (r,c+1), then place subsequent motif cells at (r+1,c+2), (r+2,c+3), etc., stopping when you run out of grid space—this reproduces the same local L‑shape seen in the examples.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the anchor: every example begins with a single non-black pixel. That pixel is the reference point for the transformation and should be treated as the center of the change.</description>\\n<example>Imagine a grid with one blue pixel at (row 3, col 4). Mark that cell as the anchor and do not move it — all subsequent additions will be positioned relative to it.</example>\\n</note1>\\n\\n<note2>\\n<description>Identify the marker color: the outputs introduce a new color that does not appear in the inputs. This marker is used to draw the new shape and is distinct from the anchor color.</description>\\n<example>If the input contains only black and one red pixel, the output will add a green marker to form the new pattern. Treat green as the marker color and do not confuse it with the red anchor.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide the orientation: the marker is placed along the row immediately above the anchor, and the marker extends to the right from the anchor's column. In other words, the new shape is a horizontal run anchored at the anchor's column, starting at the row above.</description>\\n<example>With an anchor at (r,c), place marker pixels at (r-1,c), (r-1,c+1), (r-1,c+2), … until the grid edge; the anchor itself remains at (r,c).</example>\\n</note3>\\n\\n<note4>\\n<description>Use a fixed-length rule: the run of marker pixels has a consistent length across examples (three pixels). That length is independent of the grid size and should be applied uniformly.</description>\\n<example>From the anchor at (r,c) you will always place three marker pixels to the right of the anchor's column in the row above, regardless of how many columns are available.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle boundaries and preserve the anchor: if the marker run would extend past the grid edge, stop at the edge. The original anchor pixel is not removed and remains as part of the output.</description>\\n<example>If the anchor is at the leftmost column, you can only place markers to the right that fit inside the grid; if the grid has more columns, place the full three markers as shown above. Always keep the anchor pixel unchanged.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the anchor: many ARC tasks start from a single non-background pixel. Treat that pixel as the pivot or reference point for the transformation.</description>\\n<example>Imagine a grid with one colored pixel at (r,c). Before changing anything, record its color and coordinates — this pixel is what the rule will expand or use as a reference to build the output.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a fixed offset: the transformation often places a new pixel one cell away from the anchor in the same row. In other words, the new pixel is at the same row but one column to the right.</description>\\n<example>For an anchor at column c, expect a new pixel at (r, c+1). If the grid is wide enough, that right-side placement is consistent across examples; if not, the rule may be constrained by boundaries.</example>\\n</note2>\\n\\n<note3>\\n<description>Examine the horizontal run: the cell immediately to the right of the anchor is usually filled with the anchor's own color, forming a contiguous horizontal segment of length 4. The anchor's original cell is the leftmost of that run.</description>\\n<example>If the anchor is red, you should see a horizontal run red-red-red-red starting at the anchor and extending to its right. The anchor's color is preserved at its original location and duplicated to the right.</example>\\n</note3>\\n\\n<note4>\\n<description>Check the vertical extension: below the anchor, a vertical column of the anchor's color is added, aligned under the anchor's column. This column typically has a fixed height (commonly 3 cells) and sits directly below the anchor.</description>\\n<example>With an anchor at row r, expect a vertical stripe of the anchor color at column c, occupying rows r+1, r+2, r+3 (if those rows exist). That vertical stripe is distinct from the horizontal run and uses the same color.</example>\\n</note4>\\n\\n<note5>\\n<description>Use a distinct marker for the pivot: the anchor's original position is recolored to a single other color (different from the anchor's color) so it stands out as the pivot. This helps separate the pivot from the duplicated horizontal and vertical segments.</description>\\n<example>If the anchor is blue, change the original blue pixel to a different color (for example, a marker color) while leaving the horizontal run and vertical stripe in blue. The marker makes the pivot visually distinct from the repeated pattern.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single non-background pixel that acts as the anchor. When an input has exactly one colored cell, that cell is usually the pivot around which the output is built and should be preserved.</description>\\n<example>If a 6×6 grid contains one green pixel at (2,2), treat (2,2) as the center of the transformation. The rest of the output will be constructed relative to that same coordinate rather than being a new, unrelated shape.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the output contains a uniform one-pixel-wide vertical band that runs from the top of the grid to the anchor row. This band is a consistent vertical feature that appears in the outputs.</description>\\n<example>On a 7-row grid, if the anchor is at row 4, the output will show a continuous vertical column of the same color occupying rows 0–4 (a 5-row vertical band) and that column will be at the same column as the anchor.</example>\\n</note2>\\n\\n<note3>\\n<description>Observe the horizontal extension: the anchor's column is expanded to the right by a fixed number of adjacent cells, forming a contiguous horizontal block. The block's length is constant across examples and independent of the grid width.</description>\\n<example>If the anchor is at column 3, the output will include the original anchor cell plus three cells to its right, so the horizontal run is 4 cells long; if the anchor is near the right edge, the block simply uses available cells.</example>\\n</note3>\\n\\n<note4>\\n<description>Verify color consistency: the vertical band and the horizontal run are the same color, while the original anchor keeps its original color. The transformation uses two distinct colors — one for the vertical band and one for the horizontal run — and the anchor's color is preserved.</description>\\n<example>Suppose the anchor is red and the new color used for the band is blue; the vertical column is blue and the horizontal run is also blue, but the anchor cell remains red. Identifying these two roles helps you apply the rule correctly.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle boundaries and preserve the original grid size: if the horizontal run would exceed the grid width, it is truncated to the available cells; the vertical band is always anchored at the anchor's column and is clipped at the grid's top and bottom as needed.</description>\\n<example>If the anchor is at the rightmost column, the horizontal run cannot extend further right and is simply left as a single cell; the vertical band still starts at the top and runs down to the anchor row.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the anchor: the transformation is driven by a single colored pixel in the input. Treat that pixel as the pivot point for the change and ignore other zeros or stray colors.</description>\\n<example>If an input contains exactly one green pixel, that green pixel is the anchor. All subsequent edits in the output are positioned relative to that green pixel rather than to other colors or the grid edges.</example>\\n</note1>\\n<note2>\\n<description>Look for a small, symmetric motif around the anchor: the examples show a 3×3 square centered on the anchor. That motif is not a simple enlargement of the original pixel but a consistent local shape centered on the anchor.</description>\\n<example>Imagine a lone red pixel; the output shows a small square of red cells surrounding the red pixel (with the red pixel at the motif center). The motif is the same relative pattern in each example regardless of the original color.</example>\\n</note2>\\n<note3>\\n<description>One cell of the motif is replaced by a distinct marker color: the output contains a single cell of a new color adjacent to the anchor (the same marker in every example). This marker is not the anchor color and is used to highlight the motif's placement.</description>\\n<example>For a blue anchor, the motif in the output has one blue cell turned into a different color (call it marker M) so the motif becomes visually distinct. That marker M appears in the same relative position in every example.</example>\\n</note3>\\n<note4>\\n<description>Decide which side of the anchor receives the marker by comparing examples: the marker is placed on the same side of the anchor in all training pairs. Use that consistent side to place the marker in the test case.</description>\\n<example>If in every example the marker is always on the anchor's right (positive column direction), then when you place the 3×3 motif on the test anchor you must put the marker in the same right-side cell of that motif.</example>\\n</note4>\\n<note5>\\n<description>Apply the motif and marker to the test input: center a 3×3 motif on the anchor, recolor one motif cell to the marker, and leave all other cells unchanged. If the motif would extend beyond the grid, the transformation still uses the same relative placement rule.</description>\\n<example>On a new input with a lone yellow pixel, build the 3×3 centered on that pixel, change the designated adjacent cell to the marker color, and keep the rest of the grid as it was. If the grid is smaller, the motif is clipped by the grid boundary but the rule of centering and marker placement remains.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the anchor: when a grid contains exactly one non-background pixel, that pixel is usually the reference point for the transformation. Treat it as the pivot around which new structure is built.</description>\\n<example>Imagine a 5×5 grid with a single red pixel at (2,2). In many tasks that red pixel is the center of the change rather than an isolated noise; so first record its coordinates and color before looking at the rest of the grid.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a fixed offset (a constant vector) that is added to the anchor in the outputs: the anchor is often moved by the same small displacement in every example. Finding that offset tells you where the original pixel ends up.</description>\\n<example>If in several examples the single pixel is consistently one cell down and one cell left from where it was in the inputs, then the transformation includes a translation by (−1,−1). Use that observed vector to predict the new location of the anchor in the test case.</example>\\n</note2>\\n\\n<note3>\\n<description>Check whether the anchor’s color is reused to form a new object: the original color is frequently used to draw a contiguous block (a filled rectangle or similar) anchored at the translated position. The block’s shape and extent are consistent across examples.</description>\\n<example>For instance, if the anchor color is blue, you may see a small filled rectangle of blue pixels centered at the translated anchor location in every output. That suggests the rule is “repaint a block using the anchor color at the translated position.”</example>\\n</note3>\\n\\n<note4>\\n<description>Use the anchor’s row as a horizontal anchor for the block: the block’s width (and often its left edge) is determined by the anchor’s row index rather than by the grid width. This gives a simple formula for how many columns the block will occupy.</description>\\n<example>If the anchor sits in row r, then the block’s width (or the column where it begins) can be computed from r (for example, width = 5 − r). Apply that same relationship to the test anchor’s row to decide how wide the block should be.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle overlaps and edge cases consistently: if the computed block would extend outside the grid, clip it; if it would overlap the original anchor, decide whether to overwrite it or keep both colors according to the examples. Always apply the same clipping/overwriting rule to the test case.</description>\\n<example>If the block would start at column −1 because of a small r, simply start at column 0. If the block would cover the original anchor cell, check the training outputs to see whether the original color was overwritten by the block or preserved—then use that same rule when building the test block.</example>\\n</note5>\",\n \"<note1>\\n<description>Spot the anchor: many tasks start from a single non-background pixel. That pixel is the reference point for the transformation and usually remains the same color in the output.</description>\\n<example>Imagine a grid with one blue pixel on a black background. In the output you should still see a blue pixel in the same place — treat that blue pixel as the center or anchor of the change.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a one-cell extension in the anchor’s row: the anchor’s row often gains one additional cell immediately to its right. This is a consistent horizontal change you can detect across examples.</description>\\n<example>For a solitary red pixel at column c in row r, check whether the output shows a red pixel at (r, c+1). If so, that extra red cell is part of the transformation and should be included when you recreate the output.</example>\\n</note2>\\n\\n<note3>\\n<description>Observe the anchor’s column becoming a vertical bar: the column of the anchor is filled with the same color downward from the anchor. This produces a vertical segment anchored at the original pixel.</description>\\n<example>If the anchor is green at (r,c), examine the output for green pixels at (r+1,c), (r+2,c), etc. Those consecutive green cells form the vertical bar and are added to the grid.</example>\\n</note3>\\n\\n<note4>\\n<description>Check for a horizontal run extending to the right from the anchor: one cell to the right of the anchor is usually expanded into a contiguous horizontal block of the anchor color that reaches the grid edge. Think “extend one cell to the right and fill the rest.”</description>\\n<example>With a yellow anchor at (r,c), you might find a horizontal run of yellow cells starting at (r,c+1) and continuing until the rightmost column. That run is continuous and ends at the grid boundary.</example>\\n</note4>\\n\\n<note5>\\n<description>Combine the pieces and watch for overlap rules: the anchor, its right-neighbor, and the vertical bar are all the same color; if the vertical bar and the horizontal run meet, they form a T-like shape. Always use the anchor’s color for all added cells.</description>\\n<example>When the anchor is orange, expect orange cells at the anchor, orange at (r,c+1), and orange cells below the anchor on its column. If the horizontal run and vertical bar cross, the intersection remains orange; do not introduce a different color there.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the anchor: in these examples there is exactly one non‑black cell that serves as the reference point for the whole transformation. Its coordinates (row, column) determine where the new structure is placed and oriented.</description>\\n<example>Imagine a grid with a single red pixel. That pixel is not merely decorative; it is the pivot for everything that follows. Treat its row and column as the origin when you reason about where to draw any new shape.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a one‑pixel vertical extension: the output always adds one pixel directly above the anchor. This vertical segment is consistent across examples and establishes the top anchor for the rest of the pattern.</description>\\n<example>If the anchor is at (r,c), you should add a pixel at (r−1,c) in the same column. That single top pixel is the first element of the structure and is always present in the outputs.</example>\\n</note2>\\n\\n<note3>\\n<description>Extend the anchor's color to the right into a contiguous horizontal run: the anchor's color is propagated to several adjacent columns on its same row, forming a horizontal bar that begins immediately to the right of the top anchor.</description>\\n<example>With the anchor at (r,c), color the cells (r,c+1), (r,c+2), ... up to some length L until you stop. The bar is contiguous and starts right next to the newly added top pixel.</example>\\n</note3>\\n\\n<note4>\\n<description>Build a vertical column of the anchor color to the left of the top anchor: a straight column (same column, successive rows) is drawn starting at the top anchor and extending downward, using the anchor's original color.</description>\\n<example>From the top anchor at (r,c), color (r+1,c), (r+2,c), ... down the grid until you reach the grid boundary. This creates a downward vertical stripe adjacent to the top anchor.</example>\\n</note4>\\n\\n<note5>\\n<description>Combine the pieces and check invariants: the final pattern is the union of the top anchor, the horizontal bar, and the downward vertical column; these three elements meet at the anchor and form a compact motif. Preserve the anchor's original color for the bar and vertical column and do not change other colors.</description>\\n<example>Imagine placing the top pixel, then the horizontal run to its right, and then the vertical column below it — together they form a small, consistent shape anchored at the original cell. After assembling, verify the motif matches the examples' layout and that the anchor color was used consistently for the bar and column.</example>\\n</note5>\",\n \"<note1>\\n<description>Locate the anchor: many tasks start from a single non-background pixel. That pixel is usually the pivot or reference point for the transformation and is rarely moved or removed.</description>\\n<example>Imagine a 7×7 grid with one red pixel at (row 3, column 4). In the output that red pixel remains at the same coordinates and serves as the center of the change; everything else is built around it rather than replacing it.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a vertical bar: the output often adds a straight vertical segment that extends downward from the anchor. The bar’s length is determined by the anchor’s column and the grid’s bottom edge, not by the original pixel’s color.</description>\\n<example>For example, if the anchor sits in column 3 of an 8-row grid, the output will place a vertical bar in column 3 that reaches from the anchor down to the last row, forming a continuous column of the bar color.</example>\\n</note2>\\n\\n<note3>\\n<description>Observe a horizontal extension: immediately to the right of the anchor a contiguous horizontal segment of a different color appears. The length of that horizontal segment is a fixed offset from the anchor (the same offset across examples), and it is always placed to the anchor’s right.</description>\\n<example>If the anchor is in column 4, the output shows a horizontal run of length 4 starting at column 5 and extending to the right (e.g., columns 5–8). If the anchor were in column 2, the horizontal run would start at column 3 and extend right by the same fixed amount.</example>\\n</note3>\\n\\n<note4>\\n<description>Check the colors used: the vertical bar is a single distinct color, the horizontal run uses a second distinct color, and the anchor keeps its original color. These color roles are consistent across examples and should be treated as fixed roles rather than derived from the anchor’s value.</description>\\n<example>Suppose the anchor is blue; you should place a vertical bar of one consistent color (say green) and a horizontal run of another consistent color (say yellow), leaving the original blue pixel unchanged. The important point is the role of colors, not which numeric color happens to be chosen.</example>\\n</note4>\\n\\n<note5>\\n<description>Preserve the background and handle edges: leave all other cells as the background color (usually 0), and clip any added segments to the grid boundaries. If the horizontal run would extend beyond the right edge, it simply occupies whatever columns remain.</description>\\n<example>If the horizontal run would need to span 5 columns but only 3 columns are available to the right of the anchor, place the run on the available columns only; the vertical bar is always anchored at the anchor’s column and extends down to the grid bottom.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"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, 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\": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 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, 6, 6, 6], [0, 0, 0, 0, 6, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 0], [0, 0, 0, 0, 6, 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, 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]], \"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, 5, 4, 4, 4], [0, 0, 0, 4, 0, 0, 0], [0, 0, 0, 4, 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, 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, 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, 0, 0, 0, 0], [0, 0, 0, 0, 5, 9, 9, 9, 9], [0, 0, 0, 0, 9, 0, 0, 0, 0], [0, 0, 0, 0, 9, 0, 0, 0, 0], [0, 0, 0, 0, 9, 0, 0, 0, 0]]}]"},"test":{"kind":"string","value":"[{\"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, 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]], \"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, 0, 0], [0, 0, 0, 0, 5, 6, 6, 6, 6], [0, 0, 0, 0, 6, 0, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 0, 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\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 6 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0\n0 0 0 0 5 6 6 6\n0 0 0 0 6 0 0 0\n0 0 0 0 6 0 0 0\n0 0 0 0 6 0 0 0\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 4 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```\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 0 0 0 0\n0 0 0 5 4 4 4\n0 0 0 4 0 0 0\n0 0 0 4 0 0 0\n0 0 0 4 0 0 0\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 9 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 5 9 9 9 9\n0 0 0 0 9 0 0 0 0\n0 0 0 0 9 0 0 0 0\n0 0 0 0 9 0 0 0 0\n```\n\n# Test Problem:\n```\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 6 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n```"},"answer":{"kind":"string","value":"```\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0\n0 0 0 0 5 6 6 6 6\n0 0 0 0 6 0 0 0 0\n0 0 0 0 6 0 0 0 0\n0 0 0 0 6 0 0 0 0\n0 0 0 0 6 0 0 0 0\n```"},"num_tokens":{"kind":"number","value":1132,"string":"1,132"}}},{"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```\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 6 6 6 0 0 0 0\n0 0 6 6 6 6 6 0 0 0\n0 0 0 6 6 6 0 0 0 0\n0 0 0 6 6 6 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 6 6 6 0 6 6 6 0 0\n6 6 6 6 6 6 6 6 0 0\n0 6 6 6 6 6 6 6 6 0\n0 6 6 6 0 6 6 6 0 0\n0 0 0 0 0 0 0 0 0 0\n0 6 6 6 0 6 6 6 0 0\n6 6 6 6 6 6 6 6 0 0\n0 6 6 6 6 6 6 6 6 0\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 7 0 7 0 0 0\n0 0 0 7 7 7 7 0 0 0\n0 0 0 7 7 7 7 0 0 0\n0 0 0 7 7 7 7 0 0 0\n0 0 0 0 7 0 7 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 7 0 7 0 0 7 0\n7 7 7 7 0 7 7 7\n7 7 7 7 0 7 7 7\n7 7 7 7 0 7 7 7\n7 7 7 7 0 7 7 7\n7 7 7 7 0 7 7 7\n7 7 7 7 0 7 7 7\n7 7 7 7 0 7 7 7\n7 0 7 0 0 7 0 7\n0 0 0 0 0 0 0 0\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 5 5 0 0 0 0 0\n0 0 0 0 5 0 5 0 0 0\n0 0 5 5 5 5 5 0 0 0\n0 0 5 0 5 0 0 0 0 0\n0 0 0 0 5 5 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 5 5 0 0 0 0 5 5 0\n0 0 5 0 5 5 0 5 0 0\n5 5 5 5 5 5 5 5 5 5\n5 0 5 0 0 0 0 5 0 5\n0 0 5 5 0 0 5 5 0 0\n0 0 5 5 0 0 5 5 0 0\n5 0 5 0 0 0 0 5 0 5\n5 5 5 5 5 5 5 5 5 5\n0 0 5 0 5 5 0 5 0 0\n0 5 5 0 0 0 0 5 5 0\n```\n\n# Test Problem:\n```\n0 0 0 0 0 0\n0 0 6 0 0 0\n0 6 6 6 0 0\n0 0 6 0 0 0\n0 0 0 0 0 0\n0 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":2162,"string":"2,162"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>Isolate the object by finding the minimal bounding box that contains every non-background pixel. This box captures the object's shape and relative layout without extra background noise.</description>\n<example>Imagine a small 5×5 grid with a 3×3 colored blob somewhere inside. Crop to the smallest rectangle that contains all colored cells; that cropped rectangle is the object you will use for further operations.</example>\n</note1>\n\n<note2>\n<description>Rotate the cropped object 90° clockwise and then reflect it horizontally (flip left↔right). These two operations together produce a mirror image of the object while keeping the same color values.</description>\n<example>If the cropped object is a small L-shape, rotating it 90° clockwise and flipping it horizontally will make the L face the opposite direction; the colors remain unchanged, only the orientation is altered.</example>\n</note2>\n\n<note3>\n<description>Compute the mirrored tile size from the original bounding box dimensions: mirrored_width = original_height and mirrored_height = original_width. This ensures the mirrored copy fits into the grid without changing the object's proportions.</description>\n<example>If the original bounding box is 2 rows by 4 columns, the mirrored copy will be 4 rows by 2 columns; place that mirrored copy so its height and width align with the original tile dimensions.</example>\n</note3>\n\n<note4>\n<description>Place the mirrored tile adjacent to the original tile along the same axis but with swapped orientation, using the original bounding-box width (or height) as the horizontal (or vertical) separation. In other words, the two tiles share a seam that corresponds to the original tile's width (or height).</description>\n<example>For a 4×3 tile, place the mirrored 3×4 tile next to it with a 4-cell gap along the shared axis; the two tiles will sit side-by-side with the seam at the original tile's width and the mirrored tile occupying the swapped orientation.</example>\n</note4>\n\n<note5>\n<description>Fill the entire output canvas with the object's color so the final grid is uniform in color and contains the original and mirrored copies. This produces a consistent, large-scale pattern that highlights the object and its mirror.</description>\n<example>After placing the original and mirrored tiles, set every cell outside those tiles to the object's color so the whole output looks like a tiled arrangement of the object and its mirror in a single-color background.</example>\n</note5>","<note1>\n<description>Isolate the object by locating the color that differs from the background. Knowing the object's bounding box (top, bottom, left, right) gives you the exact shape and orientation to work with.</description>\n<example>Imagine a grid where a single red shape sits on a black background. Draw the smallest rectangle that contains every red pixel — that rectangle is the object's bounding box and contains the whole pattern you must reproduce.</example>\n</note1>\n\n<note2>\n<description>Check whether the object is axis-aligned (no rotation or reflection). If the object's rows and columns line up with the grid axes, you can treat it as a block and reason about copying it without changing its orientation.</description>\n<example>For example, if the object occupies rows r..r+h−1 and columns c..c+w−1 and every pixel inside those bounds is the same color, the block is axis-aligned and you can copy it exactly in the same orientation.</example>\n</note2>\n\n<note3>\n<description>Decide on a placement rule: a common pattern is to place copies of the object at regular horizontal intervals across the grid (for instance, every half the width). Use the original object's width as the horizontal step so copies align at predictable column positions.</description>\n<example>If the object's width is 3, you might place copies at columns 0, 3, 6, ... (or every other column). Each copy should start at the same row as the original so their vertical alignment is preserved.</example>\n</note3>\n\n<note4>\n<description>Ensure every copy is identical and filled with the object's color; do not alter colors or internal holes when reproducing the shape. Treat the object as a template and apply it exactly wherever you place it.</description>\n<example>For example, a hollow square template should produce hollow squares at every target location rather than filled or differently colored versions.</example>\n</note4>\n\n<note5>\n<description>After placing copies, verify the overall pattern: the number of columns should equal the object width multiplied by the number of copies, and the arrangement should be symmetric (copies on both sides of the original). If something looks off, re-check the step size and alignment.</description>\n<example>If you placed two copies at columns 0 and 3, the grid width should accommodate both and the left/right halves should mirror each other; if they don't, adjust the step or alignment so symmetry and width are preserved.</example>\n</note5>","<note1>\n<description>Find the single non-background color and compute its minimal bounding rectangle (min/max row and column). That rectangle is the atomic unit you will copy and position elsewhere. This isolates the object you must reproduce and avoids copying background noise.</description>\n<example>Imagine a grid where color A occupies rows 2..5 and columns 3..6; the bounding box is those rows and columns. Treat that 4×4 block as the unit to be duplicated rather than copying individual pixels or the whole grid.</example>\n</note1>\n<note2>\n<description>Compare the input and output sizes to determine the scale factor k (how many times the bounding box was enlarged). Compute k by dividing the output dimensions by the bounding-box dimensions (e.g., k = output_height / box_height, k = output_width / box_width). The scale is the same along both axes in these tasks.</description>\n<example>If your bounding box is 3×2 and the output is 6×4, then k = 6/3 = 2 and k = 4/2 = 2; the box was scaled by 2 in both directions.</example>\n</note2>\n<note3>\n<description>Tile the scaled bounding box across the output grid by placing copies at regular intervals determined by k. Each copy is the same scaled rectangle and is positioned at offsets that are multiples of k from the top and left edges. The number of tiles in each direction equals floor(output_dim / k) + 1 (the extra tile comes from the leftover space).</description>\n<example>With k=2 and output width 8, you can place tiles at columns 0, 2, 4, 6 (4 tiles). For a 6×6 output with k=2 you would place tiles at (0,0),(0,2),(0,4),(2,0),(2,2),(2,4),(4,0),(4,2),(4,4) — a 5×5 grid of tiles.</example>\n</note3>\n<note4>\n<description>Preserve orientation and color when copying: do not rotate, flip, or recolor the scaled rectangle. The copies should be exact instances of the scaled bounding box, so the internal pattern (holes, thin arms) remains identical in every tile. This keeps the transformation deterministic and unambiguous.</description>\n<example>If the bounding box has a single pixel missing in the middle, every placed copy will have that same missing pixel in the same relative location inside the scaled rectangle.</example>\n</note4>\n<note5>\n<description>Handle leftover space and edge cases: when output_dim is not an exact multiple of k, the final tile(s) can extend beyond the grid (they are still placed at the computed offsets). If the grid size is not a multiple of the bounding-box size, compute k from the output dimensions (not from the input). Always verify that the same k explains both output dimensions.</description>\n<example>For a 7×7 output and k=2 you will place tiles at offsets 0 and 2, and the last tile(s) will occupy the remaining rows/columns (they are simply truncated at the grid edge). If k were 3 for a 10×10 output, you would place tiles at offsets 0,3,6 and the remaining 10/3 = 3 tiles (with remainder) would be placed accordingly.</example>\n</note5>","<note1>\n<description>Find the single non-background color that forms a coherent object in the input. If there is exactly one connected colored region, the transformation is likely based on that object rather than on multiple independent shapes.</description>\n<example>Imagine a 6×6 grid with only the color X forming a compact shape and all other cells background. Treat X as the object to analyze because it is the only meaningful colored region; everything else is background and should be ignored when inferring the rule.</example>\n</note1>\n\n<note2>\n<description>Compute the object’s minimal bounding rectangle (min/max row and column). This gives the object’s width and height and tells you the region of the grid that must be preserved or transformed.</description>\n<example>If the colored pixels occupy rows 2–4 and columns 1–3, the bounding box is rows 2..4 by cols 1..3, so you should reason about that 3×3 rectangle as the unit to copy or manipulate rather than individual scattered pixels.</example>\n</note2>\n\n<note3>\n<description>Look for a 180° rotation (half-turn) of the bounding rectangle: the object’s rows and columns are reversed. This is equivalent to rotating the rectangle 180° and is a common geometric operation in ARC tasks.</description>\n<example>For a small bounding box with pattern [A B C] in a row, after a 180° rotation that row becomes [C B A]. Apply that reversal to each row of the bounding rectangle to obtain the rotated version.</example>\n</note3>\n\n<note4>\n<description>Decide whether to tile or mirror the rotated rectangle by checking parity of the grid dimensions: if both height and width are even, place two copies (one original, one rotated) side-by-side; if one is odd, place two copies stacked. This explains why the output size changes between examples.</description>\n<example>On an even-by-even grid you can fit two equal rectangles side-by-side, so copy the rotated rectangle into the right half and the original into the left half. On an odd-by-even grid you would stack the two rectangles instead, placing the rotated copy below the original.</example>\n</note4>\n\n<note5>\n<description>When you place the two copies, preserve the original color and ensure the bounding rectangle is centered in each half (left/center, right/center, or top/center, bottom/center) depending on the chosen tiling direction. Avoid changing any cells outside the two placed rectangles.</description>\n<example>If you place the rotated rectangle in the right half, center it horizontally so the bounding rectangle’s left edge touches the grid’s left edge and its right edge aligns with the grid’s right edge; do the same for the other copy in the opposite half. This keeps the two copies symmetric and prevents accidental overlap or truncation.</example>\n</note5>","<note1>\n<description>Find the minimal bounding rectangle that contains every non-background pixel. This rectangle captures the exact shape and relative arrangement of the object you must reproduce or transform.</description>\n<example>For a cluster of colored pixels, draw the smallest rectangle that encloses all colored cells; the rectangle's width and height equal the object's dimensions and preserve the pattern inside it.</example>\n</note1>\n\n<note2>\n<description>Compare the input and output sizes and look for a consistent integer scaling factor. If the output dimensions are an integer multiple of the bounding box, the transformation likely enlarges the object by that factor.</description>\n<example>If the bounding box is 3×2 and the output shows the same pattern repeated in a grid that is 6×4, the scale factor is 2 and you should expect each original cell to expand into a 2×2 block.</example>\n</note2>\n\n<note3>\n<description>Decide how each original cell is mapped into the larger canvas. Common choices are uniform expansion (every original cell becomes a k×k block of the same color) or a tile-and-shift placement (the block is placed at a regular offset).</description>\n<example>With k=2 and a 3×2 bounding box, you could either fill every original cell with a 2×2 block of color, producing a 6×4 canvas, or place each 2×2 tile at offsets so the tiles form a tiled pattern across the output.</example>\n</note3>\n\n<note4>\n<description>Handle background and boundaries by checking how empty space is filled. If background pixels appear in the output, determine whether they are left as background or whether empty cells are filled by the repeated tile pattern.</description>\n<example>If the input has zeros outside the bounding box, the output may show the tiled pattern only inside the enlarged rectangle and keep background elsewhere; alternatively, the tiles may be placed so they cover the entire output and the background becomes part of the repeating pattern.</example>\n</note4>\n\n<note5>\n<description>Validate the candidate rule by reconstructing the output from the bounding box and the chosen mapping. If the reconstructed grid matches the example outputs, the rule is consistent; otherwise adjust the scale, placement, or filling rule.</description>\n<example>Try the minimal bounding rectangle, apply the proposed expansion or tiling, and compare; if any example pair fails, change the scale or check whether tiles should be offset or the background should be filled differently.</example>\n</note5>","<note1>\n<description>Find the minimal bounding rectangle that contains every non-background pixel. This rectangle isolates the object you will transform and is the unit that will be reused in the output.</description>\n<example>Imagine a 7×7 grid with colored pixels only inside a 3×3 box in the top-right. Draw the smallest rectangle around those colored pixels; that 3×3 box is the object to be copied and transformed.</example>\n</note1>\n\n<note2>\n<description>Decide how many copies to make: the output is typically a tiling of that bounding rectangle with a small integer (often 2 or 3) along each axis. Use the same integer for both directions so the tiling is square and regular.</description>\n<example>If the bounding rectangle is 3×3 and you choose factor 2, you will create a 6×6 output composed of four 3×3 tiles (2 tiles across and 2 tiles down). If the factor is 3, the output becomes 9×9 with nine 3×3 tiles.</example>\n</note2>\n\n<note3>\n<description>Apply a consistent color permutation to each copy before placing it: a single color in the bounding rectangle is usually mapped to another color in the tiled copies (a one-to-one relabeling). Keep the shape and relative positions of pixels inside each tile identical, only their color changes.</description>\n<example>Suppose the bounding rectangle has color A in the top-left and color B in the bottom-right. In the tiled output, every tile will show the same pattern but with A→C and B→D (for example), so the arrangement of colors is preserved but the color labels are swapped consistently.</example>\n</note3>\n\n<note4>\n<description>Place the transformed tiles in a regular grid (usually top-left to bottom-right) and leave any remaining cells as background. The final grid size equals (bounding_rect_size × tile_factor) in each dimension.</description>\n<example>With a 3×3 bounding rectangle and factor 2, make four 3×3 tiles and place them in a 2×2 layout; the rest of the 6×6 grid stays empty. With factor 3, you would make nine 3×3 tiles in a 3×3 layout.</example>\n</note4>\n\n<note5>\n<description>Verify the result by checking that the transformed tiles preserve the original shape and that the color permutation is applied uniformly to every tile. If something looks off, re-check the bounding rectangle, the chosen factor, or the color mapping.</description>\n<example>If a tile in the output has a different arrangement of holes or a missing pixel, you likely used the wrong bounding rectangle or factor. If colors are inconsistent across tiles, re-evaluate the color permutation rule.</example>\n</note5>","<note1>\n<description>Isolate the object: find every non-background cell and compute the minimal bounding rectangle that contains them. Working with that rectangle (its width, height, and pixel layout) is simpler than manipulating the full grid and makes the transformation easier to see.</description>\n<example>Imagine a small colored shape sitting in the middle of a blank grid. Draw the smallest box around all colored pixels — that box is the object you will operate on. For example, if the colored pixels occupy rows 2–4 and columns 3–5, the bounding box is 3×3 and you only need to reason about that 3×3 pattern.</example>\n</note1>\n\n<note2>\n<description>Check whether the output contains multiple copies of the bounding-box pattern. If so, the transformation is likely a tiling or mirroring of that box rather than a pixel-by-pixel recoloring or arbitrary drawing.</description>\n<example>Take a 3×2 bounding box and look for identical 3×2 blocks repeated in different places in the output. If you find several identical blocks arranged in a regular way, treat each occurrence as an independent copy of the original box rather than separate, unique shapes.</example>\n</note2>\n\n<note3>\n<description>Decide the copy arrangement: the examples often place copies at fixed offsets (for instance, at the four corners or at specific relative positions around the original). Use those offsets to locate where to paste each copy.</description>\n<example>If the original box sits at (r,c) in the input, check the output for boxes at positions like (0,c), (0,0), (r,0), and (r,c). If those four positions all contain the same pattern, the rule is to place copies at those corner-relative offsets rather than at random spots.</example>\n</note3>\n\n<note4>\n<description>When pasting copies, preserve orientation and color: copies are typically exact duplicates (same pixel pattern and color) and are not rotated or flipped unless the examples show that explicitly. Do not change the box’s internal layout when copying it.</description>\n<example>If the bounding box has a single pixel in its top row, that single pixel will appear in the same relative position inside every pasted copy. If you see rotated or mirrored copies in the examples, then rotation would be part of the rule; otherwise treat copies as literal, unrotated tiles.</example>\n</note4>\n\n<note5>\n<description>Handle overlaps and edge cases: copies may overlap, and the final grid may be smaller than the input. Decide how overlapping pixels are resolved (usually preserved because the same color is used) and whether the transformation keeps the original placement or replaces the whole grid.</description>\n<example>If two copies would write to the same cell, the same color will appear there in the output. If the pasted copies extend outside the original grid, the output grid is simply the union of those placements (the examples will show whether the original grid is kept or replaced).</example>\n</note5>","<note1>\n<description>Find the object by locating the color that differs from the background (usually 0). Treat that connected colored region as the single tile to be transformed; its bounding box and internal pattern are the key features to preserve.</description>\n<example>Imagine a grid with one small 3×3 patch of red pixels on a black background. The red patch is the object: record its bounding box and the pattern of filled vs empty cells inside that box before you try any transformation.</example>\n</note1>\n\n<note2>\n<description>Look for a global rearrangement: the output often shows the same colored pattern appearing in multiple places. Determine whether those placements are symmetric or regular (for example, mirrored across an axis or repeated in a grid).</description>\n<example>If you see the same L-shaped red pattern in the top-left, top-right, bottom-left and bottom-right quadrants of the output, that indicates a symmetric duplication rather than a single isolated copy.</example>\n</note2>\n\n<note3>\n<description>Check whether the pattern is copied exactly (same orientation and colors) or whether it is mirrored or rotated. Exact copies keep the same local arrangement; mirrored/rotated copies preserve shape but reverse orientation.</description>\n<example>Compare a copied patch with its mirror: the mirrored patch will have the same relative filled cells but their horizontal/vertical positions swapped. If the output shows reversed horizontal positions in each quadrant, mirroring is the operation.</example>\n</note3>\n\n<note4>\n<description>Use the grid dimensions to infer placement rules: if the output keeps the same height and width, the pattern is likely placed in each quadrant (top-left, top-right, bottom-left, bottom-right) rather than being resized or moved to the edge. Each quadrant may receive a transformed version of the object.</description>\n<example>On a 10×10 grid, if you see the same motif in each quadrant, think “place transformed copies into the four quadrants” rather than “resize the motif.”</example>\n</note4>\n\n<note5>\n<description>When assembling the final grid, paste each transformed copy into the corresponding quadrant, preserving the original color and the relative arrangement of filled cells. After placement, check that no other colors appear and that the overall symmetry matches the examples.</description>\n<example>Take the object’s bounding box and its internal pattern, flip it horizontally to create the right-side copy, place it in the appropriate quadrant, and repeat for the other three quadrants; the result should be a symmetric tiling of the original motif.</example>\n</note5>","<note1>\n<description>Isolate the active object by finding the minimal bounding rectangle that contains every non-background pixel. This rectangle is the basic unit the transformation will reuse or copy. Working with that box reduces the problem to manipulating a small pattern rather than the whole grid.</description>\n<example>Imagine a 7×7 grid with a 3×3 colored patch in the middle and all other cells background. The bounding rectangle is the 3×3 box that exactly covers those colored pixels; you can ignore surrounding background for the next steps and treat that 3×3 as the pattern to transform.</example>\n</note1>\n\n<note2>\n<description>Look for a horizontal mirror: many ARC tasks reflect the bounding rectangle left-to-right so its left column becomes the rightmost column and vice versa. This is equivalent to reversing the order of columns inside the box while keeping rows unchanged. A horizontal mirror preserves the shape but flips its horizontal orientation.</description>\n<example>Take a 2×3 pattern:\n1 2 3\n4 5 6\nAfter a horizontal mirror you get:\n3 2 1\n6 5 4\nThe pattern's internal arrangement is preserved but its left/right columns have been swapped.</example>\n</note2>\n\n<note3>\n<description>After mirroring, place that mirrored copy directly to the right of the original bounding rectangle, aligned at the same top/bottom row indices. The two rectangles share the same row indices and sit side-by-side horizontally, producing a wider composite image. This keeps the vertical alignment consistent and makes the duplication obvious.</description>\n<example>If the original box occupies columns 2–4 and rows 3–5, place the mirrored box in columns 6–8 (same rows 3–5). The result is a single wider region made of the original and its horizontal mirror, both occupying rows 3–5.</example>\n</note3>\n\n<note4>\n<description>Apply the same horizontal reflection and side-by-side placement to every occurrence of the bounding rectangle in the grid. If there are multiple disconnected boxes, treat each separately and duplicate each one the same way. Consistent application across all boxes produces a uniform tiling of the whole grid.</description>\n<example>If two identical 2×2 boxes appear at different horizontal positions, mirror each and place each mirrored copy immediately to the right of its original. The final grid will show those boxes repeated side-by-side in the same mirrored orientation at each original location.</example>\n</note4>\n\n<note5>\n<description>Watch for edge cases: ensure you use the minimal bounding box (not a larger background rectangle) and check that the mirrored copy does not overlap other non-background regions. Also confirm the output grid is the same size as the input—mirroring and tiling should preserve the canvas while moving pixels horizontally. If a mirrored copy would extend outside the grid or collide with other colors, reconsider the bounding box or the placement rule.</description>\n<example>If the bounding box is flush against a grid edge, the mirrored copy may fall outside the grid; in such tasks the examples usually avoid that, so prefer a bounding box that allows a clear side-by-side placement. Before finalizing, verify that every colored pixel in the original appears exactly once in the mirrored copy and that the overall grid dimensions match the input.</example>\n</note5>","<note1>\n<description>First isolate the colored object by finding every non-background cell and computing its minimal bounding box. This gives you the object’s shape and size independently of its original position.</description>\n<example>If a grid contains a compact shape made of colored cells, list all colored coordinates and take the smallest rectangle that contains them; that rectangle is the object’s canonical form you will use for copying.</example>\n</note1>\n\n<note2>\n<description>Decide whether the operation is a translation (moving the object) or a tiling/repetition of the object. In many tasks the object is placed into a regular grid of cells (often every other cell) rather than simply shifted.</description>\n<example>Imagine a small 3×3 colored block in the input: if the output shows that same 3×3 block appearing at several regular positions, the transformation is a tiling/replication rule rather than a single translation.</example>\n</note2>\n\n<note3>\n<description>Look for a periodic placement rule: the object is often repeated at positions that form a lattice (for example, every other row and every other column). Determine the repeat interval (commonly 2) by checking which rows and columns contain repeated copies.</description>\n<example>If you see copies of the object at (r,c), (r+2,c), (r,c+2) and (r+2,c+2), then the object is being tiled with a 2×2 repeating pattern; if copies occur only on alternate rows or columns, the period is 2 along that axis.</example>\n</note3>\n\n<note4>\n<description>Check how the tiling is anchored: the first occurrence of the object in the tiled pattern may be aligned to a corner or to a specific boundary (e.g., the top-left). Use the example outputs to infer which alignment is used before placing the pattern on the test grid.</description>\n<example>If in the training outputs the first copy is at the grid’s top-left corner, place the object at that anchor when you apply the same tiling rule to the test input; if examples instead show an offset, use that offset instead.</example>\n</note4>\n\n<note5>\n<description>When tiling, preserve the original object’s internal pattern and color exactly; do not rotate, reflect, or recolor it unless examples show such transforms. Also clip any copies that would fall outside the grid boundaries.</description>\n<example>If the object has a hole or an asymmetric shape, each repeated copy should match that exact arrangement. If a repeated copy would extend beyond the grid, only the part inside the grid is drawn.</example>\n</note5>","<note1>\n<description>Isolate the object by computing the minimal axis-aligned bounding rectangle that contains every non-background pixel. This rectangle captures the object's shape and orientation without extra empty space around it.</description>\n<example>For example, if colored pixels occupy rows 2–4 and columns 3–5, the bounding rectangle is rows 2..4 × cols 3..5. Work with that rectangle as the motif rather than with the full grid.</example>\n</note1>\n\n<note2>\n<description>Compute the rectangle's height h and width w and use these dimensions to decide how many copies to place along each axis: place h copies along the horizontal axis and w copies along the vertical axis. This produces a grid of h×w smaller rectangles arranged in an h-by-w layout.</description>\n<example>If the motif is 3 rows by 2 columns (h=3, w=2), you will place 3 copies across and 2 copies down, so the overall arrangement will be 3 by 2 blocks of the motif.</example>\n</note2>\n\n<note3>\n<description>Tile the motif by repeating it with its original orientation and color, filling the h×w layout. Treat each tile as an independent copy of the bounding rectangle so that the motif's internal pattern is preserved in every tile.</description>\n<example>Imagine a small L-shaped motif; when you place three across and two down you get a larger L-shaped grid where every block is identical to the original motif.</example>\n</note3>\n\n<note4>\n<description>Place the tiled motif exactly at the top-left of the output so that the motif's top-left corner coincides with the output's top-left corner. This keeps the arrangement aligned and consistent across examples.</description>\n<example>If the motif is 2×3, the first 2 rows and first 3 columns of the output are the motif; the remaining cells outside that rectangle are left as background.</example>\n</note4>\n\n<note5>\n<description>Be careful about orientation and background: do not rotate or mirror the motif unless the examples explicitly show such transformations. Also ensure you copy the exact color of the object and that any empty cells outside the motif remain the background color.</description>\n<example>If the motif contains a hole or a different pixel color, those features must appear in every tile exactly as in the original. A common mistake is to rotate the motif or to use a different color when copying, so check those invariants.</example>\n</note5>","<note1>\n<description>Find the unique non-background color and treat its connected pixels as a single object. This is effective because the transformation consistently acts on that object rather than on scattered isolated pixels.</description>\n<example>Imagine a grid with many zeros and one contiguous patch of color A. Mark every A that is orthogonally connected to form the object; ignore single stray pixels of A that are not connected to that main patch.</example>\n</note1>\n\n<note2>\n<description>Compute the minimal bounding rectangle that contains all pixels of the object (min row, max row, min col, max col). That rectangle is the unit you will copy and reposition in the output.</description>\n<example>If the object occupies rows 2..5 and columns 3..6, its bounding box is rows 2..5 × cols 3..6; treat that box as the pattern to be moved around the grid.</example>\n</note2>\n\n<note3>\n<description>Decide on the target placement: the object is copied into the top-left quadrant of the output grid. If the output width or height is not an exact multiple of the bounding-box width/height, the box will be truncated at the quadrant edge; otherwise it fits exactly.</description>\n<example>With an output that is 8×8 and a bounding box that is 3×4, place the 3×4 box into rows 0..2 and cols 0..3; any extra rows/columns beyond that quadrant are left as background.</example>\n</note3>\n\n<note4>\n<description>Copy the bounding-box pattern exactly (same relative arrangement of filled and empty cells) into the chosen quadrant and then reflect it across the vertical axis so the right-hand copy is a mirror of the left-hand copy. This produces a left/right symmetry without rotating or recoloring.</description>\n<example>If the bounding box has a distinctive column of filled cells in its left side, the mirrored copy on the right will show that column in the corresponding right-side column, preserving the pattern's internal layout.</example>\n</note4>\n\n<note5>\n<description>Do not alter other colors or the background—only the object’s bounding box is copied and mirrored. If the object touches the grid edge, the quadrant placement may be trimmed by the grid boundary.</description>\n<example>If the object lies near the right edge of the input, the left quadrant copy will be truncated at the grid edge; all other cells remain unchanged and should remain the background color.</example>\n</note5>","<note1>\n<description>Start by locating the single non-background color and computing its minimal bounding rectangle (min/max rows and cols). This isolates the object you will copy and gives its width and height so you know how many cells to move. The bounding box is the natural unit for the transformation.</description>\n<example>Imagine a 3×5 block of color A sitting on a black field. Find the smallest rectangle that contains every A cell (rows 2–4, cols 1–5). That rectangle is your object to work with; record its width and height before any copying.</example>\n</note1>\n\n<note2>\n<description>Compare the input and output dimensions to see whether the grid was scaled. If the output is an integer multiple of the input in both directions, the object was likely enlarged by that factor. Use that scale to determine how far the object was translated in the output.</description>\n<example>If an input is 10×10 and the output is 20×20, the scale is 2. That suggests the object was copied or scaled and placed so the copies line up with the new grid; the translation between copies will then be an integer multiple of the original size.</example>\n</note2>\n\n<note3>\n<description>Look for a regular, repeating arrangement of the object across the output: copies that are shifted by the same horizontal and vertical offsets. The spacing between copies (the repeat) is usually a multiple of the original bounding box size. Identifying that repeat tells you how many copies to place and where to align them.</description>\n<example>Suppose you see identical blocks of color B appearing every 4 columns and every 4 rows in the output. That indicates a repeat of 4; place copies at offsets that are multiples of 4 until the whole output is filled.</example>\n</note3>\n\n<note4>\n<description>When placing copies, preserve the original orientation and color exactly and only overwrite background cells. Do not rotate, mirror, or recolor the object — it should be an exact replica. This preserves the object's internal pattern and makes the transformation unambiguous.</description>\n<example>If the object has a distinctive hole or an offset pixel, every copy must show that same hole/offset at the same relative position. Overwriting other colored pixels would change the pattern and is not part of the intended rule.</example>\n</note4>\n\n<note5>\n<description>Use simple checks to validate your hypothesis: the number of non-background cells in the output should be an integer multiple of the original count, and the bounding box of each copy should match the original bounding box. If those checks fail, reconsider the scale or placement rule and try a different repeat offset.</description>\n<example>For instance, if the input has 10 colored cells and the output shows 20 colored cells, that supports a doubling hypothesis. If each copy's bounding box is the same size as the original, you have the correct placement; otherwise adjust the repeat or scale and re-check.</example>\n</note5>","<note1>\n<description>Isolate the object by locating every non-background pixel and computing its minimal bounding rectangle. This gives a compact template you can reason about without worrying about surrounding zeros. The bounding box is the smallest axis-aligned rectangle that contains all object pixels.</description>\n<example>Imagine a cluster of colored pixels occupying rows 2–5 and columns 3–6. Draw the smallest rectangle that covers those rows and columns; that rectangle is the object's template. Working with that rectangle makes it easier to compare how the output repeats or transforms the object.</example>\n</note1>\n\n<note2>\n<description>Compare the bounding box dimensions to the overall grid size to see if the grid is an integer multiple of the template. A consistent integer ratio (commonly 2) between width/height and the grid size is a strong clue that the template was tiled or scaled to fill the grid. Use that ratio to predict how many copies might be placed.</description>\n<example>If the template is 3×4 and the grid is 6×8, the ratio is 2 in both directions, suggesting a 2×2 arrangement of identical copies. That tells you the object should appear four times, each occupying a quadrant of the grid.</example>\n</note2>\n\n<note3>\n<description>Check how copies are positioned: are they placed in a regular grid, mirrored, rotated, or shifted? Determine the anchor (e.g., top-left, center, or a corner) and whether copies are translated or reflected. Consistent placement rules (e.g., \"tile to fill a 2×2 grid\" or \"reflect across the vertical center\") are usually the transformation.</description>\n<example>If the template is centered, copying it to the four quadrants produces symmetric mirrored copies. If copies are offset by the template's width/height, they are translated (shifted) rather than rotated or reflected. Identifying the anchor and translation/rotation type is key to reproducing the output.</example>\n</note3>\n\n<note4>\n<description>Verify that each copy preserves the template's internal pattern and color: copies should not be recolored or inverted unless the examples show such changes. If a color appears in multiple places in the output, it is likely a repeated or mirrored instance of the original template. Confirm by comparing corresponding cells inside the bounding boxes.</description>\n<example>If the template contains a hollow square (a center cell different from the border), each placed copy should show the same hollow pattern in the same orientation. If one copy were recolored, that would break the consistency and indicate a different rule.</example>\n</note4>\n\n<note5>\n<description>Use simple sanity checks and avoid overfitting: ensure copies do not overlap, that the grid dimensions are compatible with the repetition, and that all non-background pixels in the output can be explained by one or two repeated placements. If a rule fits all training examples without extra assumptions, it is likely correct. </description>\n<example>After deciding to tile the template into four quadrants, confirm that the total colored cells equal four times the template's area and that every colored cell in the output corresponds to one copy. If something doesn't add up, re-check whether the template should be mirrored, rotated, or shifted instead of tiled.</example>\n</note5>","<note1>\n<description>Look for a single non-background color that forms a coherent shape. When the input contains only one colored cluster, that cluster is usually the element being transformed and not the background.</description>\n<example>Imagine a 7×7 grid with a single 3×3 filled square of color A and all other cells 0. The square is the salient object: count and inspect its pixels to confirm it is the only non-zero region.</example>\n</note1>\n\n<note2>\n<description>Compute the object's minimal bounding rectangle (min/max row and column). This box gives the object's width and height and is the natural unit to reason about repetition or tiling.</description>\n<example>For a cluster occupying rows 2–4 and columns 1–3, the bounding box is 3 rows by 3 columns; use those four numbers to describe the object's size before any copying.</example>\n</note2>\n\n<note3>\n<description>Check whether the output preserves the object's internal pattern and repeats it across the grid. If so, the transformation is a tiling of that bounding box across the entire canvas rather than a local recoloring or rotation.</description>\n<example>If the input object is a hollow square, and the output shows the same hollow square in several places, you can treat the whole output as a tiled array of that box rather than many separate, transformed shapes.</example>\n</note3>\n\n<note4>\n<description>Decide the tiling placement: the training examples place tiles so their rows and columns align with the grid axes (no rotation or mirrored copies). Use the bounding box height and width to determine how many tiles fit horizontally and vertically.</description>\n<example>Given a bounding box of height h and width w, try placing tiles at regular intervals (e.g., every h rows and every w columns) so their edges lie on the grid lines; this reproduces the examples' arrangement.</example>\n</note4>\n\n<note5>\n<description>Handle leftover space and preserve the background. If the number of tiles does not fill the grid exactly, fill the remaining cells with the background color; do not rotate, mirror, or recolor the tiles.</description>\n<example>When tiling a 3×3 box into a 7×7 canvas, you may have one row/column of empty cells after placement; those empty cells remain the background color (zeros), while every other cell is filled by the tiled box.</example>\n</note5>","<note1>\n<description>Find the minimal bounding rectangle around the non-background pixels: compute minRow, maxRow, minCol, maxCol and ignore rows/columns that are entirely background. This isolates the object you need to reason about and removes irrelevant empty space.</description>\n<example>Imagine a grid where the colored pixels lie only between rows 2–6 and columns 1–4. The bounding rectangle is rows 2..6 by cols 1..4; you should work with that subgrid instead of the whole grid.</example>\n</note1>\n\n<note2>\n<description>Compare the sizes of the input and output bounding boxes to determine the scaling factor: if the output box is exactly twice the input box in both dimensions, the object was enlarged by a factor of 2. Use that factor to predict where pixels should appear in the output.</description>\n<example>If the input bounding box is 3×5 and the output bounding box is 6×10, that indicates a 2×2 tiling: each input cell will correspond to a 2×2 block in the output.</example>\n</note2>\n\n<note3>\n<description>Think in terms of a 2×2 tiling of the bounding box: each input cell becomes a 2×2 square in the output. This preserves relative adjacency and orientation — a 2×2 pattern in the input becomes four adjacent 2×2 squares in the output.</description>\n<example>A small L-shaped block of three pixels in the input will produce a larger L-shaped block made of four 2×2 squares in the output, with the same relative positions of the four corners.</example>\n</note3>\n\n<note4>\n<description>Preserve color and background: when you tile, copy the input pixel's color into every cell of its corresponding 2×2 block; leave background pixels as background. Do not introduce new colors or fill background cells unless the input itself had them.</description>\n<example>If an input cell is color A, the corresponding 2×2 block in the output should be entirely A; if the input cell was background, the corresponding block remains background.</example>\n</note4>\n\n<note5>\n<description>Assemble the final image by placing the tiled bounding box at the top-left corner of the output grid, then mirror it horizontally and vertically to cover the rest of the canvas. The output dimensions are twice the input dimensions in each direction, and the mirrored copies preserve the same relative arrangement.</description>\n<example>Take the 2× tiled bounding box and put it in the top-left; copy it to the right and below to form four quadrants (top-left, top-right, bottom-left, bottom-right) so the full output is the doubled size.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>Isolate the object by finding the minimal bounding box that contains every non-background pixel. This box captures the object's shape and relative layout without extra background noise.</description>\\n<example>Imagine a small 5×5 grid with a 3×3 colored blob somewhere inside. Crop to the smallest rectangle that contains all colored cells; that cropped rectangle is the object you will use for further operations.</example>\\n</note1>\\n\\n<note2>\\n<description>Rotate the cropped object 90° clockwise and then reflect it horizontally (flip left↔right). These two operations together produce a mirror image of the object while keeping the same color values.</description>\\n<example>If the cropped object is a small L-shape, rotating it 90° clockwise and flipping it horizontally will make the L face the opposite direction; the colors remain unchanged, only the orientation is altered.</example>\\n</note2>\\n\\n<note3>\\n<description>Compute the mirrored tile size from the original bounding box dimensions: mirrored_width = original_height and mirrored_height = original_width. This ensures the mirrored copy fits into the grid without changing the object's proportions.</description>\\n<example>If the original bounding box is 2 rows by 4 columns, the mirrored copy will be 4 rows by 2 columns; place that mirrored copy so its height and width align with the original tile dimensions.</example>\\n</note3>\\n\\n<note4>\\n<description>Place the mirrored tile adjacent to the original tile along the same axis but with swapped orientation, using the original bounding-box width (or height) as the horizontal (or vertical) separation. In other words, the two tiles share a seam that corresponds to the original tile's width (or height).</description>\\n<example>For a 4×3 tile, place the mirrored 3×4 tile next to it with a 4-cell gap along the shared axis; the two tiles will sit side-by-side with the seam at the original tile's width and the mirrored tile occupying the swapped orientation.</example>\\n</note4>\\n\\n<note5>\\n<description>Fill the entire output canvas with the object's color so the final grid is uniform in color and contains the original and mirrored copies. This produces a consistent, large-scale pattern that highlights the object and its mirror.</description>\\n<example>After placing the original and mirrored tiles, set every cell outside those tiles to the object's color so the whole output looks like a tiled arrangement of the object and its mirror in a single-color background.</example>\\n</note5>\",\n \"<note1>\\n<description>Isolate the object by locating the color that differs from the background. Knowing the object's bounding box (top, bottom, left, right) gives you the exact shape and orientation to work with.</description>\\n<example>Imagine a grid where a single red shape sits on a black background. Draw the smallest rectangle that contains every red pixel — that rectangle is the object's bounding box and contains the whole pattern you must reproduce.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the object is axis-aligned (no rotation or reflection). If the object's rows and columns line up with the grid axes, you can treat it as a block and reason about copying it without changing its orientation.</description>\\n<example>For example, if the object occupies rows r..r+h−1 and columns c..c+w−1 and every pixel inside those bounds is the same color, the block is axis-aligned and you can copy it exactly in the same orientation.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide on a placement rule: a common pattern is to place copies of the object at regular horizontal intervals across the grid (for instance, every half the width). Use the original object's width as the horizontal step so copies align at predictable column positions.</description>\\n<example>If the object's width is 3, you might place copies at columns 0, 3, 6, ... (or every other column). Each copy should start at the same row as the original so their vertical alignment is preserved.</example>\\n</note3>\\n\\n<note4>\\n<description>Ensure every copy is identical and filled with the object's color; do not alter colors or internal holes when reproducing the shape. Treat the object as a template and apply it exactly wherever you place it.</description>\\n<example>For example, a hollow square template should produce hollow squares at every target location rather than filled or differently colored versions.</example>\\n</note4>\\n\\n<note5>\\n<description>After placing copies, verify the overall pattern: the number of columns should equal the object width multiplied by the number of copies, and the arrangement should be symmetric (copies on both sides of the original). If something looks off, re-check the step size and alignment.</description>\\n<example>If you placed two copies at columns 0 and 3, the grid width should accommodate both and the left/right halves should mirror each other; if they don't, adjust the step or alignment so symmetry and width are preserved.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the single non-background color and compute its minimal bounding rectangle (min/max row and column). That rectangle is the atomic unit you will copy and position elsewhere. This isolates the object you must reproduce and avoids copying background noise.</description>\\n<example>Imagine a grid where color A occupies rows 2..5 and columns 3..6; the bounding box is those rows and columns. Treat that 4×4 block as the unit to be duplicated rather than copying individual pixels or the whole grid.</example>\\n</note1>\\n<note2>\\n<description>Compare the input and output sizes to determine the scale factor k (how many times the bounding box was enlarged). Compute k by dividing the output dimensions by the bounding-box dimensions (e.g., k = output_height / box_height, k = output_width / box_width). The scale is the same along both axes in these tasks.</description>\\n<example>If your bounding box is 3×2 and the output is 6×4, then k = 6/3 = 2 and k = 4/2 = 2; the box was scaled by 2 in both directions.</example>\\n</note2>\\n<note3>\\n<description>Tile the scaled bounding box across the output grid by placing copies at regular intervals determined by k. Each copy is the same scaled rectangle and is positioned at offsets that are multiples of k from the top and left edges. The number of tiles in each direction equals floor(output_dim / k) + 1 (the extra tile comes from the leftover space).</description>\\n<example>With k=2 and output width 8, you can place tiles at columns 0, 2, 4, 6 (4 tiles). For a 6×6 output with k=2 you would place tiles at (0,0),(0,2),(0,4),(2,0),(2,2),(2,4),(4,0),(4,2),(4,4) — a 5×5 grid of tiles.</example>\\n</note3>\\n<note4>\\n<description>Preserve orientation and color when copying: do not rotate, flip, or recolor the scaled rectangle. The copies should be exact instances of the scaled bounding box, so the internal pattern (holes, thin arms) remains identical in every tile. This keeps the transformation deterministic and unambiguous.</description>\\n<example>If the bounding box has a single pixel missing in the middle, every placed copy will have that same missing pixel in the same relative location inside the scaled rectangle.</example>\\n</note4>\\n<note5>\\n<description>Handle leftover space and edge cases: when output_dim is not an exact multiple of k, the final tile(s) can extend beyond the grid (they are still placed at the computed offsets). If the grid size is not a multiple of the bounding-box size, compute k from the output dimensions (not from the input). Always verify that the same k explains both output dimensions.</description>\\n<example>For a 7×7 output and k=2 you will place tiles at offsets 0 and 2, and the last tile(s) will occupy the remaining rows/columns (they are simply truncated at the grid edge). If k were 3 for a 10×10 output, you would place tiles at offsets 0,3,6 and the remaining 10/3 = 3 tiles (with remainder) would be placed accordingly.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the single non-background color that forms a coherent object in the input. If there is exactly one connected colored region, the transformation is likely based on that object rather than on multiple independent shapes.</description>\\n<example>Imagine a 6×6 grid with only the color X forming a compact shape and all other cells background. Treat X as the object to analyze because it is the only meaningful colored region; everything else is background and should be ignored when inferring the rule.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the object’s minimal bounding rectangle (min/max row and column). This gives the object’s width and height and tells you the region of the grid that must be preserved or transformed.</description>\\n<example>If the colored pixels occupy rows 2–4 and columns 1–3, the bounding box is rows 2..4 by cols 1..3, so you should reason about that 3×3 rectangle as the unit to copy or manipulate rather than individual scattered pixels.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a 180° rotation (half-turn) of the bounding rectangle: the object’s rows and columns are reversed. This is equivalent to rotating the rectangle 180° and is a common geometric operation in ARC tasks.</description>\\n<example>For a small bounding box with pattern [A B C] in a row, after a 180° rotation that row becomes [C B A]. Apply that reversal to each row of the bounding rectangle to obtain the rotated version.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide whether to tile or mirror the rotated rectangle by checking parity of the grid dimensions: if both height and width are even, place two copies (one original, one rotated) side-by-side; if one is odd, place two copies stacked. This explains why the output size changes between examples.</description>\\n<example>On an even-by-even grid you can fit two equal rectangles side-by-side, so copy the rotated rectangle into the right half and the original into the left half. On an odd-by-even grid you would stack the two rectangles instead, placing the rotated copy below the original.</example>\\n</note4>\\n\\n<note5>\\n<description>When you place the two copies, preserve the original color and ensure the bounding rectangle is centered in each half (left/center, right/center, or top/center, bottom/center) depending on the chosen tiling direction. Avoid changing any cells outside the two placed rectangles.</description>\\n<example>If you place the rotated rectangle in the right half, center it horizontally so the bounding rectangle’s left edge touches the grid’s left edge and its right edge aligns with the grid’s right edge; do the same for the other copy in the opposite half. This keeps the two copies symmetric and prevents accidental overlap or truncation.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the minimal bounding rectangle that contains every non-background pixel. This rectangle captures the exact shape and relative arrangement of the object you must reproduce or transform.</description>\\n<example>For a cluster of colored pixels, draw the smallest rectangle that encloses all colored cells; the rectangle's width and height equal the object's dimensions and preserve the pattern inside it.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the input and output sizes and look for a consistent integer scaling factor. If the output dimensions are an integer multiple of the bounding box, the transformation likely enlarges the object by that factor.</description>\\n<example>If the bounding box is 3×2 and the output shows the same pattern repeated in a grid that is 6×4, the scale factor is 2 and you should expect each original cell to expand into a 2×2 block.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide how each original cell is mapped into the larger canvas. Common choices are uniform expansion (every original cell becomes a k×k block of the same color) or a tile-and-shift placement (the block is placed at a regular offset).</description>\\n<example>With k=2 and a 3×2 bounding box, you could either fill every original cell with a 2×2 block of color, producing a 6×4 canvas, or place each 2×2 tile at offsets so the tiles form a tiled pattern across the output.</example>\\n</note3>\\n\\n<note4>\\n<description>Handle background and boundaries by checking how empty space is filled. If background pixels appear in the output, determine whether they are left as background or whether empty cells are filled by the repeated tile pattern.</description>\\n<example>If the input has zeros outside the bounding box, the output may show the tiled pattern only inside the enlarged rectangle and keep background elsewhere; alternatively, the tiles may be placed so they cover the entire output and the background becomes part of the repeating pattern.</example>\\n</note4>\\n\\n<note5>\\n<description>Validate the candidate rule by reconstructing the output from the bounding box and the chosen mapping. If the reconstructed grid matches the example outputs, the rule is consistent; otherwise adjust the scale, placement, or filling rule.</description>\\n<example>Try the minimal bounding rectangle, apply the proposed expansion or tiling, and compare; if any example pair fails, change the scale or check whether tiles should be offset or the background should be filled differently.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the minimal bounding rectangle that contains every non-background pixel. This rectangle isolates the object you will transform and is the unit that will be reused in the output.</description>\\n<example>Imagine a 7×7 grid with colored pixels only inside a 3×3 box in the top-right. Draw the smallest rectangle around those colored pixels; that 3×3 box is the object to be copied and transformed.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide how many copies to make: the output is typically a tiling of that bounding rectangle with a small integer (often 2 or 3) along each axis. Use the same integer for both directions so the tiling is square and regular.</description>\\n<example>If the bounding rectangle is 3×3 and you choose factor 2, you will create a 6×6 output composed of four 3×3 tiles (2 tiles across and 2 tiles down). If the factor is 3, the output becomes 9×9 with nine 3×3 tiles.</example>\\n</note2>\\n\\n<note3>\\n<description>Apply a consistent color permutation to each copy before placing it: a single color in the bounding rectangle is usually mapped to another color in the tiled copies (a one-to-one relabeling). Keep the shape and relative positions of pixels inside each tile identical, only their color changes.</description>\\n<example>Suppose the bounding rectangle has color A in the top-left and color B in the bottom-right. In the tiled output, every tile will show the same pattern but with A→C and B→D (for example), so the arrangement of colors is preserved but the color labels are swapped consistently.</example>\\n</note3>\\n\\n<note4>\\n<description>Place the transformed tiles in a regular grid (usually top-left to bottom-right) and leave any remaining cells as background. The final grid size equals (bounding_rect_size × tile_factor) in each dimension.</description>\\n<example>With a 3×3 bounding rectangle and factor 2, make four 3×3 tiles and place them in a 2×2 layout; the rest of the 6×6 grid stays empty. With factor 3, you would make nine 3×3 tiles in a 3×3 layout.</example>\\n</note4>\\n\\n<note5>\\n<description>Verify the result by checking that the transformed tiles preserve the original shape and that the color permutation is applied uniformly to every tile. If something looks off, re-check the bounding rectangle, the chosen factor, or the color mapping.</description>\\n<example>If a tile in the output has a different arrangement of holes or a missing pixel, you likely used the wrong bounding rectangle or factor. If colors are inconsistent across tiles, re-evaluate the color permutation rule.</example>\\n</note5>\",\n \"<note1>\\n<description>Isolate the object: find every non-background cell and compute the minimal bounding rectangle that contains them. Working with that rectangle (its width, height, and pixel layout) is simpler than manipulating the full grid and makes the transformation easier to see.</description>\\n<example>Imagine a small colored shape sitting in the middle of a blank grid. Draw the smallest box around all colored pixels — that box is the object you will operate on. For example, if the colored pixels occupy rows 2–4 and columns 3–5, the bounding box is 3×3 and you only need to reason about that 3×3 pattern.</example>\\n</note1>\\n\\n<note2>\\n<description>Check whether the output contains multiple copies of the bounding-box pattern. If so, the transformation is likely a tiling or mirroring of that box rather than a pixel-by-pixel recoloring or arbitrary drawing.</description>\\n<example>Take a 3×2 bounding box and look for identical 3×2 blocks repeated in different places in the output. If you find several identical blocks arranged in a regular way, treat each occurrence as an independent copy of the original box rather than separate, unique shapes.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide the copy arrangement: the examples often place copies at fixed offsets (for instance, at the four corners or at specific relative positions around the original). Use those offsets to locate where to paste each copy.</description>\\n<example>If the original box sits at (r,c) in the input, check the output for boxes at positions like (0,c), (0,0), (r,0), and (r,c). If those four positions all contain the same pattern, the rule is to place copies at those corner-relative offsets rather than at random spots.</example>\\n</note3>\\n\\n<note4>\\n<description>When pasting copies, preserve orientation and color: copies are typically exact duplicates (same pixel pattern and color) and are not rotated or flipped unless the examples show that explicitly. Do not change the box’s internal layout when copying it.</description>\\n<example>If the bounding box has a single pixel in its top row, that single pixel will appear in the same relative position inside every pasted copy. If you see rotated or mirrored copies in the examples, then rotation would be part of the rule; otherwise treat copies as literal, unrotated tiles.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle overlaps and edge cases: copies may overlap, and the final grid may be smaller than the input. Decide how overlapping pixels are resolved (usually preserved because the same color is used) and whether the transformation keeps the original placement or replaces the whole grid.</description>\\n<example>If two copies would write to the same cell, the same color will appear there in the output. If the pasted copies extend outside the original grid, the output grid is simply the union of those placements (the examples will show whether the original grid is kept or replaced).</example>\\n</note5>\",\n \"<note1>\\n<description>Find the object by locating the color that differs from the background (usually 0). Treat that connected colored region as the single tile to be transformed; its bounding box and internal pattern are the key features to preserve.</description>\\n<example>Imagine a grid with one small 3×3 patch of red pixels on a black background. The red patch is the object: record its bounding box and the pattern of filled vs empty cells inside that box before you try any transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a global rearrangement: the output often shows the same colored pattern appearing in multiple places. Determine whether those placements are symmetric or regular (for example, mirrored across an axis or repeated in a grid).</description>\\n<example>If you see the same L-shaped red pattern in the top-left, top-right, bottom-left and bottom-right quadrants of the output, that indicates a symmetric duplication rather than a single isolated copy.</example>\\n</note2>\\n\\n<note3>\\n<description>Check whether the pattern is copied exactly (same orientation and colors) or whether it is mirrored or rotated. Exact copies keep the same local arrangement; mirrored/rotated copies preserve shape but reverse orientation.</description>\\n<example>Compare a copied patch with its mirror: the mirrored patch will have the same relative filled cells but their horizontal/vertical positions swapped. If the output shows reversed horizontal positions in each quadrant, mirroring is the operation.</example>\\n</note3>\\n\\n<note4>\\n<description>Use the grid dimensions to infer placement rules: if the output keeps the same height and width, the pattern is likely placed in each quadrant (top-left, top-right, bottom-left, bottom-right) rather than being resized or moved to the edge. Each quadrant may receive a transformed version of the object.</description>\\n<example>On a 10×10 grid, if you see the same motif in each quadrant, think “place transformed copies into the four quadrants” rather than “resize the motif.”</example>\\n</note4>\\n\\n<note5>\\n<description>When assembling the final grid, paste each transformed copy into the corresponding quadrant, preserving the original color and the relative arrangement of filled cells. After placement, check that no other colors appear and that the overall symmetry matches the examples.</description>\\n<example>Take the object’s bounding box and its internal pattern, flip it horizontally to create the right-side copy, place it in the appropriate quadrant, and repeat for the other three quadrants; the result should be a symmetric tiling of the original motif.</example>\\n</note5>\",\n \"<note1>\\n<description>Isolate the active object by finding the minimal bounding rectangle that contains every non-background pixel. This rectangle is the basic unit the transformation will reuse or copy. Working with that box reduces the problem to manipulating a small pattern rather than the whole grid.</description>\\n<example>Imagine a 7×7 grid with a 3×3 colored patch in the middle and all other cells background. The bounding rectangle is the 3×3 box that exactly covers those colored pixels; you can ignore surrounding background for the next steps and treat that 3×3 as the pattern to transform.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a horizontal mirror: many ARC tasks reflect the bounding rectangle left-to-right so its left column becomes the rightmost column and vice versa. This is equivalent to reversing the order of columns inside the box while keeping rows unchanged. A horizontal mirror preserves the shape but flips its horizontal orientation.</description>\\n<example>Take a 2×3 pattern:\\n1 2 3\\n4 5 6\\nAfter a horizontal mirror you get:\\n3 2 1\\n6 5 4\\nThe pattern's internal arrangement is preserved but its left/right columns have been swapped.</example>\\n</note2>\\n\\n<note3>\\n<description>After mirroring, place that mirrored copy directly to the right of the original bounding rectangle, aligned at the same top/bottom row indices. The two rectangles share the same row indices and sit side-by-side horizontally, producing a wider composite image. This keeps the vertical alignment consistent and makes the duplication obvious.</description>\\n<example>If the original box occupies columns 2–4 and rows 3–5, place the mirrored box in columns 6–8 (same rows 3–5). The result is a single wider region made of the original and its horizontal mirror, both occupying rows 3–5.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the same horizontal reflection and side-by-side placement to every occurrence of the bounding rectangle in the grid. If there are multiple disconnected boxes, treat each separately and duplicate each one the same way. Consistent application across all boxes produces a uniform tiling of the whole grid.</description>\\n<example>If two identical 2×2 boxes appear at different horizontal positions, mirror each and place each mirrored copy immediately to the right of its original. The final grid will show those boxes repeated side-by-side in the same mirrored orientation at each original location.</example>\\n</note4>\\n\\n<note5>\\n<description>Watch for edge cases: ensure you use the minimal bounding box (not a larger background rectangle) and check that the mirrored copy does not overlap other non-background regions. Also confirm the output grid is the same size as the input—mirroring and tiling should preserve the canvas while moving pixels horizontally. If a mirrored copy would extend outside the grid or collide with other colors, reconsider the bounding box or the placement rule.</description>\\n<example>If the bounding box is flush against a grid edge, the mirrored copy may fall outside the grid; in such tasks the examples usually avoid that, so prefer a bounding box that allows a clear side-by-side placement. Before finalizing, verify that every colored pixel in the original appears exactly once in the mirrored copy and that the overall grid dimensions match the input.</example>\\n</note5>\",\n \"<note1>\\n<description>First isolate the colored object by finding every non-background cell and computing its minimal bounding box. This gives you the object’s shape and size independently of its original position.</description>\\n<example>If a grid contains a compact shape made of colored cells, list all colored coordinates and take the smallest rectangle that contains them; that rectangle is the object’s canonical form you will use for copying.</example>\\n</note1>\\n\\n<note2>\\n<description>Decide whether the operation is a translation (moving the object) or a tiling/repetition of the object. In many tasks the object is placed into a regular grid of cells (often every other cell) rather than simply shifted.</description>\\n<example>Imagine a small 3×3 colored block in the input: if the output shows that same 3×3 block appearing at several regular positions, the transformation is a tiling/replication rule rather than a single translation.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a periodic placement rule: the object is often repeated at positions that form a lattice (for example, every other row and every other column). Determine the repeat interval (commonly 2) by checking which rows and columns contain repeated copies.</description>\\n<example>If you see copies of the object at (r,c), (r+2,c), (r,c+2) and (r+2,c+2), then the object is being tiled with a 2×2 repeating pattern; if copies occur only on alternate rows or columns, the period is 2 along that axis.</example>\\n</note3>\\n\\n<note4>\\n<description>Check how the tiling is anchored: the first occurrence of the object in the tiled pattern may be aligned to a corner or to a specific boundary (e.g., the top-left). Use the example outputs to infer which alignment is used before placing the pattern on the test grid.</description>\\n<example>If in the training outputs the first copy is at the grid’s top-left corner, place the object at that anchor when you apply the same tiling rule to the test input; if examples instead show an offset, use that offset instead.</example>\\n</note4>\\n\\n<note5>\\n<description>When tiling, preserve the original object’s internal pattern and color exactly; do not rotate, reflect, or recolor it unless examples show such transforms. Also clip any copies that would fall outside the grid boundaries.</description>\\n<example>If the object has a hole or an asymmetric shape, each repeated copy should match that exact arrangement. If a repeated copy would extend beyond the grid, only the part inside the grid is drawn.</example>\\n</note5>\",\n \"<note1>\\n<description>Isolate the object by computing the minimal axis-aligned bounding rectangle that contains every non-background pixel. This rectangle captures the object's shape and orientation without extra empty space around it.</description>\\n<example>For example, if colored pixels occupy rows 2–4 and columns 3–5, the bounding rectangle is rows 2..4 × cols 3..5. Work with that rectangle as the motif rather than with the full grid.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the rectangle's height h and width w and use these dimensions to decide how many copies to place along each axis: place h copies along the horizontal axis and w copies along the vertical axis. This produces a grid of h×w smaller rectangles arranged in an h-by-w layout.</description>\\n<example>If the motif is 3 rows by 2 columns (h=3, w=2), you will place 3 copies across and 2 copies down, so the overall arrangement will be 3 by 2 blocks of the motif.</example>\\n</note2>\\n\\n<note3>\\n<description>Tile the motif by repeating it with its original orientation and color, filling the h×w layout. Treat each tile as an independent copy of the bounding rectangle so that the motif's internal pattern is preserved in every tile.</description>\\n<example>Imagine a small L-shaped motif; when you place three across and two down you get a larger L-shaped grid where every block is identical to the original motif.</example>\\n</note3>\\n\\n<note4>\\n<description>Place the tiled motif exactly at the top-left of the output so that the motif's top-left corner coincides with the output's top-left corner. This keeps the arrangement aligned and consistent across examples.</description>\\n<example>If the motif is 2×3, the first 2 rows and first 3 columns of the output are the motif; the remaining cells outside that rectangle are left as background.</example>\\n</note4>\\n\\n<note5>\\n<description>Be careful about orientation and background: do not rotate or mirror the motif unless the examples explicitly show such transformations. Also ensure you copy the exact color of the object and that any empty cells outside the motif remain the background color.</description>\\n<example>If the motif contains a hole or a different pixel color, those features must appear in every tile exactly as in the original. A common mistake is to rotate the motif or to use a different color when copying, so check those invariants.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the unique non-background color and treat its connected pixels as a single object. This is effective because the transformation consistently acts on that object rather than on scattered isolated pixels.</description>\\n<example>Imagine a grid with many zeros and one contiguous patch of color A. Mark every A that is orthogonally connected to form the object; ignore single stray pixels of A that are not connected to that main patch.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the minimal bounding rectangle that contains all pixels of the object (min row, max row, min col, max col). That rectangle is the unit you will copy and reposition in the output.</description>\\n<example>If the object occupies rows 2..5 and columns 3..6, its bounding box is rows 2..5 × cols 3..6; treat that box as the pattern to be moved around the grid.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide on the target placement: the object is copied into the top-left quadrant of the output grid. If the output width or height is not an exact multiple of the bounding-box width/height, the box will be truncated at the quadrant edge; otherwise it fits exactly.</description>\\n<example>With an output that is 8×8 and a bounding box that is 3×4, place the 3×4 box into rows 0..2 and cols 0..3; any extra rows/columns beyond that quadrant are left as background.</example>\\n</note3>\\n\\n<note4>\\n<description>Copy the bounding-box pattern exactly (same relative arrangement of filled and empty cells) into the chosen quadrant and then reflect it across the vertical axis so the right-hand copy is a mirror of the left-hand copy. This produces a left/right symmetry without rotating or recoloring.</description>\\n<example>If the bounding box has a distinctive column of filled cells in its left side, the mirrored copy on the right will show that column in the corresponding right-side column, preserving the pattern's internal layout.</example>\\n</note4>\\n\\n<note5>\\n<description>Do not alter other colors or the background—only the object’s bounding box is copied and mirrored. If the object touches the grid edge, the quadrant placement may be trimmed by the grid boundary.</description>\\n<example>If the object lies near the right edge of the input, the left quadrant copy will be truncated at the grid edge; all other cells remain unchanged and should remain the background color.</example>\\n</note5>\",\n \"<note1>\\n<description>Start by locating the single non-background color and computing its minimal bounding rectangle (min/max rows and cols). This isolates the object you will copy and gives its width and height so you know how many cells to move. The bounding box is the natural unit for the transformation.</description>\\n<example>Imagine a 3×5 block of color A sitting on a black field. Find the smallest rectangle that contains every A cell (rows 2–4, cols 1–5). That rectangle is your object to work with; record its width and height before any copying.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the input and output dimensions to see whether the grid was scaled. If the output is an integer multiple of the input in both directions, the object was likely enlarged by that factor. Use that scale to determine how far the object was translated in the output.</description>\\n<example>If an input is 10×10 and the output is 20×20, the scale is 2. That suggests the object was copied or scaled and placed so the copies line up with the new grid; the translation between copies will then be an integer multiple of the original size.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a regular, repeating arrangement of the object across the output: copies that are shifted by the same horizontal and vertical offsets. The spacing between copies (the repeat) is usually a multiple of the original bounding box size. Identifying that repeat tells you how many copies to place and where to align them.</description>\\n<example>Suppose you see identical blocks of color B appearing every 4 columns and every 4 rows in the output. That indicates a repeat of 4; place copies at offsets that are multiples of 4 until the whole output is filled.</example>\\n</note3>\\n\\n<note4>\\n<description>When placing copies, preserve the original orientation and color exactly and only overwrite background cells. Do not rotate, mirror, or recolor the object — it should be an exact replica. This preserves the object's internal pattern and makes the transformation unambiguous.</description>\\n<example>If the object has a distinctive hole or an offset pixel, every copy must show that same hole/offset at the same relative position. Overwriting other colored pixels would change the pattern and is not part of the intended rule.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple checks to validate your hypothesis: the number of non-background cells in the output should be an integer multiple of the original count, and the bounding box of each copy should match the original bounding box. If those checks fail, reconsider the scale or placement rule and try a different repeat offset.</description>\\n<example>For instance, if the input has 10 colored cells and the output shows 20 colored cells, that supports a doubling hypothesis. If each copy's bounding box is the same size as the original, you have the correct placement; otherwise adjust the repeat or scale and re-check.</example>\\n</note5>\",\n \"<note1>\\n<description>Isolate the object by locating every non-background pixel and computing its minimal bounding rectangle. This gives a compact template you can reason about without worrying about surrounding zeros. The bounding box is the smallest axis-aligned rectangle that contains all object pixels.</description>\\n<example>Imagine a cluster of colored pixels occupying rows 2–5 and columns 3–6. Draw the smallest rectangle that covers those rows and columns; that rectangle is the object's template. Working with that rectangle makes it easier to compare how the output repeats or transforms the object.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the bounding box dimensions to the overall grid size to see if the grid is an integer multiple of the template. A consistent integer ratio (commonly 2) between width/height and the grid size is a strong clue that the template was tiled or scaled to fill the grid. Use that ratio to predict how many copies might be placed.</description>\\n<example>If the template is 3×4 and the grid is 6×8, the ratio is 2 in both directions, suggesting a 2×2 arrangement of identical copies. That tells you the object should appear four times, each occupying a quadrant of the grid.</example>\\n</note2>\\n\\n<note3>\\n<description>Check how copies are positioned: are they placed in a regular grid, mirrored, rotated, or shifted? Determine the anchor (e.g., top-left, center, or a corner) and whether copies are translated or reflected. Consistent placement rules (e.g., \\\"tile to fill a 2×2 grid\\\" or \\\"reflect across the vertical center\\\") are usually the transformation.</description>\\n<example>If the template is centered, copying it to the four quadrants produces symmetric mirrored copies. If copies are offset by the template's width/height, they are translated (shifted) rather than rotated or reflected. Identifying the anchor and translation/rotation type is key to reproducing the output.</example>\\n</note3>\\n\\n<note4>\\n<description>Verify that each copy preserves the template's internal pattern and color: copies should not be recolored or inverted unless the examples show such changes. If a color appears in multiple places in the output, it is likely a repeated or mirrored instance of the original template. Confirm by comparing corresponding cells inside the bounding boxes.</description>\\n<example>If the template contains a hollow square (a center cell different from the border), each placed copy should show the same hollow pattern in the same orientation. If one copy were recolored, that would break the consistency and indicate a different rule.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple sanity checks and avoid overfitting: ensure copies do not overlap, that the grid dimensions are compatible with the repetition, and that all non-background pixels in the output can be explained by one or two repeated placements. If a rule fits all training examples without extra assumptions, it is likely correct. </description>\\n<example>After deciding to tile the template into four quadrants, confirm that the total colored cells equal four times the template's area and that every colored cell in the output corresponds to one copy. If something doesn't add up, re-check whether the template should be mirrored, rotated, or shifted instead of tiled.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for a single non-background color that forms a coherent shape. When the input contains only one colored cluster, that cluster is usually the element being transformed and not the background.</description>\\n<example>Imagine a 7×7 grid with a single 3×3 filled square of color A and all other cells 0. The square is the salient object: count and inspect its pixels to confirm it is the only non-zero region.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the object's minimal bounding rectangle (min/max row and column). This box gives the object's width and height and is the natural unit to reason about repetition or tiling.</description>\\n<example>For a cluster occupying rows 2–4 and columns 1–3, the bounding box is 3 rows by 3 columns; use those four numbers to describe the object's size before any copying.</example>\\n</note2>\\n\\n<note3>\\n<description>Check whether the output preserves the object's internal pattern and repeats it across the grid. If so, the transformation is a tiling of that bounding box across the entire canvas rather than a local recoloring or rotation.</description>\\n<example>If the input object is a hollow square, and the output shows the same hollow square in several places, you can treat the whole output as a tiled array of that box rather than many separate, transformed shapes.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide the tiling placement: the training examples place tiles so their rows and columns align with the grid axes (no rotation or mirrored copies). Use the bounding box height and width to determine how many tiles fit horizontally and vertically.</description>\\n<example>Given a bounding box of height h and width w, try placing tiles at regular intervals (e.g., every h rows and every w columns) so their edges lie on the grid lines; this reproduces the examples' arrangement.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle leftover space and preserve the background. If the number of tiles does not fill the grid exactly, fill the remaining cells with the background color; do not rotate, mirror, or recolor the tiles.</description>\\n<example>When tiling a 3×3 box into a 7×7 canvas, you may have one row/column of empty cells after placement; those empty cells remain the background color (zeros), while every other cell is filled by the tiled box.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the minimal bounding rectangle around the non-background pixels: compute minRow, maxRow, minCol, maxCol and ignore rows/columns that are entirely background. This isolates the object you need to reason about and removes irrelevant empty space.</description>\\n<example>Imagine a grid where the colored pixels lie only between rows 2–6 and columns 1–4. The bounding rectangle is rows 2..6 by cols 1..4; you should work with that subgrid instead of the whole grid.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare the sizes of the input and output bounding boxes to determine the scaling factor: if the output box is exactly twice the input box in both dimensions, the object was enlarged by a factor of 2. Use that factor to predict where pixels should appear in the output.</description>\\n<example>If the input bounding box is 3×5 and the output bounding box is 6×10, that indicates a 2×2 tiling: each input cell will correspond to a 2×2 block in the output.</example>\\n</note2>\\n\\n<note3>\\n<description>Think in terms of a 2×2 tiling of the bounding box: each input cell becomes a 2×2 square in the output. This preserves relative adjacency and orientation — a 2×2 pattern in the input becomes four adjacent 2×2 squares in the output.</description>\\n<example>A small L-shaped block of three pixels in the input will produce a larger L-shaped block made of four 2×2 squares in the output, with the same relative positions of the four corners.</example>\\n</note3>\\n\\n<note4>\\n<description>Preserve color and background: when you tile, copy the input pixel's color into every cell of its corresponding 2×2 block; leave background pixels as background. Do not introduce new colors or fill background cells unless the input itself had them.</description>\\n<example>If an input cell is color A, the corresponding 2×2 block in the output should be entirely A; if the input cell was background, the corresponding block remains background.</example>\\n</note4>\\n\\n<note5>\\n<description>Assemble the final image by placing the tiled bounding box at the top-left corner of the output grid, then mirror it horizontally and vertically to cover the rest of the canvas. The output dimensions are twice the input dimensions in each direction, and the mirrored copies preserve the same relative arrangement.</description>\\n<example>Take the 2× tiled bounding box and put it in the top-left; copy it to the right and below to form four quadrants (top-left, top-right, bottom-left, bottom-right) so the full output is the doubled size.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"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, 6, 6, 6, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 6, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 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]], \"output\": [[0, 6, 6, 6, 0, 6, 6, 6, 0, 0], [6, 6, 6, 6, 6, 6, 6, 6, 0, 0], [0, 6, 6, 6, 6, 6, 6, 6, 6, 0], [0, 6, 6, 6, 0, 6, 6, 6, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 6, 6, 6, 0, 6, 6, 6, 0, 0], [6, 6, 6, 6, 6, 6, 6, 6, 0, 0], [0, 6, 6, 6, 6, 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, 7, 0, 7, 0, 0, 0], [0, 0, 0, 7, 7, 7, 7, 0, 0, 0], [0, 0, 0, 7, 7, 7, 7, 0, 0, 0], [0, 0, 0, 7, 7, 7, 7, 0, 0, 0], [0, 0, 0, 0, 7, 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]], \"output\": [[0, 7, 0, 7, 0, 0, 7, 0], [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, 7, 7, 7, 0, 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, 0, 7, 0, 0, 7, 0, 7], [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, 5, 5, 0, 0, 0, 0, 0], [0, 0, 0, 0, 5, 0, 5, 0, 0, 0], [0, 0, 5, 5, 5, 5, 5, 0, 0, 0], [0, 0, 5, 0, 5, 0, 0, 0, 0, 0], [0, 0, 0, 0, 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]], \"output\": [[0, 5, 5, 0, 0, 0, 0, 5, 5, 0], [0, 0, 5, 0, 5, 5, 0, 5, 0, 0], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 0, 5, 0, 0, 0, 0, 5, 0, 5], [0, 0, 5, 5, 0, 0, 5, 5, 0, 0], [0, 0, 5, 5, 0, 0, 5, 5, 0, 0], [5, 0, 5, 0, 0, 0, 0, 5, 0, 5], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [0, 0, 5, 0, 5, 5, 0, 5, 0, 0], [0, 5, 5, 0, 0, 0, 0, 5, 5, 0]]}]"},"test":{"kind":"string","value":"[{\"input\": [[0, 0, 0, 0, 0, 0], [0, 0, 6, 0, 0, 0], [0, 6, 6, 6, 0, 0], [0, 0, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]], \"output\": [[0, 6, 0, 0, 6, 0], [6, 6, 6, 6, 6, 6], [0, 6, 0, 0, 6, 0], [0, 6, 0, 0, 6, 0], [6, 6, 6, 6, 6, 6], [0, 6, 0, 0, 6, 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 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 6 6 6 0 0 0 0\n0 0 6 6 6 6 6 0 0 0\n0 0 0 6 6 6 0 0 0 0\n0 0 0 6 6 6 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 6 6 6 0 6 6 6 0 0\n6 6 6 6 6 6 6 6 0 0\n0 6 6 6 6 6 6 6 6 0\n0 6 6 6 0 6 6 6 0 0\n0 0 0 0 0 0 0 0 0 0\n0 6 6 6 0 6 6 6 0 0\n6 6 6 6 6 6 6 6 0 0\n0 6 6 6 6 6 6 6 6 0\n```\n\n## Example 2\nInput:\n```\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 7 0 7 0 0 0\n0 0 0 7 7 7 7 0 0 0\n0 0 0 7 7 7 7 0 0 0\n0 0 0 7 7 7 7 0 0 0\n0 0 0 0 7 0 7 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 7 0 7 0 0 7 0\n7 7 7 7 0 7 7 7\n7 7 7 7 0 7 7 7\n7 7 7 7 0 7 7 7\n7 7 7 7 0 7 7 7\n7 7 7 7 0 7 7 7\n7 7 7 7 0 7 7 7\n7 7 7 7 0 7 7 7\n7 0 7 0 0 7 0 7\n0 0 0 0 0 0 0 0\n```\n\n## Example 3\nInput:\n```\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 5 5 0 0 0 0 0\n0 0 0 0 5 0 5 0 0 0\n0 0 5 5 5 5 5 0 0 0\n0 0 5 0 5 0 0 0 0 0\n0 0 0 0 5 5 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0\n```\n\nOutput:\n```\n0 5 5 0 0 0 0 5 5 0\n0 0 5 0 5 5 0 5 0 0\n5 5 5 5 5 5 5 5 5 5\n5 0 5 0 0 0 0 5 0 5\n0 0 5 5 0 0 5 5 0 0\n0 0 5 5 0 0 5 5 0 0\n5 0 5 0 0 0 0 5 0 5\n5 5 5 5 5 5 5 5 5 5\n0 0 5 0 5 5 0 5 0 0\n0 5 5 0 0 0 0 5 5 0\n```\n\n# Test Problem:\n```\n0 0 0 0 0 0\n0 0 6 0 0 0\n0 6 6 6 0 0\n0 0 6 0 0 0\n0 0 0 0 0 0\n0 0 0 0 0 0\n```"},"answer":{"kind":"string","value":"```\n0 6 0 0 6 0\n6 6 6 6 6 6\n0 6 0 0 6 0\n0 6 0 0 6 0\n6 6 6 6 6 6\n0 6 0 0 6 0\n```"},"num_tokens":{"kind":"number","value":1458,"string":"1,458"}}},{"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```\n3 3 3 3 3 3 3 4 3 3\n4 3 3 3 3 4 3 3 8 3\n3 8 3 3 8 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3\n3 3 3 3 8 8 8 3 4 3\n3 3 3 3 8 8 8 3 3 8\n3 3 3 3 8 8 8 3 3 3\n3 4 4 4 3 3 3 3 9 4\n3 4 4 4 3 3 3 3 8 9\n3 4 4 4 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 4\n3 3 3 3 3 3 3 3 8 3\n```\n\nOutput:\n```\n3 3 3 3 3 3 3 4 9 3\n4 9 3 3 9 4 3 9 8 3\n9 8 3 3 8 9 3 3 3 3\n3 3 3 3 3 3 3 3 3 3\n3 9 9 9 8 8 8 3 4 9\n3 9 9 9 8 8 8 3 9 8\n3 9 9 9 8 8 8 3 3 3\n3 4 4 4 9 9 9 3 9 4\n3 4 4 4 9 9 9 3 8 9\n3 4 4 4 9 9 9 3 3 3\n3 3 3 3 3 3 3 3 9 4\n3 3 3 3 3 3 3 3 8 9\n```\n\n## Example 2\nInput:\n```\n6 6 6 6 6 6 2 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 2 6 6 6 6 7 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 7 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 7 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 2 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n7 8 6 8 6 2 6 6 6 6 6 6\n8 8 6 6 6 6 6 6 6 6 6 6\n6 6 6 8 6 6 6 6 6 6 6 6\n8 6 8 2 6 6 6 6 7 6 6 6\n```\n\nOutput:\n```\n6 6 6 6 6 6 2 8 6 8 6 6\n6 6 6 6 6 6 8 6 6 6 6 6\n6 6 6 6 6 6 6 6 8 8 6 6\n6 8 6 8 2 6 8 6 8 7 6 6\n6 6 6 6 8 6 6 6 6 6 6 6\n6 8 8 6 6 6 6 6 6 6 6 6\n6 7 8 6 8 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 7 8 6 8 6 6 6 6\n6 6 6 6 8 8 6 6 6 6 6 6\n6 6 6 6 6 6 6 8 6 6 6 6\n6 6 6 6 8 6 8 2 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n7 8 6 8 6 2 8 6 8 6 6 6\n8 8 6 6 6 8 6 6 6 6 6 6\n6 6 6 8 6 6 6 8 8 6 6 6\n8 6 8 2 6 8 6 8 7 6 6 6\n```\n\n## Example 3\nInput:\n```\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 8 8 7\n7 7 7 7 7 7 7 7 7 7 8 8 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 5 5 7 7 7 7 7\n7 7 7 7 7 7 5 5 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 4 4 5 7\n7 7 7 7 7 7 7 7 7 4 7 4 7\n7 7 7 7 7 7 7 7 7 8 4 4 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n```\n\nOutput:\n```\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 4 4 4 4 8 8 7\n7 7 7 7 7 7 4 4 4 4 8 8 7\n7 7 7 7 7 7 4 4 7 7 4 4 7\n7 7 7 7 7 7 4 4 7 7 4 4 7\n7 7 7 7 7 7 5 5 4 4 4 4 7\n7 7 7 7 7 7 5 5 4 4 4 4 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 4 4 5 7\n7 7 7 7 7 7 7 7 7 4 7 4 7\n7 7 7 7 7 7 7 7 7 8 4 4 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n```\n\n# Test Problem:\n```\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 4 4 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 4 4 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 0 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 0 6 6 6 8 0 0 8 8 8 8 8 8 8 8 8 8 8 4\n8 8 8 6 6 8 6 8 0 0 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 6 8 8 6 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 6 6 6 4 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n```\n\n---\n\n\n# Generated Hint<|im_end|>\n<|im_start|>assistant\n"},"abstraction_prompt_length":{"kind":"number","value":3842,"string":"3,842"},"generated_abstractions":{"kind":"list like","value":["<note1>\n<description>First isolate the active objects: the background is the color that fills most of the grid, and the transformation only touches small contiguous clusters of other colors. Focusing on those clusters reduces the problem to a few local rules instead of the whole grid.</description>\n<example>Imagine a grid mostly filled with color A and two small clusters of colors B and C. Mark the B cluster and the C cluster separately; ignore the large A area when deciding what to change. This makes it easier to see how each object is being modified.</example>\n</note1>\n\n<note2>\n<description>Find the anchor color: one of the non-background colors appears in several clusters and is the source of the change. The other colors tend to be copies or targets of that anchor.</description>\n<example>For example, if color B appears in multiple disconnected spots while colors C and D appear only in single spots or small shapes, treat B as the anchor. You can spot this by counting occurrences or by seeing which color is reused across different clusters.</example>\n</note2>\n\n<note3>\n<description>The core operation is a local copy: take a small bounding rectangle around each non-anchor cluster (usually the cluster's tight bounding box) and fill every cell inside that rectangle with the anchor color. The rectangle is anchored to the cluster, so its top-left corner is the cluster's top-left cell.</description>\n<example>Suppose a cluster occupies three consecutive cells in a row at columns 5–7; the operation would fill columns 5–7 of that row with the anchor color. If the cluster is a 2×2 block, the bounding box is that 2×2 area and you fill all four cells with the anchor color.</example>\n</note3>\n\n<note4>\n<description>When multiple clusters exist, apply the same fill to each cluster's bounding box independently; these fills may overlap and the final result shows where anchor-color rectangles intersect. Overlaps simply mean the anchor color appears in those cells.</description>\n<example>If two clusters are side-by-side, each gets its own filled rectangle; where the rectangles touch or overlap the anchor color appears in the union of those rectangles. If a cluster is below another, the fills stack vertically (anchor color remains in those cells).</example>\n</note4>\n\n<note5>\n<description>Preserve original shapes and colors outside the filled rectangles: do not erase or alter pixels that are part of the original anchor or target clusters, and do not change the background. The transformation is a local recoloring of rectangles, not a global color swap.</description>\n<example>After filling rectangles with the anchor color, any pre-existing colored pixels that lie inside or outside those rectangles should remain unchanged. As a check, compare counts: the anchor color should appear in the union of all filled rectangles, while original target pixels should still be present elsewhere.</example>\n</note5>","<note1>\n<description>Look for the background color: it is the color that fills most of the grid and is left unchanged in the outputs. Treat every other color as an object color and focus on how those object colors are moved or combined.</description>\n<example>Imagine a 6×6 grid filled mostly with color A and a few isolated pixels of colors B and C. In the output A is still the dominant color; you can ignore A and concentrate on where B and C appear relative to each other and to the background.</example>\n</note1>\n\n<note2>\n<description>Group non-background pixels into connected components (4‑connectivity). Each connected component is a separate object you should consider independently when inferring the rule.</description>\n<example>If you see three separate clusters of color B (one single pixel, one 2×2 block, one 3‑pixel line) and one cluster of color C, treat each of those clusters as distinct objects and compare their positions and shapes in input vs output.</example>\n</note2>\n\n<note3>\n<description>Compare each object’s bounding box and internal arrangement in input and output to detect rigid transforms: translation (shift), rotation, reflection, or mirroring. Often the output places an object in a new location by moving it as a whole without changing its internal pattern.</description>\n<example>Suppose a 2×2 square of color X appears at (r,c) in the input and you find a 2×2 square of X at (r+2,c+1) in the output; that suggests a translation of 2 rows and 1 column. If the square’s pixels are in the same relative positions inside the moved box, it’s a rigid translation.</example>\n</note3>\n\n<note4>\n<description>Look for consistent offsets between object positions across all examples. If the same offset (same row and column change) appears for multiple objects, it’s likely the systematic rule used to place them in the outputs.</description>\n<example>If several different colored objects are all shifted by the same (dr,dc) in the examples, record that (dr,dc) and apply it to each object in the test input to predict where they should appear.</example>\n</note4>\n\n<note5>\n<description>When applying the inferred rule, preserve each object’s internal pattern and color exactly; do not alter shapes, orientations, or colors unless the examples show such changes. Only translate (or apply the detected rigid transform) the objects and leave the background unchanged.</description>\n<example>If an object is a 3‑pixel L‑shape, after your rule the L should remain an L with the same pixel counts and colors; only its coordinates will change according to the detected translation or transform.</example>\n</note5>","<note1>\n<description>Spot the background and the candidate objects: the background is the single color that fills most cells, while the objects are contiguous clusters of other colors. Focusing on these clusters reduces the problem to a few small shapes to transform.</description>\n<example>Imagine a grid mostly filled with color A and a few small clusters of colors B and C. Treat A as background and record each connected group of B and C pixels as an object to analyze separately.</example>\n</note1>\n\n<note2>\n<description>Compute the minimal bounding rectangle for each object (smallest axis-aligned box that contains it). This gives a fixed-size template you can compare across examples and reason about how the object might be copied or mirrored.</description>\n<example>If a color appears as a 2×2 block, its bounding box is 2×2; if it appears as a 3×1 vertical bar, the bounding box is 3×1. Use those dimensions to reason about possible placements and transformations.</example>\n</note2>\n\n<note3>\n<description>Compare the object's internal pattern to the background: the object may contain a contiguous patch of background-colored cells inside it. Treat that background patch as a \"hole\" or area to be filled by the object's color.</description>\n<example>For instance, if a colored block contains a 1×1 background cell inside it, that single background cell is a candidate for filling by the block's color rather than leaving it as background.</example>\n</note3>\n\n<note4>\n<description>Look for a systematic placement rule: the object's color is often copied into the background holes in a consistent way across examples (e.g., mirrored or rotated copies placed at regular offsets). Find the same offset relation in each example and apply it to the test objects.</description>\n<example>If you see a small object in the top-left and the same color appears at a regular horizontal or vertical offset elsewhere, try placing the same object (or its mirrored version) at that same offset in the test case, and check whether the background holes are filled accordingly.</example>\n</note4>\n\n<note5>\n<description>Use symmetry and overlap checks to decide which placement is correct: try the original orientation and mirrored/rotated orientations, and prefer the placement that fills background holes consistently while avoiding conflicts with other objects. Also verify that the overall color counts and relative positions match the examples.</description>\n<example>If two placements would both fill background holes but only one matches the examples' pattern of repeated offsets and does not overwrite other objects, choose that one; if neither fits, try the other orientation or a mirrored copy and re-check.</example>\n</note5>","<note1>\n<description>Find the background color first: it is the color that fills most of the grid and is not part of the objects you will change. Treat any other color as a candidate object to be transformed. This step reduces noise and focuses attention on the meaningful shapes.</description>\n<example>Imagine a 10×10 grid that is almost entirely blue with a few small red and yellow patches. Blue is the background; red and yellow are the objects you will inspect and possibly transform. Once you identify blue, ignore it when searching for object shapes.</example>\n</note1>\n\n<note2>\n<description>Group non-background pixels into connected components and compute each component’s bounding box (min/max row and column). The bounding box gives you a compact description of where an object sits and how big it is. Use the same connectivity rule (usually orthogonal) across the grid.</description>\n<example>For instance, a cluster of three orange pixels in a row spans rows 4–5 and columns 7–8, so its bounding box is rows 4–5, cols 7–8. That box tells you the object’s size and location for comparison with other objects.</example>\n</note2>\n\n<note3>\n<description>Compare bounding boxes by width and height to detect repeated motifs. Often the transformation is driven by a small square (a 2×2 or 3×3 block) that appears several times; these repeated blocks are the units you should align and copy. Look for the same dimensions repeating in different places.</description>\n<example>If you see identical 3×3 red squares in two different rows and two different columns, treat each 3×3 as a motif. Those repeated motifs are the likely source of the change in the output rather than isolated single pixels.</example>\n</note3>\n\n<note4>\n<description>Look for a color that appears only inside one motif and nowhere else in the grid. That color is the “marker” to be propagated: it is copied into the empty cells of the other motif instances. The marker color is typically confined to one object and is the one to distribute.</description>\n<example>Suppose one 3×3 blue block contains a single green pixel while another identical 3×3 is entirely blue. The green is the marker: the transformation will copy green into the other 3×3’s empty cells so both become filled with green.</example>\n</note4>\n\n<note5>\n<description>When you copy the marker, fill the entire motif’s bounding box (or the whole grid area of the motif) with that color while preserving the original motif’s placement. If multiple motifs exist, copy the marker into every motif’s bounding box; if only one motif has the marker, you may simply fill that motif’s box. Always keep the grid size and background unchanged.</description>\n<example>Given two identical 3×3 motifs, one with a single marker pixel and the other empty, copy the marker into the empty motif’s 3×3 box so both boxes become uniformly filled with the marker color. Do not alter the background or other unrelated colors.</example>\n</note5>","<note1>\n<description>Find the dominant background color and treat every other color as an object. The transformation usually targets those non-background pixels and leaves the background untouched.</description>\n<example>Imagine a grid filled with 0s and a few 2s and 3s scattered; first mark 0 as background and record all 2s and 3s as objects. Any change in the output will be limited to those object pixels, so focus on how those objects are altered rather than on the 0s.</example>\n</note1>\n\n<note2>\n<description>Group non-background pixels into connected components (4‑neighbour connectivity). Each connected patch is a candidate for a single transformation.</description>\n<example>For example, two adjacent 2s form one component (a 2×2 block is a single component), while isolated 3s elsewhere form separate components. Work with these components rather than individual pixels when you reason about the transformation.</example>\n</note2>\n\n<note3>\n<description>Compare component shapes: the key operation is to replace an object's shape with a uniform filled square that has the same side length as the object's bounding box. In other words, expand the bounding box into a filled square.</description>\n<example>If a component occupies a 2×2 bounding box, change it into a filled 2×2 square; if a component occupies a 3×3 bounding box, change it into a filled 3×3 square. The rule is consistent across components of the same size.</example>\n</note3>\n\n<note4>\n<description>Preserve each component's color and its position: the filled square uses the component's original color and is placed at the component's bounding-box coordinates. Do not rotate or translate the square unless the examples show such an operation.</description>\n<example>If a 3×3 block of color A appears in the input, you should place a 3×3 block of color A at the same location in the output; similarly for a 2×2 block of color B.</example>\n</note4>\n\n<note5>\n<description>Handle overlaps by applying the same rule to every component and checking for collisions: components that would overlap are resolved consistently (examples typically show one color appearing where overlaps occur). Use the training examples to infer which color wins when two filled squares would coincide.</description>\n<example>When two components' filled squares would meet, inspect the training pairs to see which color appears in the overlapping cells; apply that same precedence when you place the squares on the test grid. If no overlap occurs, simply fill each component's bounding box uniformly.</example>\n</note5>","<note1>\n<description>Look first for a dominant background color and treat all other colors as foreground objects. This separation makes it easy to focus on which pixels are being changed and which are acting as anchors.</description>\n<example>Imagine a grid filled with color A except for a few pixels of colors B and C. If the output shows the same background A everywhere except for new B/C pixels, then B and C are the foreground objects you should track rather than A.</example>\n</note1>\n\n<note2>\n<description>Group foreground pixels into connected components (use orthogonal adjacency). Each component is a unit you will reason about independently — the transformation usually applies to whole components, not isolated single pixels.</description>\n<example>If you find a 2×2 block of B and a lone pixel of C elsewhere, treat them as two separate components. You will analyze each component’s size, shape and location before deciding how it should be transformed.</example>\n</note2>\n\n<note3>\n<description>Decide which components are anchors (they are preserved) and which are templates (they are duplicated or copied). Anchors typically occupy the same coordinates in input and output; templates are moved or repeated to fill empty areas.</description>\n<example>Suppose a single B pixel remains in the same spot in the output while other B pixels are arranged around it — that lone B is an anchor and the other B pixels are templates that were copied into the surrounding empty space.</example>\n</note3>\n\n<note4>\n<description>When copying a template, align its bounding box so the template’s top-left (or some consistent corner) maps to the empty area’s top-left. Use the template’s shape and orientation as a stencil and fill the rectangular area with that template’s color.</description>\n<example>If a 2×3 template appears in the input, and there is a 2×3 empty rectangle nearby, place the template so its top-left touches the empty rectangle’s top-left and fill that 2×3 block with the template color.</example>\n</note4>\n\n<note5>\n<description>Apply the same copying rule to every template color and then check for overlaps: if two templates would write to the same cell, the examples show a consistent precedence (usually the template that was copied later or the one that is not an anchor wins). Use this rule to resolve conflicts.</description>\n<example>If two different templates would both write to cell X, compare their source positions and which template’s color appears in X in the output; use that precedence when placing overlapping templates in the test case.</example>\n</note5>","<note1>\n<description>Find the background by frequency: the color that fills most cells is the canvas. Treat every other color as an object to be analyzed or transformed. This separation tells you what stays fixed and what can be moved or copied.</description>\n<example>Imagine a 6×6 grid where 30 cells are color A and a few cells are colors B and C. A is the background; B and C are objects. You can ignore A when deciding where to place new pixels and focus on how B and C are being used or copied.</example>\n</note1>\n\n<note2>\n<description>Look for repeated 2×2 squares of the same non-background color: these are the building blocks of the transformation. If the same small square appears multiple times, it is likely the unit that will be replicated or used as a stamp.</description>\n<example>For example, if you see two identical 2×2 blocks of color B separated by background cells, those two blocks are likely the source units. Record their positions and the pattern inside each 2×2 so you can reason about what to do with them.</example>\n</note2>\n\n<note3>\n<description>Check for a single isolated 2×2 block that contains three of one color and one of another (a 3+1 configuration). That unique 2×2 is often the template or seed whose pattern is copied elsewhere. Identifying which color is the “odd one out” in that 2×2 helps determine which color will be used when stamping.</description>\n<example>Suppose one 2×2 block is [B B; B C] (three B, one C). That block stands out from the repeated 2×2s and is the likely source of the stamp: the three B cells may act as the stamp color and the C as the marker color.</example>\n</note3>\n\n<note4>\n<description>Try tiling the template: place copies of the template’s 2×2 pattern at regular offsets (for example, every other cell in both directions) across the background. The offset determines where the template’s “odd” cell lands, so a small shift can turn a 3+1 template into a uniform 2×2 of the stamp color.</description>\n<example>Imagine stamping a 2×2 template [B B; B C] every two rows and every two columns. Each stamped block will have one C in a predictable position; if you shift the template by one cell, those C positions will move and the whole background can become filled by the stamp color while the C positions align with the original 3+1 block.</example>\n</note4>\n\n<note5>\n<description>Validate your hypothesis by checking invariants: the original 3+1 block should remain or become the only place where the marker color appears, and every other 2×2 region should become uniform (same color) after stamping. If either invariant fails, adjust the offset or which color you treat as the stamp vs. the marker.</description>\n<example>After stamping, scan the grid: you should find only one 2×2 that still has the marker color (or none, if the stamping fully replaced it). All other 2×2 tiles should be uniform copies of the stamp color. If this is not true, try shifting the template by one cell and re-check.</example>\n</note5>","<note1>\n<description>Find the background and the small objects: one color usually fills most cells and the rest are compact clusters. Treat each cluster of non-background pixels as an object to be analyzed.</description>\n<example>Imagine a 7×7 grid mostly filled with color A and three small blobs of colors B and C. Mark each blob as a separate object and record its color and the set of cells it occupies. This isolates what you must move or copy.</example>\n</note1>\n\n<note2>\n<description>Measure each object's bounding box and internal structure. Many ARC tasks copy the object's exact pixel pattern (including holes) rather than just its color, so record both the color and the relative arrangement of pixels inside the box.</description>\n<example>If a red object occupies a 2×2 square but one cell inside is empty, note that the pattern is \"red on three cells\" with a hole. When you later reproduce that object elsewhere, keep the same relative positions of red and empty cells.</example>\n</note2>\n\n<note3>\n<description>Look for an anchor: one object often stays in place while other objects are moved to or aligned with it. Determine which object serves as the fixed reference by comparing input/output coordinates.</description>\n<example>In a small example, the blue square remains at the same coordinates in the output while two green squares appear aligned with it. That tells you to keep the blue square fixed and plan copies relative to it.</example>\n</note3>\n\n<note4>\n<description>Decide the placement rule for copies: copies are often placed so their bounding boxes overlap or touch the anchor's bounding box, and copies of one object are placed on top of the anchor's color. Use the same relative offset each time to reproduce the pattern.</description>\n<example>If you copy a green 2×2 square to the anchor, place the green square so its bounding box overlaps the anchor's bounding box; if multiple green copies are needed, align them in the same offset so they form a regular arrangement.</example>\n</note4>\n\n<note5>\n<description>When placing copies, overwrite cells according to the stacking order (copies placed later overwrite earlier ones). Preserve the anchor's original cells and keep each copy's internal pattern (including holes) intact.</description>\n<example>If you place a red square and then place a green square that covers some red cells, the final visible cells are green where the green was placed; red remains in cells not covered by green. Check that holes and relative offsets inside each copy are unchanged.</example>\n</note5>","<note1>\n<description>Look for the background: the color that fills most cells. Once you know the background, any non-background pixels are the seeds that drive the transformation. This helps you focus on a few small objects instead of the whole grid.</description>\n<example>Imagine a grid of mostly blue cells with a few red and yellow pixels sprinkled in. Treat blue as the background and ignore it when looking for the rule; the red and yellow pixels are the only ones you need to reason about.</example>\n</note1>\n\n<note2>\n<description>Group non-background pixels into connected components (use 4‑neighbour adjacency). Each connected component is an object to analyze and is usually the unit the rule acts on. Don’t assume a single global rule—different objects may be treated differently.</description>\n<example>If two red pixels touch each other vertically and a yellow pixel sits alone, you have two components (a 2‑cell vertical bar and a single yellow cell). Treat each component separately when you compare input and output.</example>\n</note2>\n\n<note3>\n<description>Measure each component’s bounding box and compute its aspect ratio (width/height). The examples use the object’s aspect ratio to decide which side of the bounding box is “longer.” This tells you whether the object is taller, wider, or square.</description>\n<example>A 3×2 rectangle has aspect ratio 1.5 (wider) while a 2×3 rectangle has ratio 0.67 (taller). You can use these ratios to classify objects and determine the orientation you should use when copying or filling.</example>\n</note3>\n\n<note4>\n<description>When an object’s aspect ratio is not 1, the output extends that object along the longer axis by copying its existing pixels into the empty cells inside its bounding box. In other words, the longer dimension is filled by repeating the object’s pattern. This makes the object more regular while keeping its original orientation.</description>\n<example>If a component is a 1×3 row of color A, the rule produces a 3×3 filled block of A (copying the row into the missing cells to make a square). If it’s a 3×1 column, the rule produces a 3×3 filled block of that column’s color.</example>\n</note4>\n\n<note5>\n<description>If an object’s aspect ratio equals 1 (a square), the rule does not change that object—leave it as-is. Also, when multiple objects are present, each is handled independently and only fills its own bounding box (no merging with other objects). This prevents unintended overlaps or global changes.</description>\n<example>Given a 2×2 colored square and a 1×2 horizontal bar elsewhere, the square remains unchanged while the horizontal bar is extended into a 2×2 filled block. If two different colors would fill the same cell, check the examples to see whether they are merged or kept separate; the training pairs usually avoid ambiguous conflicts.</example>\n</note5>","<note1>\n<description>Find the dominant background color and treat every other color as a foreground object. This isolates the parts of the grid that change between input and output so you can focus on how those objects are transformed.</description>\n<example>Imagine a grid filled with blue except for a few red and green pixels. Mark blue as background and list all red/green pixels as objects; in the output you will only see those objects (and their new positions), not blue changes.</example>\n</note1>\n\n<note2>\n<description>Group foreground pixels into connected components and compute each component's minimal bounding rectangle (width × height). The bounding box captures the component's extent and is the unit that gets copied or transformed.</description>\n<example>If you find two small 2×2 squares of different colors, record each as a 2×2 rectangle with its top-left coordinate. Those rectangles are the basic shapes you will use to reason about what happens to the grid.</example>\n</note2>\n\n<note3>\n<description>Look for a consistent spatial relation among the bounding boxes: often the boxes are arranged in a regular grid (e.g., a 3×3 pattern of boxes) and the transformation copies each box into the box that sits diagonally opposite it. That diagonal pairing is the core structural rule to test.</description>\n<example>For a 3×3 arrangement of boxes, check whether each box's copy appears in the box two rows and two columns away; if that holds for every example, you have identified the diagonal-copying pattern.</example>\n</note3>\n\n<note4>\n<description>When a box is copied, it is not simply moved but is placed into the target box's coordinate and its color is preserved. The copy is therefore an exact same-color rectangle placed at the target box's location, so you can think of it as a rectangle-level copy rather than pixel-by-pixel painting.</description>\n<example>If a 2×2 red rectangle is copied to a 2×2 blue rectangle, the blue rectangle becomes red at the same coordinates. In the output you will see the red pattern occupying the blue's bounding box.</example>\n</note4>\n\n<note5>\n<description>Use simple checks to validate your hypothesis: confirm that every non-background pixel in the output can be traced back to a copy of an input box, that the grid of boxes is regular, and that copies always land on boxes that are diagonally opposite. If any example fails these checks, reconsider whether you need a different pairing rule.</description>\n<example>After you believe you have the diagonal-copy rule, verify each output non-background pixel matches a source box at the expected diagonal location; if all do, the rule is consistent and can be applied to the test input.</example>\n</note5>","<note1>\n<description>Look for small, compact non-background clusters that repeat across the grid. These compact clusters are the “seeds” or tiles that drive the transformation rather than isolated stray pixels.</description>\n<example>Imagine a mostly uniform background with several tiny 2×2 squares of a single color scattered around; those 2×2 squares are the natural candidates to focus on. Ignore single pixels or long lines — they are not the repeating tiles.</example>\n</note1>\n\n<note2>\n<description>Compare corresponding tiles across the grid to find the consistent color relationship between them. Often one tile is the same color everywhere, and the other tiles are either that same color or a single contrasting color.</description>\n<example>For instance, if you find three identical 2×2 tiles and in every case two tiles are color A and the third is color B, then A is the common tile color and B is the contrasting tile color to expect elsewhere.</example>\n</note2>\n\n<note3>\n<description>Use the tile that appears most frequently as the default fill color and the contrasting color as the marker to be propagated. The marker is used to fill the gaps where the common tile color is missing in the same relative positions.</description>\n<example>If color A appears in most tiles and color B appears once, treat A as the filler and B as the marker. When you see a tile that lacks A in its marker positions, replace those missing cells with B so the tile becomes a mixed A/B tile.</example>\n</note3>\n\n<note4>\n<description>Apply the rule to every tile in the same orientation and alignment (same relative offset from the grid edges). Do not rotate, reflect, or change the size of the tiles — only fill missing cells with the marker.</description>\n<example>If tiles are always 2×2 and sit at the same offsets from the borders in every example, fill each tile’s missing cells with the marker color while keeping the tile’s shape and orientation unchanged.</example>\n</note4>\n\n<note5>\n<description>Decide how to handle ambiguous tiles: if a tile already contains both colors, leave it as-is; if it contains only one color, fill the other color into the empty positions. After applying the rule to every tile, check that the overall pattern of A/B tiles is consistent with the examples.</description>\n<example>For example, a tile that is entirely A stays A, a tile that is entirely B becomes A/B after filling, and a mixed tile remains mixed. Verify your result by confirming the same A/B arrangement appears in all tiles.</example>\n</note5>","<note1>\n<description>First separate the background from the objects: the background is the color that fills most of the grid and the objects are the other colors that appear in compact shapes. Focusing on the minority colors isolates the pieces that are being transformed.</description>\n<example>Imagine a grid of mostly green cells with a few small blue and red shapes; treat green as the background and blue/red as the objects. Mark each object's coordinates and colors so you can compare input vs output for those objects only.</example>\n</note1>\n\n<note2>\n<description>Look for a single source object (or one small object) whose color appears repeatedly in the output in different places. That color is the “painter” — it is the one being copied or propagated.</description>\n<example>If the output contains many green pixels while the input had only one small green patch, suspect that green is being copied elsewhere. Check every occurrence of green in the output to see where it appears.</example>\n</note2>\n\n<note3>\n<description>For each painted cell in the output, determine whether it lies inside a different object's bounding box. If it does, the painted color has been placed inside the bounding box of another object (i.e., the bounding box is being filled with the painter's color).</description>\n<example>Suppose a red bounding box has a blue pixel inside it in the output; that indicates the blue pixel came from outside and filled that red box. Repeat this check for every painted pixel to see which boxes were filled.</example>\n</note3>\n\n<note4>\n<description>Use the painter's own bounding box to infer the filling direction: the painter's pixels tend to appear on the side of the painter's box that is opposite to the source box. That side is the natural target for filling other boxes.</description>\n<example>If the painter's box is on the left and you see many painted pixels on its right, the rule is “paint the side opposite the source.” Apply this idea to each painted cell to see whether it follows that same orientation.</example>\n</note4>\n\n<note5>\n<description>When you apply the rule, only fill empty cells inside a box (leave existing object pixels unchanged). Also, the painter's own original box may be left as-is or may be overwritten depending on how the propagation interacts with the source box.</description>\n<example>Take a 2×2 box of color A and a single cell of color B outside it; if B is the painter, fill every empty cell inside A with B, but do not change any A cells that were already present. This preserves original object pixels while propagating the painter's color into empty space.</example>\n</note5>","<note1>\n<description>Find the dominant background color and treat every other color as a seed: the background is usually the most frequent color and forms the canvas; all other colors are the objects that will be transformed.</description>\n<example>Imagine a 6×6 grid where 30 cells are color A and the remaining cells are small clusters of B and C. Color A is the background; you should ignore A when deciding which objects to change and instead focus on the B and C clusters.</example>\n</note1>\n\n<note2>\n<description>Group non-background pixels into connected components (orthogonal adjacency) and compute each component's minimal bounding rectangle. This isolates each object so you can reason about its shape independently.</description>\n<example>For instance, if a cluster occupies cells (2,3),(2,4),(3,3) then its bounding box is rows 2–3 and cols 3–4 (a 2×2 rectangle). Treat that whole rectangle as the object's footprint rather than individual pixels.</example>\n</note2>\n\n<note3>\n<description>Decide which seed color to propagate by comparing seed frequency and by checking which seed's bounding box is larger. The chosen seed is the one that appears most often or has the largest bounding-box area; that color is used to fill the box.</description>\n<example>If you have two small 2×2 clusters of colors X and Y and X appears three times while Y appears once, choose X to be the fill color because it is the most frequent. If two seeds are equal in count, pick the one whose bounding box covers more cells (or use a consistent tie-breaker).</example>\n</note3>\n\n<note4>\n<description>Fill every cell inside the chosen seed's bounding rectangle with that seed color; do not alter cells outside that rectangle. This operation preserves the original seed pixels and produces a contiguous filled block.</description>\n<example>Given a 2×2 bounding box for a color Z, set all four cells in that box to Z so the cluster becomes a solid square; leave all other pixels unchanged.</example>\n</note4>\n\n<note5>\n<description>Apply the same rule to every non-background component: for each component compute its bounding box, select its seed color using the frequency/area rule, and fill that box. Watch for multiple components of the same seed color—each gets filled independently.</description>\n<example>If two separate clusters both use color W, compute W's bounding box for each cluster and fill each box completely. If a cluster has no non-background neighbors (it is isolated), its bounding box is just itself and it will be filled with its seed color.</example>\n</note5>","<note1>\n<description>First separate the background from foreground: identify the single color that fills most of the grid and treat every other color as an object to analyze. This reduces the problem to a few discrete shapes instead of the whole grid. A reliable way is to count occurrences or visually inspect the largest contiguous region.</description>\n<example>Imagine a 6×6 grid where 30 cells are color A and the remaining 6 cells are colors B and C. Color A is the background; B and C are the objects. Work with B and C positions and ignore A when searching for the transformation.</example>\n</note1>\n\n<note2>\n<description>Check each non-background color for a compact, rectangular footprint: determine its bounding box and whether the bounding box is filled (a filled rectangle) or only partially filled (a mask). Filled rectangles are easier to reason about and often act as templates for copying. If a color has a bounding box but many cells inside are background, treat it as a mask rather than a filled block.</description>\n<example>For instance, if color X occupies cells whose coordinates lie inside a 2×3 box and every cell inside that box is X, then X is a filled rectangle. If some interior cells are background, X is a mask (its shape is the pattern you should reproduce).</example>\n</note2>\n\n<note3>\n<description>Find the template by size: the template is typically the largest filled rectangle (largest bounding box where every cell inside is that color). Once you have the template, record its color, width, height, and the exact pattern of foreground/background inside it. This template is the pattern you will replicate elsewhere.</description>\n<example>Suppose you find a 3×2 filled rectangle of color Y and a 2×2 filled rectangle of color Z; Y is the template because it is larger. Note that the template’s internal arrangement (which cells inside the box are foreground) is the pattern you must reproduce when copying.</example>\n</note3>\n\n<note4>\n<description>Locate the other non-background color and compute its bounding box. The transformation often copies the template into the empty cells of that box (preserving the template’s internal pattern) rather than filling the whole box uniformly. If the other color’s bounding box is exactly the template’s size, the copy will exactly match the template; otherwise the copy will be the template’s pattern placed into the box.</description>\n<example>If the template is 3×2 and the other color’s bounding box is also 3×2, copy the template into that box so the box becomes a filled 3×2 of the template color. If the other box is 4×3, place the 3×2 template into the empty cells of that 4×3 box while keeping the template’s internal arrangement.</example>\n</note4>\n\n<note5>\n<description>After copying, verify the result: the template color should now occupy the previously-empty cells of the target box (and the template itself may remain), while other objects keep their original colors. If there are multiple candidate boxes, prefer the one that matches the template’s size or the one whose empty cells best receive the template’s pattern. Avoid overwriting other non-background objects.</description>\n<example>After copying a 3×2 template into a target 3×2 box, the box should be uniformly the template color and the original object should still appear elsewhere. If two boxes could accept the template, pick the one that is empty and whose size aligns with the template.</example>\n</note5>","<note1>\n<description>Find the background first: the most frequent color is usually the filler that remains unchanged. Treat any other color(s) as the objects to be transformed. This separation reduces the problem to a few small shapes instead of the whole grid.</description>\n<example>Imagine a grid of mostly green cells with a few red and blue pixels. Call green the background and focus on the red/blue pixels as the objects; you will only change those objects and leave green alone. This keeps the transformation local and easier to reason about.</example>\n</note1>\n\n<note2>\n<description>Group non-background pixels into connected components using orthogonal adjacency (up/down/left/right). Each contiguous patch is an independent object to consider. Connected components are the natural units for copying or moving.</description>\n<example>On a small grid, if red pixels at (2,3) and (3,3) touch, they form one component; a blue pixel at (4,5) is a separate component. Work with these components rather than individual pixels to avoid accidental overwrites.</example>\n</note2>\n\n<note3>\n<description>Identify a distinctive \"anchor\" color inside each component: the color that appears only a few times or appears in a unique shape. That color usually determines where the component will be moved or copied. Use frequency and uniqueness as cues rather than arbitrary choice.</description>\n<example>If one component contains blue only in a 2×2 block and another contains red only as isolated pixels, treat the blue block as the anchor for that component. The anchor color is the one you will track when you copy the whole component.</example>\n</note3>\n\n<note4>\n<description>Copy each component as a rigid block: preserve its exact shape and internal arrangement and place it at the same relative offset inside its anchor cell. That is, translate the whole component by the anchor's displacement from the original anchor position. Do not rotate, reflect, or recolor the component when copying.</description>\n<example>Suppose a 2×2 blue block sits at the top-left of its anchor cell and you find another anchor at the bottom-right; copy the 2×2 block so it occupies the top-left of that new anchor cell. The relative pattern inside the block stays identical, only its location changes.</example>\n</note4>\n\n<note5>\n<description>Apply the copy only where it fits inside the grid and leave all other cells unchanged. If a copy would fall outside the grid, it is simply not placed; otherwise it overwrites the original anchor cell and any background cells it occupies. Treat each anchor independently and leave the background untouched.</description>\n<example>If an anchor sits on the last row and you copy the component above it, the copy will stay inside the grid and overwrite the original anchor area; if an anchor is on the last column, the copy would extend outside and is not applied. This ensures only valid placements change the grid.</example>\n</note5>","<note1>\n<description>Look for the background color and treat every cell that is not background as part of a foreground object. This separates the sparse colored pixels into objects you can analyze independently.</description>\n<example>Imagine a 6×6 grid where most cells are 0 and a few are 1 or 2. First mark all 1s and 2s as foreground and ignore the 0s. Working with those foreground coordinates makes it easier to spot which pixels are being reused or copied.</example>\n</note1>\n\n<note2>\n<description>Group foreground pixels into connected components (use orthogonal adjacency). Each component is a candidate object to be propagated or copied across the grid.</description>\n<example>For instance, if you see three separate clusters of 1s separated by at least one 0 cell, treat them as three independent objects. Each object will have its own bounding box and internal arrangement you can compare across examples.</example>\n</note2>\n\n<note3>\n<description>Compare how each object’s bounding box appears in the output: the transformation often copies an entire component’s pattern (shape and colors) into a contiguous rectangular area. Think “crop the object, then paste that crop into a rectangle” rather than changing individual pixels one by one.</description>\n<example>If a 2×2 red square appears in the input and the output shows a larger contiguous red area, it is likely the 2×2 was cropped and then copied into a larger rectangle elsewhere. The crop preserves the relative arrangement of the red pixels inside that rectangle.</example>\n</note3>\n\n<note4>\n<description>Find the source of the copied pattern by locating the original object that matches the crop: the source’s bounding box will contain the same internal arrangement of colors. Use that source to determine where and how the crop was placed.</description>\n<example>Suppose you detect a small 2×3 green patch in the input and later find a larger green rectangle in the output; inspect the smaller patch to see the green pixels’ layout and then search the larger rectangle for that same layout — that smaller patch is the source.</example>\n</note4>\n\n<note5>\n<description>When you apply the rule to the test grid, do not alter the original object; instead place copies of the source crop into the target rectangles that already exist in the output examples. Preserve the source’s orientation and color arrangement when copying.</description>\n<example>If the training output shows a source object copied into a particular rectangle, locate that rectangle in the test input and paste the source crop there exactly (same colors, same relative positions). This keeps the transformation consistent and avoids changing the original object.</example>\n</note5>"],"string":"[\n \"<note1>\\n<description>First isolate the active objects: the background is the color that fills most of the grid, and the transformation only touches small contiguous clusters of other colors. Focusing on those clusters reduces the problem to a few local rules instead of the whole grid.</description>\\n<example>Imagine a grid mostly filled with color A and two small clusters of colors B and C. Mark the B cluster and the C cluster separately; ignore the large A area when deciding what to change. This makes it easier to see how each object is being modified.</example>\\n</note1>\\n\\n<note2>\\n<description>Find the anchor color: one of the non-background colors appears in several clusters and is the source of the change. The other colors tend to be copies or targets of that anchor.</description>\\n<example>For example, if color B appears in multiple disconnected spots while colors C and D appear only in single spots or small shapes, treat B as the anchor. You can spot this by counting occurrences or by seeing which color is reused across different clusters.</example>\\n</note2>\\n\\n<note3>\\n<description>The core operation is a local copy: take a small bounding rectangle around each non-anchor cluster (usually the cluster's tight bounding box) and fill every cell inside that rectangle with the anchor color. The rectangle is anchored to the cluster, so its top-left corner is the cluster's top-left cell.</description>\\n<example>Suppose a cluster occupies three consecutive cells in a row at columns 5–7; the operation would fill columns 5–7 of that row with the anchor color. If the cluster is a 2×2 block, the bounding box is that 2×2 area and you fill all four cells with the anchor color.</example>\\n</note3>\\n\\n<note4>\\n<description>When multiple clusters exist, apply the same fill to each cluster's bounding box independently; these fills may overlap and the final result shows where anchor-color rectangles intersect. Overlaps simply mean the anchor color appears in those cells.</description>\\n<example>If two clusters are side-by-side, each gets its own filled rectangle; where the rectangles touch or overlap the anchor color appears in the union of those rectangles. If a cluster is below another, the fills stack vertically (anchor color remains in those cells).</example>\\n</note4>\\n\\n<note5>\\n<description>Preserve original shapes and colors outside the filled rectangles: do not erase or alter pixels that are part of the original anchor or target clusters, and do not change the background. The transformation is a local recoloring of rectangles, not a global color swap.</description>\\n<example>After filling rectangles with the anchor color, any pre-existing colored pixels that lie inside or outside those rectangles should remain unchanged. As a check, compare counts: the anchor color should appear in the union of all filled rectangles, while original target pixels should still be present elsewhere.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the background color: it is the color that fills most of the grid and is left unchanged in the outputs. Treat every other color as an object color and focus on how those object colors are moved or combined.</description>\\n<example>Imagine a 6×6 grid filled mostly with color A and a few isolated pixels of colors B and C. In the output A is still the dominant color; you can ignore A and concentrate on where B and C appear relative to each other and to the background.</example>\\n</note1>\\n\\n<note2>\\n<description>Group non-background pixels into connected components (4‑connectivity). Each connected component is a separate object you should consider independently when inferring the rule.</description>\\n<example>If you see three separate clusters of color B (one single pixel, one 2×2 block, one 3‑pixel line) and one cluster of color C, treat each of those clusters as distinct objects and compare their positions and shapes in input vs output.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare each object’s bounding box and internal arrangement in input and output to detect rigid transforms: translation (shift), rotation, reflection, or mirroring. Often the output places an object in a new location by moving it as a whole without changing its internal pattern.</description>\\n<example>Suppose a 2×2 square of color X appears at (r,c) in the input and you find a 2×2 square of X at (r+2,c+1) in the output; that suggests a translation of 2 rows and 1 column. If the square’s pixels are in the same relative positions inside the moved box, it’s a rigid translation.</example>\\n</note3>\\n\\n<note4>\\n<description>Look for consistent offsets between object positions across all examples. If the same offset (same row and column change) appears for multiple objects, it’s likely the systematic rule used to place them in the outputs.</description>\\n<example>If several different colored objects are all shifted by the same (dr,dc) in the examples, record that (dr,dc) and apply it to each object in the test input to predict where they should appear.</example>\\n</note4>\\n\\n<note5>\\n<description>When applying the inferred rule, preserve each object’s internal pattern and color exactly; do not alter shapes, orientations, or colors unless the examples show such changes. Only translate (or apply the detected rigid transform) the objects and leave the background unchanged.</description>\\n<example>If an object is a 3‑pixel L‑shape, after your rule the L should remain an L with the same pixel counts and colors; only its coordinates will change according to the detected translation or transform.</example>\\n</note5>\",\n \"<note1>\\n<description>Spot the background and the candidate objects: the background is the single color that fills most cells, while the objects are contiguous clusters of other colors. Focusing on these clusters reduces the problem to a few small shapes to transform.</description>\\n<example>Imagine a grid mostly filled with color A and a few small clusters of colors B and C. Treat A as background and record each connected group of B and C pixels as an object to analyze separately.</example>\\n</note1>\\n\\n<note2>\\n<description>Compute the minimal bounding rectangle for each object (smallest axis-aligned box that contains it). This gives a fixed-size template you can compare across examples and reason about how the object might be copied or mirrored.</description>\\n<example>If a color appears as a 2×2 block, its bounding box is 2×2; if it appears as a 3×1 vertical bar, the bounding box is 3×1. Use those dimensions to reason about possible placements and transformations.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare the object's internal pattern to the background: the object may contain a contiguous patch of background-colored cells inside it. Treat that background patch as a \\\"hole\\\" or area to be filled by the object's color.</description>\\n<example>For instance, if a colored block contains a 1×1 background cell inside it, that single background cell is a candidate for filling by the block's color rather than leaving it as background.</example>\\n</note3>\\n\\n<note4>\\n<description>Look for a systematic placement rule: the object's color is often copied into the background holes in a consistent way across examples (e.g., mirrored or rotated copies placed at regular offsets). Find the same offset relation in each example and apply it to the test objects.</description>\\n<example>If you see a small object in the top-left and the same color appears at a regular horizontal or vertical offset elsewhere, try placing the same object (or its mirrored version) at that same offset in the test case, and check whether the background holes are filled accordingly.</example>\\n</note4>\\n\\n<note5>\\n<description>Use symmetry and overlap checks to decide which placement is correct: try the original orientation and mirrored/rotated orientations, and prefer the placement that fills background holes consistently while avoiding conflicts with other objects. Also verify that the overall color counts and relative positions match the examples.</description>\\n<example>If two placements would both fill background holes but only one matches the examples' pattern of repeated offsets and does not overwrite other objects, choose that one; if neither fits, try the other orientation or a mirrored copy and re-check.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the background color first: it is the color that fills most of the grid and is not part of the objects you will change. Treat any other color as a candidate object to be transformed. This step reduces noise and focuses attention on the meaningful shapes.</description>\\n<example>Imagine a 10×10 grid that is almost entirely blue with a few small red and yellow patches. Blue is the background; red and yellow are the objects you will inspect and possibly transform. Once you identify blue, ignore it when searching for object shapes.</example>\\n</note1>\\n\\n<note2>\\n<description>Group non-background pixels into connected components and compute each component’s bounding box (min/max row and column). The bounding box gives you a compact description of where an object sits and how big it is. Use the same connectivity rule (usually orthogonal) across the grid.</description>\\n<example>For instance, a cluster of three orange pixels in a row spans rows 4–5 and columns 7–8, so its bounding box is rows 4–5, cols 7–8. That box tells you the object’s size and location for comparison with other objects.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare bounding boxes by width and height to detect repeated motifs. Often the transformation is driven by a small square (a 2×2 or 3×3 block) that appears several times; these repeated blocks are the units you should align and copy. Look for the same dimensions repeating in different places.</description>\\n<example>If you see identical 3×3 red squares in two different rows and two different columns, treat each 3×3 as a motif. Those repeated motifs are the likely source of the change in the output rather than isolated single pixels.</example>\\n</note3>\\n\\n<note4>\\n<description>Look for a color that appears only inside one motif and nowhere else in the grid. That color is the “marker” to be propagated: it is copied into the empty cells of the other motif instances. The marker color is typically confined to one object and is the one to distribute.</description>\\n<example>Suppose one 3×3 blue block contains a single green pixel while another identical 3×3 is entirely blue. The green is the marker: the transformation will copy green into the other 3×3’s empty cells so both become filled with green.</example>\\n</note4>\\n\\n<note5>\\n<description>When you copy the marker, fill the entire motif’s bounding box (or the whole grid area of the motif) with that color while preserving the original motif’s placement. If multiple motifs exist, copy the marker into every motif’s bounding box; if only one motif has the marker, you may simply fill that motif’s box. Always keep the grid size and background unchanged.</description>\\n<example>Given two identical 3×3 motifs, one with a single marker pixel and the other empty, copy the marker into the empty motif’s 3×3 box so both boxes become uniformly filled with the marker color. Do not alter the background or other unrelated colors.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the dominant background color and treat every other color as an object. The transformation usually targets those non-background pixels and leaves the background untouched.</description>\\n<example>Imagine a grid filled with 0s and a few 2s and 3s scattered; first mark 0 as background and record all 2s and 3s as objects. Any change in the output will be limited to those object pixels, so focus on how those objects are altered rather than on the 0s.</example>\\n</note1>\\n\\n<note2>\\n<description>Group non-background pixels into connected components (4‑neighbour connectivity). Each connected patch is a candidate for a single transformation.</description>\\n<example>For example, two adjacent 2s form one component (a 2×2 block is a single component), while isolated 3s elsewhere form separate components. Work with these components rather than individual pixels when you reason about the transformation.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare component shapes: the key operation is to replace an object's shape with a uniform filled square that has the same side length as the object's bounding box. In other words, expand the bounding box into a filled square.</description>\\n<example>If a component occupies a 2×2 bounding box, change it into a filled 2×2 square; if a component occupies a 3×3 bounding box, change it into a filled 3×3 square. The rule is consistent across components of the same size.</example>\\n</note3>\\n\\n<note4>\\n<description>Preserve each component's color and its position: the filled square uses the component's original color and is placed at the component's bounding-box coordinates. Do not rotate or translate the square unless the examples show such an operation.</description>\\n<example>If a 3×3 block of color A appears in the input, you should place a 3×3 block of color A at the same location in the output; similarly for a 2×2 block of color B.</example>\\n</note4>\\n\\n<note5>\\n<description>Handle overlaps by applying the same rule to every component and checking for collisions: components that would overlap are resolved consistently (examples typically show one color appearing where overlaps occur). Use the training examples to infer which color wins when two filled squares would coincide.</description>\\n<example>When two components' filled squares would meet, inspect the training pairs to see which color appears in the overlapping cells; apply that same precedence when you place the squares on the test grid. If no overlap occurs, simply fill each component's bounding box uniformly.</example>\\n</note5>\",\n \"<note1>\\n<description>Look first for a dominant background color and treat all other colors as foreground objects. This separation makes it easy to focus on which pixels are being changed and which are acting as anchors.</description>\\n<example>Imagine a grid filled with color A except for a few pixels of colors B and C. If the output shows the same background A everywhere except for new B/C pixels, then B and C are the foreground objects you should track rather than A.</example>\\n</note1>\\n\\n<note2>\\n<description>Group foreground pixels into connected components (use orthogonal adjacency). Each component is a unit you will reason about independently — the transformation usually applies to whole components, not isolated single pixels.</description>\\n<example>If you find a 2×2 block of B and a lone pixel of C elsewhere, treat them as two separate components. You will analyze each component’s size, shape and location before deciding how it should be transformed.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide which components are anchors (they are preserved) and which are templates (they are duplicated or copied). Anchors typically occupy the same coordinates in input and output; templates are moved or repeated to fill empty areas.</description>\\n<example>Suppose a single B pixel remains in the same spot in the output while other B pixels are arranged around it — that lone B is an anchor and the other B pixels are templates that were copied into the surrounding empty space.</example>\\n</note3>\\n\\n<note4>\\n<description>When copying a template, align its bounding box so the template’s top-left (or some consistent corner) maps to the empty area’s top-left. Use the template’s shape and orientation as a stencil and fill the rectangular area with that template’s color.</description>\\n<example>If a 2×3 template appears in the input, and there is a 2×3 empty rectangle nearby, place the template so its top-left touches the empty rectangle’s top-left and fill that 2×3 block with the template color.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the same copying rule to every template color and then check for overlaps: if two templates would write to the same cell, the examples show a consistent precedence (usually the template that was copied later or the one that is not an anchor wins). Use this rule to resolve conflicts.</description>\\n<example>If two different templates would both write to cell X, compare their source positions and which template’s color appears in X in the output; use that precedence when placing overlapping templates in the test case.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the background by frequency: the color that fills most cells is the canvas. Treat every other color as an object to be analyzed or transformed. This separation tells you what stays fixed and what can be moved or copied.</description>\\n<example>Imagine a 6×6 grid where 30 cells are color A and a few cells are colors B and C. A is the background; B and C are objects. You can ignore A when deciding where to place new pixels and focus on how B and C are being used or copied.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for repeated 2×2 squares of the same non-background color: these are the building blocks of the transformation. If the same small square appears multiple times, it is likely the unit that will be replicated or used as a stamp.</description>\\n<example>For example, if you see two identical 2×2 blocks of color B separated by background cells, those two blocks are likely the source units. Record their positions and the pattern inside each 2×2 so you can reason about what to do with them.</example>\\n</note2>\\n\\n<note3>\\n<description>Check for a single isolated 2×2 block that contains three of one color and one of another (a 3+1 configuration). That unique 2×2 is often the template or seed whose pattern is copied elsewhere. Identifying which color is the “odd one out” in that 2×2 helps determine which color will be used when stamping.</description>\\n<example>Suppose one 2×2 block is [B B; B C] (three B, one C). That block stands out from the repeated 2×2s and is the likely source of the stamp: the three B cells may act as the stamp color and the C as the marker color.</example>\\n</note3>\\n\\n<note4>\\n<description>Try tiling the template: place copies of the template’s 2×2 pattern at regular offsets (for example, every other cell in both directions) across the background. The offset determines where the template’s “odd” cell lands, so a small shift can turn a 3+1 template into a uniform 2×2 of the stamp color.</description>\\n<example>Imagine stamping a 2×2 template [B B; B C] every two rows and every two columns. Each stamped block will have one C in a predictable position; if you shift the template by one cell, those C positions will move and the whole background can become filled by the stamp color while the C positions align with the original 3+1 block.</example>\\n</note4>\\n\\n<note5>\\n<description>Validate your hypothesis by checking invariants: the original 3+1 block should remain or become the only place where the marker color appears, and every other 2×2 region should become uniform (same color) after stamping. If either invariant fails, adjust the offset or which color you treat as the stamp vs. the marker.</description>\\n<example>After stamping, scan the grid: you should find only one 2×2 that still has the marker color (or none, if the stamping fully replaced it). All other 2×2 tiles should be uniform copies of the stamp color. If this is not true, try shifting the template by one cell and re-check.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the background and the small objects: one color usually fills most cells and the rest are compact clusters. Treat each cluster of non-background pixels as an object to be analyzed.</description>\\n<example>Imagine a 7×7 grid mostly filled with color A and three small blobs of colors B and C. Mark each blob as a separate object and record its color and the set of cells it occupies. This isolates what you must move or copy.</example>\\n</note1>\\n\\n<note2>\\n<description>Measure each object's bounding box and internal structure. Many ARC tasks copy the object's exact pixel pattern (including holes) rather than just its color, so record both the color and the relative arrangement of pixels inside the box.</description>\\n<example>If a red object occupies a 2×2 square but one cell inside is empty, note that the pattern is \\\"red on three cells\\\" with a hole. When you later reproduce that object elsewhere, keep the same relative positions of red and empty cells.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for an anchor: one object often stays in place while other objects are moved to or aligned with it. Determine which object serves as the fixed reference by comparing input/output coordinates.</description>\\n<example>In a small example, the blue square remains at the same coordinates in the output while two green squares appear aligned with it. That tells you to keep the blue square fixed and plan copies relative to it.</example>\\n</note3>\\n\\n<note4>\\n<description>Decide the placement rule for copies: copies are often placed so their bounding boxes overlap or touch the anchor's bounding box, and copies of one object are placed on top of the anchor's color. Use the same relative offset each time to reproduce the pattern.</description>\\n<example>If you copy a green 2×2 square to the anchor, place the green square so its bounding box overlaps the anchor's bounding box; if multiple green copies are needed, align them in the same offset so they form a regular arrangement.</example>\\n</note4>\\n\\n<note5>\\n<description>When placing copies, overwrite cells according to the stacking order (copies placed later overwrite earlier ones). Preserve the anchor's original cells and keep each copy's internal pattern (including holes) intact.</description>\\n<example>If you place a red square and then place a green square that covers some red cells, the final visible cells are green where the green was placed; red remains in cells not covered by green. Check that holes and relative offsets inside each copy are unchanged.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the background: the color that fills most cells. Once you know the background, any non-background pixels are the seeds that drive the transformation. This helps you focus on a few small objects instead of the whole grid.</description>\\n<example>Imagine a grid of mostly blue cells with a few red and yellow pixels sprinkled in. Treat blue as the background and ignore it when looking for the rule; the red and yellow pixels are the only ones you need to reason about.</example>\\n</note1>\\n\\n<note2>\\n<description>Group non-background pixels into connected components (use 4‑neighbour adjacency). Each connected component is an object to analyze and is usually the unit the rule acts on. Don’t assume a single global rule—different objects may be treated differently.</description>\\n<example>If two red pixels touch each other vertically and a yellow pixel sits alone, you have two components (a 2‑cell vertical bar and a single yellow cell). Treat each component separately when you compare input and output.</example>\\n</note2>\\n\\n<note3>\\n<description>Measure each component’s bounding box and compute its aspect ratio (width/height). The examples use the object’s aspect ratio to decide which side of the bounding box is “longer.” This tells you whether the object is taller, wider, or square.</description>\\n<example>A 3×2 rectangle has aspect ratio 1.5 (wider) while a 2×3 rectangle has ratio 0.67 (taller). You can use these ratios to classify objects and determine the orientation you should use when copying or filling.</example>\\n</note3>\\n\\n<note4>\\n<description>When an object’s aspect ratio is not 1, the output extends that object along the longer axis by copying its existing pixels into the empty cells inside its bounding box. In other words, the longer dimension is filled by repeating the object’s pattern. This makes the object more regular while keeping its original orientation.</description>\\n<example>If a component is a 1×3 row of color A, the rule produces a 3×3 filled block of A (copying the row into the missing cells to make a square). If it’s a 3×1 column, the rule produces a 3×3 filled block of that column’s color.</example>\\n</note4>\\n\\n<note5>\\n<description>If an object’s aspect ratio equals 1 (a square), the rule does not change that object—leave it as-is. Also, when multiple objects are present, each is handled independently and only fills its own bounding box (no merging with other objects). This prevents unintended overlaps or global changes.</description>\\n<example>Given a 2×2 colored square and a 1×2 horizontal bar elsewhere, the square remains unchanged while the horizontal bar is extended into a 2×2 filled block. If two different colors would fill the same cell, check the examples to see whether they are merged or kept separate; the training pairs usually avoid ambiguous conflicts.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the dominant background color and treat every other color as a foreground object. This isolates the parts of the grid that change between input and output so you can focus on how those objects are transformed.</description>\\n<example>Imagine a grid filled with blue except for a few red and green pixels. Mark blue as background and list all red/green pixels as objects; in the output you will only see those objects (and their new positions), not blue changes.</example>\\n</note1>\\n\\n<note2>\\n<description>Group foreground pixels into connected components and compute each component's minimal bounding rectangle (width × height). The bounding box captures the component's extent and is the unit that gets copied or transformed.</description>\\n<example>If you find two small 2×2 squares of different colors, record each as a 2×2 rectangle with its top-left coordinate. Those rectangles are the basic shapes you will use to reason about what happens to the grid.</example>\\n</note2>\\n\\n<note3>\\n<description>Look for a consistent spatial relation among the bounding boxes: often the boxes are arranged in a regular grid (e.g., a 3×3 pattern of boxes) and the transformation copies each box into the box that sits diagonally opposite it. That diagonal pairing is the core structural rule to test.</description>\\n<example>For a 3×3 arrangement of boxes, check whether each box's copy appears in the box two rows and two columns away; if that holds for every example, you have identified the diagonal-copying pattern.</example>\\n</note3>\\n\\n<note4>\\n<description>When a box is copied, it is not simply moved but is placed into the target box's coordinate and its color is preserved. The copy is therefore an exact same-color rectangle placed at the target box's location, so you can think of it as a rectangle-level copy rather than pixel-by-pixel painting.</description>\\n<example>If a 2×2 red rectangle is copied to a 2×2 blue rectangle, the blue rectangle becomes red at the same coordinates. In the output you will see the red pattern occupying the blue's bounding box.</example>\\n</note4>\\n\\n<note5>\\n<description>Use simple checks to validate your hypothesis: confirm that every non-background pixel in the output can be traced back to a copy of an input box, that the grid of boxes is regular, and that copies always land on boxes that are diagonally opposite. If any example fails these checks, reconsider whether you need a different pairing rule.</description>\\n<example>After you believe you have the diagonal-copy rule, verify each output non-background pixel matches a source box at the expected diagonal location; if all do, the rule is consistent and can be applied to the test input.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for small, compact non-background clusters that repeat across the grid. These compact clusters are the “seeds” or tiles that drive the transformation rather than isolated stray pixels.</description>\\n<example>Imagine a mostly uniform background with several tiny 2×2 squares of a single color scattered around; those 2×2 squares are the natural candidates to focus on. Ignore single pixels or long lines — they are not the repeating tiles.</example>\\n</note1>\\n\\n<note2>\\n<description>Compare corresponding tiles across the grid to find the consistent color relationship between them. Often one tile is the same color everywhere, and the other tiles are either that same color or a single contrasting color.</description>\\n<example>For instance, if you find three identical 2×2 tiles and in every case two tiles are color A and the third is color B, then A is the common tile color and B is the contrasting tile color to expect elsewhere.</example>\\n</note2>\\n\\n<note3>\\n<description>Use the tile that appears most frequently as the default fill color and the contrasting color as the marker to be propagated. The marker is used to fill the gaps where the common tile color is missing in the same relative positions.</description>\\n<example>If color A appears in most tiles and color B appears once, treat A as the filler and B as the marker. When you see a tile that lacks A in its marker positions, replace those missing cells with B so the tile becomes a mixed A/B tile.</example>\\n</note3>\\n\\n<note4>\\n<description>Apply the rule to every tile in the same orientation and alignment (same relative offset from the grid edges). Do not rotate, reflect, or change the size of the tiles — only fill missing cells with the marker.</description>\\n<example>If tiles are always 2×2 and sit at the same offsets from the borders in every example, fill each tile’s missing cells with the marker color while keeping the tile’s shape and orientation unchanged.</example>\\n</note4>\\n\\n<note5>\\n<description>Decide how to handle ambiguous tiles: if a tile already contains both colors, leave it as-is; if it contains only one color, fill the other color into the empty positions. After applying the rule to every tile, check that the overall pattern of A/B tiles is consistent with the examples.</description>\\n<example>For example, a tile that is entirely A stays A, a tile that is entirely B becomes A/B after filling, and a mixed tile remains mixed. Verify your result by confirming the same A/B arrangement appears in all tiles.</example>\\n</note5>\",\n \"<note1>\\n<description>First separate the background from the objects: the background is the color that fills most of the grid and the objects are the other colors that appear in compact shapes. Focusing on the minority colors isolates the pieces that are being transformed.</description>\\n<example>Imagine a grid of mostly green cells with a few small blue and red shapes; treat green as the background and blue/red as the objects. Mark each object's coordinates and colors so you can compare input vs output for those objects only.</example>\\n</note1>\\n\\n<note2>\\n<description>Look for a single source object (or one small object) whose color appears repeatedly in the output in different places. That color is the “painter” — it is the one being copied or propagated.</description>\\n<example>If the output contains many green pixels while the input had only one small green patch, suspect that green is being copied elsewhere. Check every occurrence of green in the output to see where it appears.</example>\\n</note2>\\n\\n<note3>\\n<description>For each painted cell in the output, determine whether it lies inside a different object's bounding box. If it does, the painted color has been placed inside the bounding box of another object (i.e., the bounding box is being filled with the painter's color).</description>\\n<example>Suppose a red bounding box has a blue pixel inside it in the output; that indicates the blue pixel came from outside and filled that red box. Repeat this check for every painted pixel to see which boxes were filled.</example>\\n</note3>\\n\\n<note4>\\n<description>Use the painter's own bounding box to infer the filling direction: the painter's pixels tend to appear on the side of the painter's box that is opposite to the source box. That side is the natural target for filling other boxes.</description>\\n<example>If the painter's box is on the left and you see many painted pixels on its right, the rule is “paint the side opposite the source.” Apply this idea to each painted cell to see whether it follows that same orientation.</example>\\n</note4>\\n\\n<note5>\\n<description>When you apply the rule, only fill empty cells inside a box (leave existing object pixels unchanged). Also, the painter's own original box may be left as-is or may be overwritten depending on how the propagation interacts with the source box.</description>\\n<example>Take a 2×2 box of color A and a single cell of color B outside it; if B is the painter, fill every empty cell inside A with B, but do not change any A cells that were already present. This preserves original object pixels while propagating the painter's color into empty space.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the dominant background color and treat every other color as a seed: the background is usually the most frequent color and forms the canvas; all other colors are the objects that will be transformed.</description>\\n<example>Imagine a 6×6 grid where 30 cells are color A and the remaining cells are small clusters of B and C. Color A is the background; you should ignore A when deciding which objects to change and instead focus on the B and C clusters.</example>\\n</note1>\\n\\n<note2>\\n<description>Group non-background pixels into connected components (orthogonal adjacency) and compute each component's minimal bounding rectangle. This isolates each object so you can reason about its shape independently.</description>\\n<example>For instance, if a cluster occupies cells (2,3),(2,4),(3,3) then its bounding box is rows 2–3 and cols 3–4 (a 2×2 rectangle). Treat that whole rectangle as the object's footprint rather than individual pixels.</example>\\n</note2>\\n\\n<note3>\\n<description>Decide which seed color to propagate by comparing seed frequency and by checking which seed's bounding box is larger. The chosen seed is the one that appears most often or has the largest bounding-box area; that color is used to fill the box.</description>\\n<example>If you have two small 2×2 clusters of colors X and Y and X appears three times while Y appears once, choose X to be the fill color because it is the most frequent. If two seeds are equal in count, pick the one whose bounding box covers more cells (or use a consistent tie-breaker).</example>\\n</note3>\\n\\n<note4>\\n<description>Fill every cell inside the chosen seed's bounding rectangle with that seed color; do not alter cells outside that rectangle. This operation preserves the original seed pixels and produces a contiguous filled block.</description>\\n<example>Given a 2×2 bounding box for a color Z, set all four cells in that box to Z so the cluster becomes a solid square; leave all other pixels unchanged.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the same rule to every non-background component: for each component compute its bounding box, select its seed color using the frequency/area rule, and fill that box. Watch for multiple components of the same seed color—each gets filled independently.</description>\\n<example>If two separate clusters both use color W, compute W's bounding box for each cluster and fill each box completely. If a cluster has no non-background neighbors (it is isolated), its bounding box is just itself and it will be filled with its seed color.</example>\\n</note5>\",\n \"<note1>\\n<description>First separate the background from foreground: identify the single color that fills most of the grid and treat every other color as an object to analyze. This reduces the problem to a few discrete shapes instead of the whole grid. A reliable way is to count occurrences or visually inspect the largest contiguous region.</description>\\n<example>Imagine a 6×6 grid where 30 cells are color A and the remaining 6 cells are colors B and C. Color A is the background; B and C are the objects. Work with B and C positions and ignore A when searching for the transformation.</example>\\n</note1>\\n\\n<note2>\\n<description>Check each non-background color for a compact, rectangular footprint: determine its bounding box and whether the bounding box is filled (a filled rectangle) or only partially filled (a mask). Filled rectangles are easier to reason about and often act as templates for copying. If a color has a bounding box but many cells inside are background, treat it as a mask rather than a filled block.</description>\\n<example>For instance, if color X occupies cells whose coordinates lie inside a 2×3 box and every cell inside that box is X, then X is a filled rectangle. If some interior cells are background, X is a mask (its shape is the pattern you should reproduce).</example>\\n</note2>\\n\\n<note3>\\n<description>Find the template by size: the template is typically the largest filled rectangle (largest bounding box where every cell inside is that color). Once you have the template, record its color, width, height, and the exact pattern of foreground/background inside it. This template is the pattern you will replicate elsewhere.</description>\\n<example>Suppose you find a 3×2 filled rectangle of color Y and a 2×2 filled rectangle of color Z; Y is the template because it is larger. Note that the template’s internal arrangement (which cells inside the box are foreground) is the pattern you must reproduce when copying.</example>\\n</note3>\\n\\n<note4>\\n<description>Locate the other non-background color and compute its bounding box. The transformation often copies the template into the empty cells of that box (preserving the template’s internal pattern) rather than filling the whole box uniformly. If the other color’s bounding box is exactly the template’s size, the copy will exactly match the template; otherwise the copy will be the template’s pattern placed into the box.</description>\\n<example>If the template is 3×2 and the other color’s bounding box is also 3×2, copy the template into that box so the box becomes a filled 3×2 of the template color. If the other box is 4×3, place the 3×2 template into the empty cells of that 4×3 box while keeping the template’s internal arrangement.</example>\\n</note4>\\n\\n<note5>\\n<description>After copying, verify the result: the template color should now occupy the previously-empty cells of the target box (and the template itself may remain), while other objects keep their original colors. If there are multiple candidate boxes, prefer the one that matches the template’s size or the one whose empty cells best receive the template’s pattern. Avoid overwriting other non-background objects.</description>\\n<example>After copying a 3×2 template into a target 3×2 box, the box should be uniformly the template color and the original object should still appear elsewhere. If two boxes could accept the template, pick the one that is empty and whose size aligns with the template.</example>\\n</note5>\",\n \"<note1>\\n<description>Find the background first: the most frequent color is usually the filler that remains unchanged. Treat any other color(s) as the objects to be transformed. This separation reduces the problem to a few small shapes instead of the whole grid.</description>\\n<example>Imagine a grid of mostly green cells with a few red and blue pixels. Call green the background and focus on the red/blue pixels as the objects; you will only change those objects and leave green alone. This keeps the transformation local and easier to reason about.</example>\\n</note1>\\n\\n<note2>\\n<description>Group non-background pixels into connected components using orthogonal adjacency (up/down/left/right). Each contiguous patch is an independent object to consider. Connected components are the natural units for copying or moving.</description>\\n<example>On a small grid, if red pixels at (2,3) and (3,3) touch, they form one component; a blue pixel at (4,5) is a separate component. Work with these components rather than individual pixels to avoid accidental overwrites.</example>\\n</note2>\\n\\n<note3>\\n<description>Identify a distinctive \\\"anchor\\\" color inside each component: the color that appears only a few times or appears in a unique shape. That color usually determines where the component will be moved or copied. Use frequency and uniqueness as cues rather than arbitrary choice.</description>\\n<example>If one component contains blue only in a 2×2 block and another contains red only as isolated pixels, treat the blue block as the anchor for that component. The anchor color is the one you will track when you copy the whole component.</example>\\n</note3>\\n\\n<note4>\\n<description>Copy each component as a rigid block: preserve its exact shape and internal arrangement and place it at the same relative offset inside its anchor cell. That is, translate the whole component by the anchor's displacement from the original anchor position. Do not rotate, reflect, or recolor the component when copying.</description>\\n<example>Suppose a 2×2 blue block sits at the top-left of its anchor cell and you find another anchor at the bottom-right; copy the 2×2 block so it occupies the top-left of that new anchor cell. The relative pattern inside the block stays identical, only its location changes.</example>\\n</note4>\\n\\n<note5>\\n<description>Apply the copy only where it fits inside the grid and leave all other cells unchanged. If a copy would fall outside the grid, it is simply not placed; otherwise it overwrites the original anchor cell and any background cells it occupies. Treat each anchor independently and leave the background untouched.</description>\\n<example>If an anchor sits on the last row and you copy the component above it, the copy will stay inside the grid and overwrite the original anchor area; if an anchor is on the last column, the copy would extend outside and is not applied. This ensures only valid placements change the grid.</example>\\n</note5>\",\n \"<note1>\\n<description>Look for the background color and treat every cell that is not background as part of a foreground object. This separates the sparse colored pixels into objects you can analyze independently.</description>\\n<example>Imagine a 6×6 grid where most cells are 0 and a few are 1 or 2. First mark all 1s and 2s as foreground and ignore the 0s. Working with those foreground coordinates makes it easier to spot which pixels are being reused or copied.</example>\\n</note1>\\n\\n<note2>\\n<description>Group foreground pixels into connected components (use orthogonal adjacency). Each component is a candidate object to be propagated or copied across the grid.</description>\\n<example>For instance, if you see three separate clusters of 1s separated by at least one 0 cell, treat them as three independent objects. Each object will have its own bounding box and internal arrangement you can compare across examples.</example>\\n</note2>\\n\\n<note3>\\n<description>Compare how each object’s bounding box appears in the output: the transformation often copies an entire component’s pattern (shape and colors) into a contiguous rectangular area. Think “crop the object, then paste that crop into a rectangle” rather than changing individual pixels one by one.</description>\\n<example>If a 2×2 red square appears in the input and the output shows a larger contiguous red area, it is likely the 2×2 was cropped and then copied into a larger rectangle elsewhere. The crop preserves the relative arrangement of the red pixels inside that rectangle.</example>\\n</note3>\\n\\n<note4>\\n<description>Find the source of the copied pattern by locating the original object that matches the crop: the source’s bounding box will contain the same internal arrangement of colors. Use that source to determine where and how the crop was placed.</description>\\n<example>Suppose you detect a small 2×3 green patch in the input and later find a larger green rectangle in the output; inspect the smaller patch to see the green pixels’ layout and then search the larger rectangle for that same layout — that smaller patch is the source.</example>\\n</note4>\\n\\n<note5>\\n<description>When you apply the rule to the test grid, do not alter the original object; instead place copies of the source crop into the target rectangles that already exist in the output examples. Preserve the source’s orientation and color arrangement when copying.</description>\\n<example>If the training output shows a source object copied into a particular rectangle, locate that rectangle in the test input and paste the source crop there exactly (same colors, same relative positions). This keeps the transformation consistent and avoids changing the original object.</example>\\n</note5>\"\n]","isConversational":false},"train":{"kind":"string","value":"[{\"input\": [[3, 3, 3, 3, 3, 3, 3, 4, 3, 3], [4, 3, 3, 3, 3, 4, 3, 3, 8, 3], [3, 8, 3, 3, 8, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 8, 8, 8, 3, 4, 3], [3, 3, 3, 3, 8, 8, 8, 3, 3, 8], [3, 3, 3, 3, 8, 8, 8, 3, 3, 3], [3, 4, 4, 4, 3, 3, 3, 3, 9, 4], [3, 4, 4, 4, 3, 3, 3, 3, 8, 9], [3, 4, 4, 4, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 4], [3, 3, 3, 3, 3, 3, 3, 3, 8, 3]], \"output\": [[3, 3, 3, 3, 3, 3, 3, 4, 9, 3], [4, 9, 3, 3, 9, 4, 3, 9, 8, 3], [9, 8, 3, 3, 8, 9, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 9, 9, 9, 8, 8, 8, 3, 4, 9], [3, 9, 9, 9, 8, 8, 8, 3, 9, 8], [3, 9, 9, 9, 8, 8, 8, 3, 3, 3], [3, 4, 4, 4, 9, 9, 9, 3, 9, 4], [3, 4, 4, 4, 9, 9, 9, 3, 8, 9], [3, 4, 4, 4, 9, 9, 9, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 9, 4], [3, 3, 3, 3, 3, 3, 3, 3, 8, 9]]}, {\"input\": [[6, 6, 6, 6, 6, 6, 2, 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, 6, 7, 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, 7, 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, 7, 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, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [7, 8, 6, 8, 6, 2, 6, 6, 6, 6, 6, 6], [8, 8, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 8, 6, 6, 6, 6, 6, 6, 6, 6], [8, 6, 8, 2, 6, 6, 6, 6, 7, 6, 6, 6]], \"output\": [[6, 6, 6, 6, 6, 6, 2, 8, 6, 8, 6, 6], [6, 6, 6, 6, 6, 6, 8, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 6, 6], [6, 8, 6, 8, 2, 6, 8, 6, 8, 7, 6, 6], [6, 6, 6, 6, 8, 6, 6, 6, 6, 6, 6, 6], [6, 8, 8, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 7, 8, 6, 8, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 7, 8, 6, 8, 6, 6, 6, 6], [6, 6, 6, 6, 8, 8, 6, 6, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 8, 6, 6, 6, 6], [6, 6, 6, 6, 8, 6, 8, 2, 6, 6, 6, 6], [6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [7, 8, 6, 8, 6, 2, 8, 6, 8, 6, 6, 6], [8, 8, 6, 6, 6, 8, 6, 6, 6, 6, 6, 6], [6, 6, 6, 8, 6, 6, 6, 8, 8, 6, 6, 6], [8, 6, 8, 2, 6, 8, 6, 8, 7, 6, 6, 6]]}, {\"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, 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, 8, 8, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 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, 5, 5, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 5, 5, 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, 4, 4, 5, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 7, 4, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 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, 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]], \"output\": [[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, 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, 4, 4, 4, 4, 8, 8, 7], [7, 7, 7, 7, 7, 7, 4, 4, 4, 4, 8, 8, 7], [7, 7, 7, 7, 7, 7, 4, 4, 7, 7, 4, 4, 7], [7, 7, 7, 7, 7, 7, 4, 4, 7, 7, 4, 4, 7], [7, 7, 7, 7, 7, 7, 5, 5, 4, 4, 4, 4, 7], [7, 7, 7, 7, 7, 7, 5, 5, 4, 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, 4, 4, 5, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 7, 4, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 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, 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]]}]"},"test":{"kind":"string","value":"[{\"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, 4, 4, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 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, 8, 8, 8, 8, 0, 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, 8, 8, 8, 8, 8], [8, 8, 8, 0, 6, 6, 6, 8, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 4], [8, 8, 8, 6, 6, 8, 6, 8, 0, 0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 6, 8, 8, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 6, 6, 6, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]], \"output\": [[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, 6, 6, 6, 6, 6, 6, 4, 4, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 6, 6, 6, 6, 6, 6, 4, 4, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 6, 6, 8, 8, 8, 8, 6, 6, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 6, 6, 8, 8, 8, 8, 6, 6, 8, 8, 0, 6, 6, 6], [8, 8, 8, 8, 8, 8, 8, 8, 6, 6, 6, 6, 8, 8, 6, 6, 8, 8, 6, 6, 8, 6], [8, 8, 8, 8, 8, 8, 8, 8, 6, 6, 6, 6, 8, 8, 6, 6, 8, 8, 6, 8, 8, 6], [8, 8, 8, 0, 6, 6, 6, 8, 0, 0, 6, 6, 6, 6, 6, 6, 8, 8, 6, 6, 6, 4], [8, 8, 8, 6, 6, 8, 6, 8, 0, 0, 6, 6, 6, 6, 6, 6, 8, 8, 8, 8, 8, 8], [8, 8, 8, 6, 8, 8, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 6, 6, 6, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]]}]"},"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```\n3 3 3 3 3 3 3 4 3 3\n4 3 3 3 3 4 3 3 8 3\n3 8 3 3 8 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 3\n3 3 3 3 8 8 8 3 4 3\n3 3 3 3 8 8 8 3 3 8\n3 3 3 3 8 8 8 3 3 3\n3 4 4 4 3 3 3 3 9 4\n3 4 4 4 3 3 3 3 8 9\n3 4 4 4 3 3 3 3 3 3\n3 3 3 3 3 3 3 3 3 4\n3 3 3 3 3 3 3 3 8 3\n```\n\nOutput:\n```\n3 3 3 3 3 3 3 4 9 3\n4 9 3 3 9 4 3 9 8 3\n9 8 3 3 8 9 3 3 3 3\n3 3 3 3 3 3 3 3 3 3\n3 9 9 9 8 8 8 3 4 9\n3 9 9 9 8 8 8 3 9 8\n3 9 9 9 8 8 8 3 3 3\n3 4 4 4 9 9 9 3 9 4\n3 4 4 4 9 9 9 3 8 9\n3 4 4 4 9 9 9 3 3 3\n3 3 3 3 3 3 3 3 9 4\n3 3 3 3 3 3 3 3 8 9\n```\n\n## Example 2\nInput:\n```\n6 6 6 6 6 6 2 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 2 6 6 6 6 7 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 7 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 7 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 2 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n7 8 6 8 6 2 6 6 6 6 6 6\n8 8 6 6 6 6 6 6 6 6 6 6\n6 6 6 8 6 6 6 6 6 6 6 6\n8 6 8 2 6 6 6 6 7 6 6 6\n```\n\nOutput:\n```\n6 6 6 6 6 6 2 8 6 8 6 6\n6 6 6 6 6 6 8 6 6 6 6 6\n6 6 6 6 6 6 6 6 8 8 6 6\n6 8 6 8 2 6 8 6 8 7 6 6\n6 6 6 6 8 6 6 6 6 6 6 6\n6 8 8 6 6 6 6 6 6 6 6 6\n6 7 8 6 8 6 6 6 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n6 6 6 6 7 8 6 8 6 6 6 6\n6 6 6 6 8 8 6 6 6 6 6 6\n6 6 6 6 6 6 6 8 6 6 6 6\n6 6 6 6 8 6 8 2 6 6 6 6\n6 6 6 6 6 6 6 6 6 6 6 6\n7 8 6 8 6 2 8 6 8 6 6 6\n8 8 6 6 6 8 6 6 6 6 6 6\n6 6 6 8 6 6 6 8 8 6 6 6\n8 6 8 2 6 8 6 8 7 6 6 6\n```\n\n## Example 3\nInput:\n```\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 8 8 7\n7 7 7 7 7 7 7 7 7 7 8 8 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 5 5 7 7 7 7 7\n7 7 7 7 7 7 5 5 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 4 4 5 7\n7 7 7 7 7 7 7 7 7 4 7 4 7\n7 7 7 7 7 7 7 7 7 8 4 4 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n```\n\nOutput:\n```\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 4 4 4 4 8 8 7\n7 7 7 7 7 7 4 4 4 4 8 8 7\n7 7 7 7 7 7 4 4 7 7 4 4 7\n7 7 7 7 7 7 4 4 7 7 4 4 7\n7 7 7 7 7 7 5 5 4 4 4 4 7\n7 7 7 7 7 7 5 5 4 4 4 4 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 4 4 5 7\n7 7 7 7 7 7 7 7 7 4 7 4 7\n7 7 7 7 7 7 7 7 7 8 4 4 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n7 7 7 7 7 7 7 7 7 7 7 7 7\n```\n\n# Test Problem:\n```\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 4 4 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 4 4 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 0 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 0 6 6 6 8 0 0 8 8 8 8 8 8 8 8 8 8 8 4\n8 8 8 6 6 8 6 8 0 0 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 6 8 8 6 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 6 6 6 4 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n```"},"answer":{"kind":"string","value":"```\n8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 6 6 6 6 6 6 4 4 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 6 6 6 6 6 6 4 4 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 6 6 8 8 8 8 6 6 8 8 8 8 8 8\n8 8 8 8 8 8 8 8 6 6 8 8 8 8 6 6 8 8 0 6 6 6\n8 8 8 8 8 8 8 8 6 6 6 6 8 8 6 6 8 8 6 6 8 6\n8 8 8 8 8 8 8 8 6 6 6 6 8 8 6 6 8 8 6 8 8 6\n8 8 8 0 6 6 6 8 0 0 6 6 6 6 6 6 8 8 6 6 6 4\n8 8 8 6 6 8 6 8 0 0 6 6 6 6 6 6 8 8 8 8 8 8\n8 8 8 6 8 8 6 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n8 8 8 6 6 6 4 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8\n```"},"num_tokens":{"kind":"number","value":3138,"string":"3,138"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":0,"numItemsPerPage":100,"numTotalItems":1396,"offset":0,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4MDczNDI0Nywic3ViIjoiL2RhdGFzZXRzL2FzaW5naDE1L2FyYy1iYXJjLXByb2Nlc3NlZC1kaXJlY3QtbWF4NGstc2Z0YWJzLTRvZjgiLCJleHAiOjE3ODA3Mzc4NDcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.UUZkgNj1B1YBeQWEsjp40mw3pZc9eljwvY-veisDMQuwX1SDi5e9q4GAcCslgEKHqvFDeSQSq-7TrY2L92p9Cg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"test","numRows":15,"numBytesParquet":853785},{"config":"default","split":"train","numRows":1396,"numBytesParquet":30188271}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
abstraction_prompt stringlengths 4.74k 8.5k | abstraction_prompt_length int64 1.05k 4.8k | generated_abstractions listlengths 16 16 | train stringlengths 255 5.83k | test stringlengths 57 5.94k | source stringclasses 4
values | prompt stringlengths 1.24k 5k | answer stringlengths 9 1.69k | num_tokens int64 346 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... | 2,174 | [
"<note1>\n<description>Look for a single non-background pixel in the input that serves as the anchor for the whole transformation. That anchor is not moved and remains the center of the added structure in the output.</description>\n<example>If an input contains one isolated colored pixel, treat that pixel as the re... | [{"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, 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]], "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, 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, 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 7 7 0
0 0 0 0 0 0 7 7 7
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 0
0 0 0 0 0 0 0 0 0
0 0 0 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,470 |
<|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 output is a simple uniform replacement of the input: if every output row equals the same row, the transformation is a single-row-to-row mapping applied across the whole grid. This reduces the task to finding how one row is converted into another.</description>\n<example>Imag... | [{"input": [[4, 1, 9, 8, 5], [4, 1, 9, 8, 5], [4, 1, 9, 8, 5], [4, 1, 9, 8, 5], [4, 1, 9, 8, 5]], "output": [[6, 2, 3, 9, 8], [6, 2, 3, 9, 8], [6, 2, 3, 9, 8], [6, 2, 3, 9, 8], [6, 2, 3, 9, 8]]}, {"input": [[2, 8, 2, 4, 4], [2, 8, 2, 4, 4], [2, 8, 2, 4, 4], [2, 8, 2, 4, 4], [2, 8, 2, 4, 4]], "output": [[4, 9, 4, 6, 6],... | [{"input": [[1, 1, 2, 1, 2], [1, 1, 2, 1, 2], [1, 1, 2, 1, 2], [1, 1, 2, 1, 2], [1, 1, 2, 1, 2]], "output": [[2, 2, 4, 2, 4], [2, 2, 4, 2, 4], [2, 2, 4, 2, 4], [2, 2, 4, 2, 4], [2, 2, 4, 2, 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... | ```
2 2 4 2 4
2 2 4 2 4
2 2 4 2 4
2 2 4 2 4
2 2 4 2 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... | 3,380 | [
"<note1>\n<description>First check whether the transformation preserves the grid shape and only changes colors. If the output grid has the same dimensions as the input, the rule is likely a color remapping (a permutation of colors) rather than a spatial rearrangement.</description>\n<example>Imagine a 3×3 input wit... | [{"input": [[3, 6, 3, 6, 2, 4, 3, 6, 2, 3, 4, 4, 6, 6, 4, 4, 3, 3, 2, 6, 2, 2, 2, 6, 6, 2], [3, 4, 6, 6, 6, 4, 2, 3, 3, 2, 4, 2, 4, 6, 2, 2, 3, 3, 4, 2, 6, 6, 2, 2, 3, 6], [2, 3, 4, 3, 2, 6, 2, 2, 2, 4, 2, 2, 3, 6, 2, 4, 6, 3, 4, 3, 6, 3, 4, 2, 4, 2], [6, 6, 2, 2, 2, 2, 4, 6, 3, 4, 3, 2, 2, 6, 2, 2, 3, 3, 3, 4, 3, 3, 3... | [{"input": [[6, 3, 8, 6, 8], [3, 8, 3, 3, 8], [8, 6, 6, 6, 8], [3, 3, 6, 3, 3], [6, 8, 8, 3, 8], [6, 6, 3, 6, 8], [6, 3, 6, 8, 8], [8, 6, 8, 3, 6], [6, 8, 6, 8, 6], [8, 3, 6, 6, 6], [3, 6, 8, 8, 8]], "output": [[2, 4, 9, 2, 9], [4, 9, 4, 4, 9], [9, 2, 2, 2, 9], [4, 4, 2, 4, 4], [2, 9, 9, 4, 9], [2, 2, 4, 2, 9], [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... | ```
2 4 9 2 9
4 9 4 4 9
9 2 2 2 9
4 4 2 4 4
2 9 9 4 9
2 2 4 2 9
2 4 2 9 9
9 2 9 4 2
2 9 2 9 2
9 4 2 2 2
4 2 9 9 9
``` | 2,676 |
<|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,780 | [
"<note1>\n<description>Look first for a single connected group of non-background pixels and treat it as one object. When the transformation is object-centric, the whole object is recolored while the rest of the grid stays unchanged.</description>\n<example>Imagine a grid with one contiguous blob of color 1 on a bla... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 0, 0], [3, 3, 3, 3, 3, 3, 3, 3], [0, 3, 3, 3, 0, 3, 3, 3], [0, 3, 0, ... | [{"input": [[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, 1, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 1, 1, 1, 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
3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3
0 0 0 0 3 3 0 0 3
3 3 3 3 3 3 3 3 3
3 3 3 3 3 3 3 3 3
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0
``` | 1,076 |
<|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,300 | [
"<note1>\n<description>Look first for a full-length separator: a row or column where every cell is the same color. Such a line is usually the intended cut that partitions the grid into two rectangular blocks. Finding it is the key first step because it tells you where the transformation happens.</description>\n<exa... | [{"input": [[2, 2, 9, 2, 2, 6, 2, 2, 0, 2, 2], [2, 2, 2, 2, 2, 6, 2, 2, 2, 2, 2]], "output": [[3, 3, 2, 3, 3], [3, 3, 3, 3, 3]]}, {"input": [[0, 4, 0, 4, 4, 4, 0, 4, 4, 4, 4, 4, 1, 0, 0, 6, 0, 6, 6, 6, 0, 0, 6, 6, 6], [0, 4, 0, 4, 4, 4, 4, 4, 4, 0, 4, 4, 1, 6, 0, 6, 6, 6, 0, 0, 0, 6, 6, 6, 6], [4, 4, 4, 4, 4, 4, 4, 4, ... | [{"input": [[6, 6, 1, 6, 6, 6, 6, 1, 1], [6, 6, 1, 6, 6, 1, 1, 1, 6], [6, 6, 1, 6, 6, 1, 1, 1, 6], [6, 1, 6, 1, 1, 6, 6, 1, 6], [6, 1, 6, 1, 1, 6, 6, 1, 6], [6, 1, 6, 6, 1, 6, 1, 1, 1], [6, 6, 6, 6, 6, 6, 6, 6, 6], [1, 1, 1, 1, 1, 6, 6, 6, 1], [1, 6, 6, 1, 6, 1, 6, 1, 6], [7, 7, 7, 7, 7, 7, 7, 7, 7], [5, 5, 6, 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 6 6 6 6 6 6 6 6
3 6 6 6 3 6 6 6 3
6 3 6 6 6 6 6 6 6
6 6 3 6 6 3 3 6 3
6 6 3 6 6 6 6 6 3
6 6 3 3 6 6 6 6 6
3 6 3 3 6 6 6 3 6
6 6 6 6 6 6 6 3 6
6 3 3 6 6 6 6 6 3
``` | 2,596 |
<|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,238 | [
"<note1>\n<description>Compare overall sizes first: if the output's number of rows and columns is an integer multiple of the input's, the transformation is likely a uniform scaling (an integer factor k). This tells you to look for repeated tiles or blocks rather than a reordering of colors.</description>\n<example>... | [{"input": [[9, 9, 1, 6], [9, 9, 6, 6], [1, 6, 9, 9], [6, 6, 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, 9, 6, 6, 6, 6, 9, 9, 9, 9], [9, 9, 9, 9, 6, 6, 6, 6, 9, 9, 9, 9], [9, 9, 6, 6, 6, 6, 6, 6, 9, 9, 9, 9], [9, 9, 6, 6, 6, 6, 6, 6, 9, 9, 9, 9], [9, 9, 6, 6,... | [{"input": [[1, 1, 1, 1, 1, 1], [2, 2, 1, 1, 1, 1], [2, 8, 1, 2, 2, 1], [1, 1, 1, 2, 8, 1]], "output": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2, 2, 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 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 1
1 1 1 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
1 1 1 1 2 2 2 2 2 2 2 1 1 1 1 1 1 1
1 1 1 1 2 2 2 2 2 2 2 1 1 1 1 1 1 1
1 1 1 1 2 2 2 2 2 2 2 1 1 1 ... | 1,534 |
<|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,640 | [
"<note1>\n<description>Start by comparing the two grids cell-by-cell. If every cell in the output corresponds to the same color as the input, the transformation is a reordering (a permutation of positions) rather than a recoloring. This narrows the search to spatial rearrangements only.</description>\n<example>For ... | [{"input": [[4], [9], [4], [4], [4], [9], [9], [9], [1], [4], [4], [4], [1], [7], [7], [4], [9], [4], [1], [4], [9], [4], [7]], "output": [[7], [4], [9], [4], [1], [4], [9], [4], [7], [7], [1], [4], [4], [4], [1], [9], [9], [9], [4], [4], [4], [9], [4]]}, {"input": [[4, 4, 7, 4, 4, 0, 4, 4, 4, 4, 9, 4, 4, 4, 0, 4, 0, 4... | [{"input": [[8], [8], [0], [5], [5], [3], [8], [6], [8], [8], [4], [1], [7], [8], [8], [8], [9], [8], [2]], "output": [[2], [8], [9], [8], [8], [8], [7], [1], [4], [8], [8], [6], [8], [3], [5], [5], [0], [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... | ```
2
8
9
8
8
8
7
1
4
8
8
6
8
3
5
5
0
8
8
``` | 2,936 |
<|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,634 | [
"<note1>\n<description>Look for a small, consistent sub-block (often 2×2) that appears repeatedly across the whole input. When the same small block recurs many times, it is a strong candidate for the output because the task often isolates a repeated motif.</description>\n<example>Imagine a large grid that contains ... | [{"input": [[4, 3, 3, 0, 0, 4, 4, 3, 4, 0, 4, 3, 3, 0, 4, 4, 0, 0, 0, 3, 4, 0, 4], [4, 0, 4, 3, 3, 0, 4, 3, 0, 0, 4, 3, 0, 0, 4, 0, 0, 4, 3, 0, 4, 0, 4], [0, 3, 0, 0, 0, 3, 0, 0, 4, 0, 4, 4, 0, 4, 0, 0, 0, 0, 0, 0, 4, 0, 3], [4, 0, 4, 3, 3, 0, 3, 4, 0, 4, 0, 0, 0, 3, 4, 0, 4, 0, 0, 0, 4, 0, 4], [3, 0, 3, 0, 0, 4, 4, 4,... | [{"input": [[6, 3, 6, 4, 6, 6, 6, 6, 4, 4, 6, 3, 6, 6], [4, 6, 4, 6, 4, 6, 4, 6, 6, 6, 6, 4, 3, 6], [6, 4, 6, 4, 4, 3, 6, 3, 6, 4, 3, 6, 3, 6], [4, 3, 4, 4, 6, 6, 6, 4, 6, 4, 3, 6, 6, 4], [3, 3, 3, 6, 4, 3, 6, 3, 6, 4, 4, 3, 6, 3], [4, 6, 6, 4, 4, 3, 6, 3, 6, 6, 3, 3, 6, 6], [6, 4, 3, 4, 6, 6, 3, 3, 4, 3, 4, 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... | ```
6 3
4 6
``` | 2,930 |
<|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,830 | [
"<note1>\n<description>Find the two dominant colors and treat them as the only meaningful objects: one will form a continuous band (two or more rows or columns) and the other will occupy the remaining area. This separation reduces the problem to working with two simple shapes instead of many isolated pixels.</descr... | [{"input": [[9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 0, 0], [9, 9, 9, 9, 9, 9, 9, 9, 9, ... | [{"input": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [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, 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, 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, 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... | ```
1 1 1 1 1 1 1 1 1 1 1 1 1
4 2 9 9 9 9 9 9 9 9 9 9 9
4 9 2 9 9 9 9 9 9 9 9 9 9
4 9 9 2 9 9 9 9 9 9 9 9 9
4 9 9 9 2 9 9 9 9 9 9 9 9
4 9 9 9 9 2 9 9 9 9 9 9 9
4 9 9 9 9 9 2 9 9 9 9 9 9
4 9 9 9 9 9 9 2 9 9 9 9 9
4 9 9 9 9 9 9 9 2 9 9 9 9
4 9 9 9 9 9 9 9 9 2 9 9 9
``` | 2,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... | 1,264 | [
"<note1>\n<description>First check whether the output is a single cell and what it represents. If the output is a single color, the transformation is likely a selection from the input rather than a reshaping or repositioning of the whole grid.</description>\n<example>Imagine several 6×6 puzzles where every output i... | [{"input": [[1, 7, 2, 9, 6, 3], [8, 7, 4, 3, 8, 1], [3, 6, 3, 9, 5, 8], [6, 9, 7, 8, 1, 8], [6, 7, 7, 2, 8, 7], [2, 1, 4, 4, 7, 6]], "output": [[2]]}, {"input": [[5, 3, 2, 3, 7, 1], [6, 2, 6, 8, 2, 1], [7, 2, 9, 1, 9, 6], [4, 1, 6, 1, 3, 8], [6, 1, 5, 9, 5, 9], [9, 1, 4, 7, 8, 1]], "output": [[2]]}, {"input": [[9, 3, 7... | [{"input": [[9, 1, 6, 5, 3, 1], [1, 7, 6, 9, 4, 7], [6, 7, 1, 5, 1, 4], [9, 7, 8, 7, 7, 7], [9, 9, 1, 3, 5, 4], [9, 1, 8, 8, 4, 7]], "output": [[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... | ```
2
``` | 560 |
<|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>Group pixels by color and compute each connected component's bounding box and pixel count. This separates independent shapes from noise and gives you a concise representation of each object's size and position.</description>\n<example>Imagine a grid with two small colored patches: one a 2×2 s... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 3, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 5, 1, 0, 3, 0, 0, 0, 0, 0], [1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 5, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 7, 1, 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, 1, 0, 0, 0, 0, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0], [2, 2, 2, 0, 1, 1, 0, 0, 0, 7, 4, 0, 0, 0], [2, 2, 2, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0], [2, 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], ... | 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 1 1 0 0 0 1 1 0 0 0
0 0 0 0 1 1 0 0 0 7 4 0 0 0
0 0 0 0 1 1 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 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 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 ... | 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,848 | [
"<note1>\n<description>Look for a single color that fills most of the input grid (the background). Treat any other colors as foreground objects; the transformation usually preserves that background color and only moves or repositions the foreground pixels.</description>\n<example>Imagine a 7×7 grid where 4 fills ne... | [{"input": [[0, 0, 0, 4, 4, 4, 0], [4, 4, 3, 4, 4, 4, 0], [4, 4, 4, 4, 4, 4, 0], [4, 4, 8, 7, 4, 4, 0], [4, 4, 4, 4, 4, 4, 0], [4, 4, 4, 4, 4, 4, 0], [6, 4, 4, 0, 0, 0, 0]], "output": [[7, 4, 4, 0, 0, 0, 4, 4, 3], [4, 4, 4, 0, 0, 0, 4, 4, 4], [4, 4, 4, 0, 0, 0, 4, 4, 8], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, ... | [{"input": [[4, 4, 4, 4, 4, 1, 0], [4, 4, 4, 4, 4, 4, 0], [8, 4, 4, 4, 4, 6, 0], [0, 9, 4, 5, 0, 0, 0], [0, 4, 4, 4, 7, 4, 6], [0, 4, 4, 7, 4, 4, 4], [0, 0, 0, 0, 4, 4, 4]], "output": [[7, 4, 6, 0, 0, 0, 4, 4, 1], [4, 4, 4, 0, 0, 0, 4, 4, 4], [4, 4, 4, 0, 0, 0, 4, 4, 6], [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 4 6 0 0 0 4 4 1
4 4 4 0 0 0 4 4 4
4 4 4 0 0 0 4 4 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
4 4 4 0 0 0 0 0 0
4 4 4 0 0 0 0 0 0
8 4 4 0 0 0 0 0 0
``` | 1,144 |
<|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,230 | [
"<note1>\n<description>Focus on the non-background color: identify which color is being transformed and treat it as a single object (a collection of connected pixels) rather than many separate items. This reduces the problem to moving or repositioning one coherent shape.</description>\n<example>Imagine a 7×7 grid w... | [{"input": [[0, 0, 0, 0, 0], [0, 6, 6, 0, 0], [0, 6, 6, 0, 0], [0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0], [0, 0, 6, 6, 0], [0, 0, 6, 6, 0], [0, 0, 0, 0, 0]]}, {"input": [[0, 0, 0, 0], [0, 0, 0, 0], [0, 4, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], "output": [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 4, 0], [0, 0, 0, 0], [0, 0, 0,... | [{"input": [[0, 0, 0, 0], [0, 4, 0, 0], [0, 4, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], "output": [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 4, 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 0 0 0
0 0 4 0
0 0 4 0
0 0 0 0
``` | 526 |
<|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,976 | [
"<note1>\n<description>Locate the object by finding the connected component of the non-background color (usually the largest contiguous region). This isolates the shape you must operate on, ignoring scattered or background pixels.</description>\n<example>Imagine a grid with a single 4×4 colored patch and many isola... | [{"input": [[0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 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, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 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,... | [{"input": [[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, 0], [0, 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... | ```
6 0 6
6 0 6
6 6 6
``` | 2,272 |
<|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,260 | [
"<note1>\n<description>Compare dimensions first: if the output's width equals the input's height and its height equals the input's width, the transformation is a 90° rotation (transpose + row reversal or transpose + column reversal). This tells you to treat rows and columns as partners rather than independent objec... | [{"input": [[0, 9, 0, 9, 0], [2, 2, 9, 2, 2], [0, 2, 4, 2, 0], [8, 4, 4, 4, 8]], "output": [[8, 0, 2, 0], [4, 2, 2, 9], [4, 4, 9, 0], [4, 2, 2, 9], [8, 0, 2, 0]]}, {"input": [[8, 1, 1, 8], [4, 6, 6, 4], [6, 6, 6, 6], [3, 3, 3, 3], [3, 3, 3, 3]], "output": [[3, 3, 6, 4, 8], [3, 3, 6, 6, 1], [3, 3, 6, 6, 1], [3, 3, 6, 4,... | [{"input": [[3, 2, 2], [8, 7, 7], [0, 3, 2], [8, 3, 0], [0, 3, 0]], "output": [[0, 0, 2, 7, 2], [3, 3, 3, 7, 2], [0, 8, 0, 8, 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 2 7 2
3 3 3 7 2
0 8 0 8 3
``` | 556 |
<|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>Look for a small set of non-background pixels that act as seeds: these seeds are the only colors that reappear in the output and are used to decide every cell. In many ARC tasks the entire output is built from a few scattered colored pixels rather than from the whole input pattern.</descripti... | [{"input": [[0, 0, 0, 0, 0, 5, 6, 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, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 6, 0, 9, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [3, 0, 3, 7, 0, 0, 4, 0, 0, 8, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6]], "ou... | [{"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": [[9, 5, 5, 5, 6, 6, 6, 5, 6], [9, 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 5 5 5 6 6 6 5 6
9 5 0 0 6 6 6 0 6
9 5 0 0 6 6 6 0 6
9 9 9 9 6 6 6 9 6
5 5 5 5 6 6 6 5 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
``` | 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... | 2,554 | [
"<note1>\n<description>Look first at the global scaling: the output grid size is a consistent integer multiple of the input. If the output dimensions are exact integer multiples of the input dimensions, the transformation is likely a uniform scaling (each input cell becomes a small block in the output).</descriptio... | [{"input": [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 8, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]], "output": [[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], [8, 8, 8, 8, 1, 1, 1, 1], [8, 8, 8, 8, 1, 1, 1, 1], [8, 8, 8, 8, 1, 1, 1, 1], [8, 8, 8, 8, 1, 1, 1, 1], [1, ... | [{"input": [[6, 6, 6, 6, 6, 6], [6, 6, 6, 8, 6, 6], [6, 6, 6, 6, 6, 6], [6, 6, 6, 3, 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]], "output": [[6, 6, 6, 6, 8, 8, 8, 8, 6, 6, 6, 6], [6, 6, 6, 6, 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... | ```
6 6 6 6 8 8 8 8 6 6 6 6
6 6 6 6 8 8 8 8 6 6 6 6
6 6 6 6 8 8 8 8 6 6 6 6
6 6 6 6 8 8 8 8 6 6 6 6
6 6 6 6 3 3 3 3 6 6 6 6
6 6 6 6 3 3 3 3 6 6 6 6
6 6 6 6 3 3 3 3 6 6 6 6
6 6 6 6 3 3 3 3 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 ... | 1,850 |
<|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 single color that appears as many separate islands as there are distinct colored objects in the input. That color is often the marker used to label each object; finding it is the first key observation.</description>\n<example>Imagine a grid with four colored blobs and a color that ... | [{"input": [[6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 5, 5, 0], [8, 8, 8, 0, 0, 9, 9, 9, 0, 0, 4, 4, 4, 4, 5, 5, 0], [0, 8, 8, 0, 0, 9, 9, 9, 0, 0, 4, 4, 4, 4, 5, 5, 5], [8, 8, 8, 0, 0, 0, 0, 3, 3, 3, 0, 0, 6, 6, 0, 0, 0], [0, 0, 3, 3, 3, 3, 0, 3, 3, 3, 0, 0, 6, 6, ... | [{"input": [[9, 5, 5, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0], [0, 5, 5, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0], [0, 5, 5, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 9, 9, 0, 1, 1, 1, 1, 0, 0, 0, 0], [0, 0, 0, 9, 9, 0, 0, 0, 0, 0, 6, 6, 6, 6], [0, 5, 0, 9, 9, 0, 0, 0, 0, 0, 6, 6, 6, 6], [5, 5, 0, 9, 9, 0, 0, 0, 3, 0, 0, 6, 6, 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... | ```
9 9 5 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
9 9 5 0 0 0 0 0 0 0 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 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 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... | 2,322 | [
"<note1>\n<description>Look for a single color that appears as a contiguous vertical line or a narrow column in the input; that column is the element being propagated. When one column stands out from the uniform background, treat it as the object to be copied rather than the background.</description>\n<example>Imag... | [{"input": [[8, 8, 8, 8, 8, 4, 9, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 5, 5, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 4, 9, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 5, 5, 8, 8, 8, 8, 8, 8, 8, 8]], "output": [[8, 8, 8, 8, 8, 4, 9, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 5, 5, 8, 8, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8... | [{"input": [[0, 0, 0, 0, 0, 2, 8, 0, 6, 7, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 2, 8, 0, 6, 7, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 2, 8, 0, 6, 7, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 2, 8, 0, 6, 7, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 2, 8, 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 2 8 0 6 7 3 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 2 8 0 6 7 3 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 2 8 0 6 7 3 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 2 8 0 6 7 3 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 2 8 0 6 7 3 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 2 8 0 6 7 3 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 2 8 0 6 7 3 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 ... | 1,618 |
<|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 for a single color that forms a large contiguous block; that block is usually the background or canvas you should preserve. The transformation typically keeps this dominant region intact and only modifies a smaller set of pixels around it.</description>\n<example>Imagine a 6×6 grid where... | [{"input": [[4, 4, 4, 4, 4, 9, 9, 9, 9, 9], [4, 4, 4, 4, 4, 9, 9, 9, 9, 9], [4, 4, 7, 4, 4, 9, 9, 9, 9, 9], [4, 4, 4, 4, 4, 9, 9, 9, 9, 9], [4, 4, 7, 4, 4, 9, 9, 9, 9, 9], [4, 7, 4, 4, 4, 9, 9, 9, 9, 9], [4, 4, 4, 7, 4, 9, 9, 9, 9, 9], [4, 4, 7, 4, 4, 9, 9, 9, 9, 9], [4, 4, 4, 4, 4, 9, 9, 9, 9, 9], [7, 4, 7, 4, 4, 9, 9... | [{"input": [[9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 7, 9], [9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9], [7, 9, 9, 9, 9, 9], [9, 9, 9, 7, 9, 9], [9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9], [9, 9, 9, 7, 9, 9], [9, 9, 9, 9, 9, 7], [7, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9], [7, 9, 7, 9, 9, 9], [9, 9, 9, 9, 9, 9], [8, 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 7 7 7 2 7
7 7 7 7 7 7
7 7 7 7 7 7
2 7 7 7 7 7
7 7 7 2 7 7
7 7 7 7 7 7
7 7 7 7 7 7
7 7 7 2 7 7
7 7 7 7 7 2
2 7 7 7 7 7
7 7 7 7 7 7
2 7 2 7 7 7
7 7 7 7 7 7
``` | 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... | 3,534 | [
"<note1>\n<description>Look for the \"marker\" color that is transformed in the outputs: it is the color that appears as a compact object (a filled square or a small block) in the input and is replaced by a single new color in the output. Identifying that color is the first step because the transformation is applie... | [{"input": [[0, 6, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0], [0, 6, 6, 6, 6, 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, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 4, 4, 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, 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, 0, 0, 5, 5, 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, 9, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 9, 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 1 1 1 0 0
0 0 0 0 0 0 0 0 0 1 1 1 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 0 0 0 0 0
0 0 0 0 0 9 1 9 9 0 0 0 0 0
0 0 0 0 0 0 1 0 9 0 0 0 0 0
0 0 0 0 0 0 1 0 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 0 0 0 0 0 0 0 0 0
0 1 1 0 0 0 0 0 0 0 0 0 0 0
1 1 1 1 ... | 2,830 |
<|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 dominant color that covers the largest area of the grid; this color usually forms the background and is not the target. Identifying the background reduces the problem to finding the smaller, contrasting object(s) that stand out against it.</description>\n<example>Imagine a grid t... | [{"input": [[8, 2, 2, 8, 2, 8, 2, 8, 2, 8, 2, 8, 8, 8, 8], [2, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 8, 2, 8], [8, 2, 2, 8, 8, 2, 2, 2, 2, 8, 2, 2, 2, 8, 8], [8, 2, 2, 2, 8, 8, 8, 8, 2, 8, 2, 8, 8, 2, 2], [2, 8, 8, 2, 2, 2, 2, 2, 2, 8, 2, 8, 2, 8, 8], [2, 2, 2, 2, 8, 2, 8, 2, 8, 2, 8, 2, 8, 2, 2], [2, 8, 2, 2, 2, 8, 8, 2, 2... | [{"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, 2, 2, 2, 2, 2], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 7, 9, 7, 2], [7, 7, 2, 2, 2, 2, 2, 2, 2, 7, 2, 7, 7, 7, 2], [7, 7, 2, 9, 7, 7, 9, 7, 2, 7, 2, 2, 2, 2, 2], [7, 7, 2, 7, 7, 7, 9, 9, 2, 7, 7, 7, 7, 7, 7], [7, 7, 2, 7, 7, 7, 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... | ```
9 9 9 9 9 9 9
9 9 7 7 9 7 9
9 7 7 7 9 9 9
9 7 7 7 7 7 9
9 7 7 9 7 7 9
9 9 9 9 9 9 9
``` | 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... | 1,836 | [
"<note1>\n<description>Look for a single color that appears as a vertical stack in the input (same column, different rows). That color is the anchor: its column and the spacing between its pixels determine the global alignment of the whole output.</description>\n<example>Imagine a small grid where blue pixels appea... | [{"input": [[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, 9], [0, 0, 7, 0, 0, 0, 0, 0], [0, 6, 0, 7, 0, 0, 0, 0], [0, 0, 0, 0, 7, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 9, 0, 0, 0], [0, 0, 0, 0, 0, 9, 0, 0], [7, 0, 0, 0, 0, 0, 9, 0], [0, 7, 0, ... | [{"input": [[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, 9, 0, 0, 0], [0, 0, 0, 0, 6, 0, 0, 0, 0], [0, 0, 0, 0, 0, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0, 6, 0, 0], [0, 0, 0, 0, 9, 0, 0, 0, 0]], "output": [[0, 9, 0, 0, 0, 6, 0, 0, 0], [6, 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 9 0 0 0 6 0 0 0
6 0 9 0 0 0 6 0 0
0 6 0 9 0 0 0 6 0
0 0 6 0 9 0 0 0 6
9 0 0 6 0 9 0 0 0
0 9 0 0 6 0 9 0 0
0 0 9 0 0 6 0 9 0
0 0 0 9 0 0 6 0 9
0 0 0 0 9 0 0 6 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... | 4,010 | [
"<note1>\n<description>Find the seeds: identify the small set of pixels that are not the dominant background color. These isolated pixels are the only elements that drive the transformation; everything else is treated as background.</description>\n<example>Imagine a mostly-gray grid with a single red pixel and a si... | [{"input": [[7, 4, 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, 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, 1, 7, 7, 4, 7, 7... | [{"input": [[3, 3, 3, 0, 3, 3, 3, 3, 3, 3, 3, 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, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 7, 3, 3, 3, 3, 3, 3, 3, 0]], "output": [[3, 3, 7, 0, 7, 5, 3, 5, 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 7 0 7 5 3 5 3 5 0 7
3 3 7 7 7 3 3 3 3 3 0 0
3 3 3 5 3 3 3 3 3 3 3 5
3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 5 3 3 3 3 3 3 3 5
3 3 0 0 0 3 3 3 3 3 7 7
3 3 0 7 0 5 3 5 3 5 7 0
``` | 3,306 |
<|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,972 | [
"<note1>\n<description>Look for a single color that occupies almost every cell and one or a few pixels of a different color; those rare pixels are usually preserved and act as anchors for the transformation. This is effective because the transformation typically treats the dominant color uniformly while leaving rar... | [{"input": [[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, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 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": [[4, 0, 4, 0, 4, 0, 4, 0, 4], [4, 0, 4, 0, 4, 0, 4, 0, 4], [0, 0, 0, 0, 5, 0, 0, 0, 0], [0, 0,... | [{"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, 2, 2, 2, 2, 5, 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, 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, 2, 2, 2, 2], [2, 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 4 2 4 2 4 2 4 2 4 2
2 4 2 4 2 4 2 4 2 4 2
2 4 2 4 2 4 2 4 2 4 2
2 2 2 2 2 2 2 5 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 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 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 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 2 2 2 2 2
2 2 2 2 ... | 3,268 |
<|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,912 | [
"<note1>\n<description>Look for a single row and a single column made entirely of the same color — these act as separators that partition the grid into a 3×3 arrangement of rectangular blocks. When such full rows/columns exist they are usually the key to the transformation because they define the natural tiles to i... | [{"input": [[7, 7, 6, 9, 6, 4, 5, 9, 3, 9, 7, 4, 6, 6, 8, 6, 9, 9, 9], [1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 9, 9, 9, 9, 9, 9, 9, 9, 4], [4, 1, 1, 1, 1, 1, 1, 7, 3, 4, 9, 9, 9, 9, 9, 9, 9, 9, 3], [6, 1, 1, 1, 1, 1, 1, 1, 3, 5, 9, 9, 9, 9, 9, 9, 9, 9, 4], [3, 1, 1, 1, 1, 1, 1, 7, 3, 8, 9, 9, 9, 9, 9, 9, 9, 9, 8], [4, 1, 1, 1, ... | [{"input": [[4, 9, 8, 5, 4, 7, 7, 7, 8, 7, 1, 6, 4, 2, 2, 9, 9, 3, 7], [7, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 4, 4, 4, 4, 4, 4, 4, 5], [4, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 2, 4, 4, 4, 4, 4, 4, 7], [1, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 7, 4, 4, 4, 4, 4, 4, 8], [3, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 4, 4, 4, 4, 4, 4, 4, 8], [2, 2, 2, 2, ... | 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 1 4
1 1 1
0 1 8
``` | 3,208 |
<|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,533 | [
"<note1>\n<description>Isolate objects by grouping non-background pixels that touch orthogonally. Treat each connected component as a single object even if it has several pixels; this reduces the problem to comparing a small set of objects.</description>\n<example>Imagine a grid with two separated L-shaped blobs an... | [{"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, 8, 0, 0, 0, 0, 0, 0, 0], [0, 0, 8, 0, 0, 0, 6, 0, 0, 0], [0, 0, 8, 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, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 5, 0, 0, 0, 0, 1, 1, 1], [0, 5, 5, 0, 0, 0, 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, 9, 9, 0, 0, 0], [8, 0, 0, 0, 0, 0, 0, 0, 0, 0], [8, 0, 0, 2, 2, 0, 0, 0, 0, 0], [8, 0, 0, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 2, 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... | ```
5 2 1
5 2 1
5 2 1
5 2 1
``` | 1,829 |
<|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,750 | [
"<note1>\n<description>Start by locating the single contiguous colored region (the object) and compute its bounding box: the smallest rectangle that contains every non-background pixel. This gives you the object's height, width, and exact pixel coordinates, which are the essential parameters for any translation or ... | [{"input": [[0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 0], [0, 0, 6, 6, 6, 6, 0], [0, 0, 6, 6, 6, 6, 0], [0, 0, 6, 6, 6, 6, 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, 0, 6, 6, 6, 6], [0, 0, 0, 6, 6, 6, 6], [0, 0, 0, 6, 6, 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, 6, 6], [0, 0, 0, 0, 6, 6], [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, 0], [0, 0, 0, 0, 6, 6], [0, 0, 0, 0, 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... | ```
0 0 0 0 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 6 6
``` | 1,046 |
<|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,716 | [
"<note1>\n<description>Look for a single, contiguous object that stands out from the background. When one non-background color forms a compact rectangular region, treat that region as the candidate for the transformation.</description>\n<example>Imagine a grid with a single blue rectangle on a black background. Tha... | [{"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, 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, 3, 3, 3, 3, 0, 0, 0, 0, 0], [0, 0, 0, 0, 3, 2, 2, 3, 0, 0, 0, 0, 0], [0, 0, 0, 0, 3, 2, 2, 3, 0, 0, 0, 0, 0], [0, 0, 0, 0, 3, 3, 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 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 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 0 0 0 0 0
0 0 0 0 3 3 2 3 0 0 0 0 0
0 0 0 0 3 2 2 3 0 0 0 0 0
0 0 0 0 3 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 ... | 4,012 |
<|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>Look for the contiguous rectangular area that contains all zeros; that area is the region you must replace. Isolating that rectangle gives you the exact subgrid to analyze and the output size. Treat the zeros as a mask to be filled, not as part of the final pattern.</description>\n<example>Im... | [{"input": [[3, 5, 3, 5, 3, 5, 5, 5, 6, 3, 5, 3, 5, 3, 5, 5, 5, 6, 3, 5], [6, 6, 5, 3, 3, 5, 6, 6, 3, 6, 6, 5, 3, 3, 5, 6, 6, 3, 6, 6], [3, 3, 5, 3, 5, 6, 6, 6, 6, 3, 3, 5, 3, 5, 6, 6, 6, 6, 3, 3], [5, 3, 6, 3, 5, 5, 3, 3, 3, 5, 3, 6, 3, 5, 5, 3, 3, 3, 5, 3], [3, 3, 5, 3, 5, 3, 3, 3, 5, 3, 3, 5, 3, 5, 3, 3, 3, 5, 3, 3]... | [{"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, 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
5 5
5 5
5 5
5 5
5 5
5 5
``` | 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... | 1,328 | [
"<note1>\n<description>Look for a single horizontal “anchor” row in the input that is preserved in the output (often the topmost or bottommost row). That row usually stays exactly as it is and serves as a reference for all other moves. Identifying which row is fixed reduces the problem to rearranging the other rows... | [{"input": [[0, 0, 0, 0, 0, 9], [0, 0, 0, 8, 0, 0], [0, 0, 0, 0, 0, 0], [4, 0, 0, 0, 0, 0], [4, 0, 7, 8, 0, 0], [4, 0, 7, 0, 0, 0]], "output": [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [4, 0, 0, 0, 0, 0], [4, 0, 7, 8, 0, 0], [4, 0, 7, 8, 0, 9]]}, {"input": [[0, 4, 0, 9], [0, 0, 0, 0], [0, 4, 6, 0], [... | [{"input": [[0, 2, 0, 4, 3], [5, 0, 0, 0, 0], [0, 0, 6, 0, 0], [5, 2, 0, 4, 0], [5, 0, 0, 0, 0]], "output": [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [5, 0, 0, 0, 0], [5, 2, 0, 4, 0], [5, 2, 6, 4, 3]]}] | 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
5 0 0 0 0
5 2 0 4 0
5 2 6 4 3
``` | 624 |
<|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,924 | [
"<note1>\n<description>Locate the object by finding the minimal bounding rectangle that contains all non-background pixels. This isolates the pattern you must replicate and makes it easy to reason about its size and placement.</description>\n<example>Imagine a 3×3 block of colored pixels on a black background. Draw... | [{"input": [[0, 3, 3, 3, 0, 0, 0, 0, 0, 0], [0, 3, 3, 3, 0, 0, 0, 0, 0, 0], [0, 3, 0, 3, 0, 0, 0, 0, 0, 0], [0, 1, 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... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 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, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 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], [1, 1,... | 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
1 1 1 0 0 0 1 1 1
1 1 1 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 0 0 0 0 0 0
1 1 1 0 0 0 1 1 1
1 1 1 0 0 0 1 1 1
0 0 0 0 0 0 0 0 0
``` | 1,220 |
<|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,438 | [
"<note1>\n<description>Start by comparing the two grids at the pixel level: check whether entire rows or entire columns are identical in input and output. If whole rows (or columns) match exactly, the transformation is likely a global relabeling rather than a geometric rearrangement.</description>\n<example>Imagine... | [{"input": [[8, 9, 2, 2, 8, 6, 2, 7, 7, 8, 7, 8, 9, 7, 5, 2, 8, 5, 8, 9, 7, 5, 9], [5, 2, 6, 5, 9, 2, 6, 7, 6, 8, 2, 5, 8, 9, 5, 7, 5, 5, 8, 7, 8, 6, 2], [6, 5, 2, 7, 5, 9, 6, 9, 9, 6, 5, 9, 7, 6, 8, 7, 6, 9, 2, 7, 2, 5, 5], [5, 8, 2, 6, 6, 2, 5, 7, 2, 9, 6, 5, 5, 2, 2, 8, 8, 7, 6, 6, 2, 7, 9], [8, 7, 5, 5, 7, 2, 5, 2,... | [{"input": [[8, 3, 5, 5, 8, 5, 9, 4, 5, 5, 1, 1, 9, 7, 9, 4, 1, 8, 0], [4, 7, 5, 5, 5, 5, 3, 5, 5, 8, 3, 5, 8, 1, 5, 0, 1, 8, 2], [5, 5, 5, 4, 3, 1, 8, 7, 5, 5, 2, 2, 1, 9, 9, 3, 5, 1, 0], [8, 5, 3, 0, 0, 5, 9, 3, 1, 1, 4, 7, 5, 5, 5, 8, 5, 5, 5], [8, 2, 5, 5, 5, 4, 5, 9, 8, 1, 1, 9, 5, 3, 5, 5, 2, 7, 5], [5, 8, 9, 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 3 8 8 5 8 9 4 8 8 1 1 9 7 9 4 1 5 0
4 7 8 8 8 8 3 8 8 5 3 8 5 1 8 0 1 5 2
8 8 8 4 3 1 5 7 8 8 2 2 1 9 9 3 8 1 0
5 8 3 0 0 8 9 3 1 1 4 7 8 8 8 5 8 8 8
5 2 8 8 8 4 8 9 5 1 1 9 8 3 8 8 2 7 8
8 5 9 3 8 7 9 3 7 8 7 3 7 5 7 5 9 9 8
2 8 8 3 5 3 7 4 9 2 9 9 4 8 7 8 8 8 0
8 5 0 8 4 7 3 9 0 7 0 8 7 8 3 8 3 1 3
8 0 7 4 5 7 ... | 3,734 |
<|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 compact, contiguous non-background objects and compute each one's bounding box and a compact descriptor (e.g., the most frequent color and a small set of corner/edge pixels). This separates objects from noise and gives a stable representation to compare across examples.</description>... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 4, 4, 4, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 0, 9, 4, 4], [0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 0, 4, 4, 4], [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, 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, 3, 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], [0, 3, 2, 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 3 2 3 0 0 0 0 0 0
0 0 0 0 0 2 3 3 0 0 0 0 0 0
0 0 0 0 0 0 3 3 5 0 0 0 0 0
0 0 0 0 0 0 5 5 5 0 0 0 0 0
0 0 0 0 0 0 5 5 5 0 0 0 0 0
0 0 5 5 5 5 5 5 5 0 0 0 2 3
3 3 3 5 5 5 0 0 5 5 5 3 3 2
2 3 3 5 5 5 0 0 5 5 5 3 3 3
3 2 0 0 0 5 5 5 5 5 5 5 0 0
0 0 0 0 0 5 5 5 0 0 0 0 0 0
0 0 0 0 0 5 5 5 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... | 3,996 | [
"<note1>\n<description>Identify the background and the object color by frequency: the background is usually the single color filling most cells, while the object(s) are the minority color(s). This distinction tells you which pixels are candidates for change and which should be left alone. Treat the object color as ... | [{"input": [[9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 0, 9, 0, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 0, 0, 0, 0, 0, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 0, 0, 0, 9, 0, 0, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 0, 9, 9, 0, 0, 9, 9], [9, 0, 9, 9, 9, 9, 9, 9, 9... | [{"input": [[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, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [0, 0, 0, 0, 0, 9, 9, 9, 9, 9, 9, 9, 9, 0, 9], [0, 0, 0, 0, 0, 0, 9, 9, 9... | 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 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 9 9 9 9 9 9 9 9 9 9 9 9 9 9
9 9 2 9 9 9 9 9 9 9 9 9 9 9 9
2 2 2 2 2 9 9 9 9 9 9 9 9 9 9
2 2 2 2 2 9 9 9 9 9 9 9 9 2 9
2 2 2 2 2 2 9 9 9 9 9 9 2 2 2
2 2 2 2 2 9 9 9 9 9 9 9 9 2 9
2 2 2 2 2 9 9 9 9 9 9 9 9 2 9
9 9 2 9 9 9 9 9 9 9 9 9 9 2 9
9 9 9 9 2 2 2 9 ... | 3,292 |
<|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,316 | [
"<note1>\n<description>Find the minority color(s) that form the repeating motif: these are the pixels that appear less often and create the alternating pattern. Focusing on that color isolates the structure you need to analyze.</description>\n<example>Imagine a grid of mostly color A with a few B pixels scattered. ... | [{"input": [[4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 4, 1, 4, 1, 4, 4], [4, 4, 4, 4, 4, 4, 4, 1, 4, 1, 4, 1, 4, 4, 4, 4, 4, 4], [4, 4, 1, 4, 1, 4, 1, 4, 1, 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, 4, 4, 4, 4, 4, 4, 4, 4, ... | [{"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, 0, 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 0, 3, 0, 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,... | 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 3 3 3 3 3 3 3 3
3 3 3 0 2 0 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 3 0 2 0 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,612 |
<|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,836 | [
"<note1>\n<description>Look for full rows or full columns that are a single color; these are deliberate separators that split the grid into independent blocks. Treat each rectangular region between two adjacent separators as a single tile to be analyzed independently. This reduces the problem to a small set of comp... | [{"input": [[8, 8, 8, 8, 8, 1, 8, 8, 8, 8, 8, 1, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 1, 8, 0, 0, 0, 8, 1, 8, 0, 0, 8, 8], [8, 8, 8, 8, 8, 1, 8, 0, 0, 0, 8, 1, 8, 0, 0, 0, 8], [8, 0, 0, 0, 8, 1, 8, 0, 0, 0, 8, 1, 8, 0, 0, 0, 8], [8, 8, 8, 8, 8, 1, 8, 0, 8, 0, 8, 1, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 1, 8, 8, 8, 8, 8, 1, 8, 8, ... | [{"input": [[7, 7, 7, 7, 7], [7, 7, 5, 5, 7], [7, 5, 5, 7, 7], [7, 7, 7, 7, 7], [7, 7, 7, 7, 7], [2, 2, 2, 2, 2], [7, 7, 7, 7, 7], [7, 5, 5, 5, 7], [7, 5, 5, 7, 7], [7, 7, 7, 7, 7], [7, 7, 7, 7, 7], [2, 2, 2, 2, 2], [7, 7, 7, 7, 7], [7, 5, 5, 5, 7], [7, 5, 5, 7, 7], [7, 7, 7, 7, 7], [7, 7, 7, 7, 7]], "output": [[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 2 5 5 7
7 5 5 7 7
7 7 7 7 7
7 7 7 7 7
2 2 2 2 2
7 7 7 7 7
7 5 5 5 7
7 5 5 7 7
7 7 7 7 7
7 7 7 7 7
2 2 2 2 2
7 7 7 7 7
7 5 5 5 7
7 5 5 7 7
7 7 7 7 7
7 7 7 7 7
``` | 3,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,934 | [
"<note1>\n<description>Check the overall dimensions first: if the output's height equals the input's width and the output's width equals the input's height, the transformation is a 90° rotation (either clockwise or counterclockwise). This is the quickest way to rule out other operations like reflection or scaling.<... | [{"input": [[7, 7, 1, 7, 7, 1, 7, 1, 7, 1, 7, 7, 7], [1, 7, 1, 1, 1, 1, 7, 1, 7, 7, 7, 1, 7], [7, 7, 7, 1, 7, 7, 7, 7, 1, 1, 7, 1, 1], [7, 7, 7, 1, 7, 7, 7, 7, 7, 7, 7, 1, 7], [7, 7, 1, 1, 1, 1, 7, 7, 1, 7, 7, 7, 7], [7, 1, 7, 7, 1, 7, 7, 7, 1, 7, 1, 7, 1], [1, 7, 1, 1, 1, 1, 7, 7, 1, 1, 1, 1, 7], [1, 7, 7, 1, 7, 7, 7,... | [{"input": [[4, 4, 3, 7, 3, 4, 4, 4, 4, 4, 4, 4, 3, 4, 3, 8, 0, 7, 0, 3, 4, 3, 3, 4, 4, 4, 3, 3], [0, 4, 0, 8, 4, 4, 3, 4, 7, 4, 4, 4, 3, 3, 3, 4, 3, 4, 4, 4, 4, 3, 4, 4, 4, 4, 0, 4], [4, 7, 4, 7, 3, 3, 4, 3, 4, 7, 0, 4, 4, 4, 4, 4, 4, 7, 7, 4, 4, 7, 4, 4, 4, 4, 3, 4], [7, 4, 3, 4, 7, 4, 3, 4, 4, 4, 4, 3, 4, 0, 4, 4, 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... | ```
4 0 4 7 4 4 3 4 4 4
4 4 7 4 4 4 4 3 0 7
3 0 4 3 4 4 4 3 3 4
7 8 7 4 3 4 4 3 7 4
3 4 3 7 4 0 3 4 4 7
4 4 3 4 3 4 7 4 4 4
4 3 4 3 4 4 4 3 4 7
4 4 3 4 4 4 3 4 3 0
4 7 4 4 4 7 3 4 7 4
4 4 7 4 4 7 4 3 7 4
4 4 0 4 4 3 4 4 0 7
4 4 4 3 7 4 3 4 7 7
3 3 4 4 4 4 8 4 4 4
4 3 4 0 4 7 3 7 4 3
3 3 4 4 7 7 3 4 7 4
8 4 4 4 3 4 7 4 ... | 2,230 |
<|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>First check whether the transformation is a global relabeling: every occurrence of a given color in the input becomes the same new color in the output. If so, you can treat the problem as a one-to-one substitution between color sets rather than as a shape or position change.</description>\n<e... | [{"input": [[7, 8, 6, 6, 9, 9, 9, 4], [4, 8, 6, 6, 6, 7, 9, 4], [0, 0, 7, 3, 7, 5, 5, 4], [0, 0, 0, 3, 4, 4, 5, 3], [0, 0, 0, 0, 0, 4, 4, 2], [0, 0, 0, 0, 0, 4, 4, 2], [0, 0, 0, 3, 4, 4, 5, 3], [0, 0, 7, 3, 7, 5, 5, 4], [4, 8, 6, 6, 6, 7, 9, 4], [7, 8, 6, 6, 9, 9, 9, 4]], "output": [[1, 8, 8, 8, 5, 5, 9, 8], [1, 8, 8, ... | [{"input": [[0, 0, 0, 1, 8, 0, 0, 0, 0], [0, 0, 5, 8, 8, 0, 0, 0, 0], [0, 0, 0, 1, 1, 3, 0, 5, 0], [0, 0, 3, 1, 4, 1, 1, 8, 1], [8, 8, 1, 4, 2, 4, 1, 8, 8], [1, 8, 1, 1, 4, 1, 3, 0, 0], [0, 5, 0, 3, 1, 1, 0, 0, 0], [0, 0, 0, 0, 8, 8, 5, 0, 0], [0, 0, 0, 0, 8, 1, 0, 0, 0]], "output": [[0, 0, 0, 0, 9, 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 9 4 0 0 0
0 0 0 0 9 9 6 0 0
0 6 0 2 4 4 0 0 0
4 9 4 4 1 4 2 0 0
9 9 4 1 3 1 4 9 9
0 0 2 4 1 4 4 9 4
0 0 0 4 4 2 0 6 0
0 0 6 9 9 0 0 0 0
0 0 0 4 9 0 0 0 0
``` | 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... | 1,260 | [
"<note1>\n<description>First isolate the target color: find the color that appears as a contiguous band along the top row and (in the examples) as a single vertical column in the bottom row. Treat that color as the one being replaced or \"propagated\" by the transformation.</description>\n<example>Imagine a 4×5 gri... | [{"input": [[7, 6, 6, 6, 7], [5, 1, 1, 1, 5], [1, 1, 1, 1, 1], [1, 5, 1, 5, 1]], "output": [[6, 6, 6, 6, 6], [5, 1, 1, 1, 5], [1, 1, 1, 1, 1], [1, 5, 1, 5, 1]]}, {"input": [[2, 2, 2, 2], [7, 7, 7, 7], [3, 7, 7, 3], [3, 8, 8, 3], [7, 4, 4, 7]], "output": [[2, 2, 2, 2], [6, 6, 6, 6], [2, 6, 6, 2], [2, 8, 8, 2], [6, 1, 1,... | [{"input": [[3, 2, 3], [8, 7, 8], [4, 3, 4], [4, 7, 4], [4, 1, 4]], "output": [[2, 2, 2], [8, 6, 8], [1, 2, 1], [1, 6, 1], [1, 1, 1]]}] | 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
8 6 8
1 2 1
1 6 1
1 1 1
``` | 556 |
<|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,040 | [
"<note1>\n<description>Find the anchor object: one color forms a compact, multi-row block (the \"1\" object). Treat that connected component as the fixed reference for the transformation rather than individual isolated pixels.</description>\n<example>Imagine a grid where a contiguous 3×3 block of color 1 sits in th... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 0, 0, 0, 0, 0], [0, 0, 4, 0, 0, 0, 0, 0], [0, 0, 4, 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, ... | [{"input": [[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, 4, 0, 0, 0, 1, 1, 1, 0], [0, 4, 0, 0, 0, 0, 0, 1, 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, 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 4 0 0 0 0 0 0 0
0 4 1 1 1 0 0 0 0
0 4 0 0 1 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 0
0 0 0 0 0 0 0 0 0
``` | 1,336 |
<|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 color that appears in the output only as a continuous straight line. That color is the “marker” used in the transformation and is the one you should track across the grid.</description>\n<example>Imagine an input with several colored squares and an output that shows only b... | [{"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, 3, 3, 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, 0, 0, 0, 0, 0, 8, 8, 8, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 8, 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, 5, 5, 5, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 5, 5, 5, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 9, 9, 9, 0], [0, 0, 0, 0, 1, 6, 6, 6, 0, 0, 9, 9, 9, 0], [0, 0, 0, 0, 1, 9, 9, 6, 0, 0, 9, 9, 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 9 0 0 0 0 9 0 0
0 0 0 0 0 0 0 9 0 0 0 9 0 0
0 0 0 0 0 0 0 0 9 0 0 9 0 0
0 0 0 0 0 0 0 0 0 9 0 9 0 9
0 0 0 0 0 0 0 0 0 0 9 9 9 0
9 9 9 9 9 9 9 9 9 9 9 9 9 9
0 0 0 0 0 0 0 0 0 0 9 9 9 0
0 0 0 0 0 0 0 0 0 9 0 9 0 9
0 0 0 0 0 0 0 0 9 0 0 9 0 0
0 0 0 0 0 0 0 9 0 0 0 9 0 0
0 0 0 0 0 0 9 0 0 0 0 9 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... | 3,734 | [
"<note1>\n<description>Focus first on connectivity and shape: treat each contiguous group of non-zero cells as an object (a connected component). If two objects touch orthogonally (up/down/left/right) they form one object; diagonals do not. This separation is what the transformation acts on, not isolated pixels.</d... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0], [0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0], [0, 8, 8, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 0, 0, 0, 0], [0, 8, 8, 0, 0, 4, 4, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0], [0, 8, 8, 0, 0, 0, 8, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 8, 8, 0, 0, 0, 0, 0, 0, ... | [{"input": [[8, 2, 5, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0], [8, 2, 5, 0, 0, 8, 8, 8, 0, 2, 8, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 8, 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, 8, 8, 0, 0], [0, 0, 8, 8, 0, 5, 0, 5, 0, 0, 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... | ```
6 4 8 0 0 6 0 0 0 0 0 0 0 0
6 4 8 0 0 6 6 6 0 4 6 0 0 0
0 0 0 0 0 0 0 0 0 4 5 0 0 0
0 0 0 0 0 0 0 0 0 4 6 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 0 0 6 6 0 0
0 0 6 6 0 8 0 8 0 0 6 6 0 0
0 0 6 6 0 6 6 6 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 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 ... | 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,914 | [
"<note1>\n<description>Look for a single color that appears in a compact, contiguous region while every other color is either scattered or forms a uniform background. That compact, contiguous region is usually the object to extract and is the only thing that changes between input and output.</description>\n<example... | [{"input": [[1, 1, 3, 7, 7, 7, 7, 7, 7, 7, 7, 3, 1, 1], [1, 3, 5, 7, 7, 1, 7, 7, 1, 7, 7, 5, 3, 1], [3, 5, 7, 1, 9, 7, 3, 3, 7, 9, 1, 7, 5, 3], [7, 7, 1, 5, 7, 1, 1, 1, 1, 7, 5, 1, 7, 7], [0, 0, 0, 7, 1, 4, 7, 7, 4, 1, 7, 9, 7, 7], [0, 0, 0, 1, 4, 7, 1, 1, 7, 4, 1, 7, 1, 7], [7, 7, 3, 1, 7, 1, 5, 5, 1, 7, 1, 3, 7, 7], ... | [{"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], [8, 8, 8, 2, 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, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 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... | ```
8 8
``` | 2,210 |
<|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,154 | [
"<note1>\n<description>Look for a compact, contiguous multi-pixel object that sits on a neutral background and is not part of the grid border. Such objects are often the only places where the transformation changes the grid.</description>\n<example>Imagine a mostly uniform grid with a single 2×2 colored square some... | [{"input": [[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, 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, 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, 5, 4, 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, 5, 5], [5, 1, 8, 5, 5, 5, 7, 9, 5, 5, 5, 5], [5, 8, 8, 5, 5, 5, 9, 7, 5, 5, 5, 5], [5, 5, 5, 7, 1, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 2, 7, 5, 5, 5, 9, 2, 5, 5], [5, 5, 5, 5, 5, 5, 5, 5, 4, 9, 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, ... | 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 1 8 5 5 5 7 9 5 5 5 5
5 8 8 5 5 5 9 7 5 5 5 5
5 3 3 7 1 5 3 3 5 5 5 5
5 3 3 2 7 5 3 3 9 2 5 5
5 5 5 3 3 5 5 5 4 9 5 5
5 5 5 3 3 5 5 5 3 3 5 5
5 5 5 3 3 5 5 5 3 3 5 5
5 5 5 5 5 5 5 5 3 3 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,450 |
<|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,770 | [
"<note1>\n<description>Look for a vertical mirror: many tasks flip the left and right halves of the grid. A vertical reflection maps column j to column (width - j + 1) and preserves each cell's color. This is effective when the right side appears like a reversed version of the left.</description>\n<example>Imagine ... | [{"input": [[7, 4, 1, 2, 3, 6, 1, 5, 2, 7], [9, 1, 8, 9, 5, 9, 9, 8, 8, 9], [6, 7, 1, 7, 9, 6, 3, 3, 4, 4], [7, 4, 1, 8, 8, 6, 7, 1, 3, 2], [6, 1, 8, 2, 8, 5, 6, 5, 4, 8], [6, 7, 2, 6, 7, 4, 9, 5, 5, 7], [6, 7, 7, 9, 9, 8, 8, 8, 2, 4]], "output": [[7, 4, 1, 2, 3, 3, 2, 1, 4, 7], [9, 1, 8, 9, 5, 5, 9, 8, 1, 9], [6, 7, 1... | [{"input": [[3, 6, 9, 6, 8, 4, 6, 8], [4, 6, 4, 2, 9, 9, 9, 2], [3, 6, 2, 6, 5, 6, 8, 7], [7, 3, 8, 9, 4, 3, 6, 6], [8, 3, 5, 8, 7, 5, 2, 1], [2, 7, 9, 3, 1, 8, 7, 7], [5, 4, 1, 5, 6, 7, 9, 3], [6, 4, 5, 6, 6, 1, 5, 9], [1, 2, 1, 9, 6, 6, 7, 9], [3, 4, 5, 2, 4, 5, 5, 8]], "output": [[3, 6, 9, 6, 6, 9, 6, 3], [4, 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... | ```
3 6 9 6 6 9 6 3
4 6 4 2 2 4 6 4
3 6 2 6 6 2 6 3
7 3 8 9 9 8 3 7
8 3 5 8 8 5 3 8
2 7 9 3 3 9 7 2
5 4 1 5 5 1 4 5
6 4 5 6 6 5 4 6
1 2 1 9 9 1 2 1
3 4 5 2 2 5 4 3
``` | 1,066 |
<|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,848 | [
"<note1>\n<description>Isolate the foreground: treat every cell that is not the background color as part of the object to be transformed. This removes irrelevant zeros and focuses on the meaningful colored pixels.</description>\n<example>Imagine a grid mostly filled with zeros but with a few colored pixels scattere... | [{"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, 8, 8, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 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, 5, 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, 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], ... | 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 9 9 5
5 0 0 5
6 0 0 5
0 0 0 0
``` | 2,144 |
<|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,234 | [
"<note1>\n<description>Find the background by frequency: the color that fills most cells is the canvas and the other color(s) form the motif to be transformed. This isolates which pixels are meaningful for the next step.</description>\n<example>If a grid is mostly color A with a small cluster of color B, treat A as... | [{"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": [[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, 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, 8, 2, 2, 8, 8], [2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 2, 8, 2, 8, 8], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 8, 8, 8, 8, 8], [2, 2, 2, 2, 2, 2, 2, 2, 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... | ```
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 8 8 2 2 2 2 8 8 8 8
2 2 2 2 8 8 2 2 2 2 8 8 8 8
2 2 8 8 2 2 8 8 2 2 8 8 8 8
2 2 8 8 2 2 8 8 2 2 8 8 8 8
2 2 2 2 8 8 8 8 8 8 8 8 8 8
2 2 2 2 8 8 8 8 8 8 8 8 8 8
8 8 8 8 8 8 8 8 2 2 2 2 2 2
8 8 8 8 8 8 8 8 2 2 2 2 2 2
2 2 8 8 8 8 2 2 2 2 2 2 2 2
2 2 8 8 ... | 3,530 |
<|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,558 | [
"<note1>\n<description>Find the unique non-background color that forms a contiguous block: this is usually the object to transform. Treat that block as a single unit (its bounding box) rather than individual pixels when reasoning about the transformation.</description>\n<example>Imagine a grid of one color with a s... | [{"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, 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, 6, 6, 6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 6, 6, 6, 6, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4], [4, 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, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 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... | ```
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 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 ... | 3,854 |
<|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>Check whether the transformation preserves geometry: if every colored pixel keeps the same coordinates and shape, then the rule is a recoloring rather than a translation, rotation, or reflection. This narrows the search to color-to-color mappings.</description>\n<example>Imagine a 3×3 grid wi... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0], [0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 2, 0], [0, 3, 2, 0, 0, 2, 0, 0, 0, 0, 7, 0], [3, 4, 3, 7, 0, 0, 0, 0, 0, 7, 0, 0], [0, 3, 4, 3, 0, 7, 0, 1, 7, 0, 0, 0], [0, 0, 0, 0, 4, 0, 0, 2, 0, 0, 0, 7], [2, 0, 1, 0, 1, 0, 3, 2, 2, 3, 0, 0], [0, 0, 0, 0, 0, 0, 0, 4, 3, 0, 0, 4]], "ou... | [{"input": [[0, 0, 1, 0, 0, 0, 0, 3, 0], [0, 0, 0, 0, 0, 0, 3, 4, 3], [0, 0, 0, 0, 0, 0, 0, 3, 2], [1, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 3, 0, 0, 0, 1, 0, 3], [0, 0, 7, 0, 7, 0, 0, 0, 1], [0, 0, 0, 2, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 0, 3, 0, 0], [0, 0, 0, 0, 0, 0, 3, 0, 0]], "output": [[0, 0, 2, 0, 0, 0, 0, 1, 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 2 0 0 0 0 1 0
0 0 0 0 0 0 1 7 1
0 0 0 0 0 0 0 1 3
2 0 0 0 0 0 0 0 0
2 0 1 0 0 0 2 0 1
0 0 4 0 4 0 0 0 2
0 0 0 3 0 0 0 7 0
0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 1 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... | 2,370 | [
"<note1>\n<description>Check for a global shift: when one color is consistently placed to the right in the output while the other color remains on the left, the transformation is likely a uniform translation (same row, new column). A simple formula is new_col = old_col + offset; the offset is constant across the gr... | [{"input": [[0, 0, 0, 0, 0, 7, 0, 0, 0, 0], [0, 0, 7, 0, 0, 0, 4, 0, 0, 0], [0, 0, 0, 4, 0, 0, 0, 7, 0, 0], [0, 0, 0, 0, 7, 0, 0, 0, 4, 0], [0, 0, 0, 0, 0, 4, 0, 0, 0, 0], [0, 0, 7, 7, 0, 0, 0, 0, 0, 0], [0, 0, 0, 4, 4, 0, 0, 0, 0, 0], [0, 0, 0, 0, 7, 7, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4, 4, 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, 7, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 4, 0, 0, 7, 0, 0, 0, 0], [0, 0, 0, 7, 0, 0, 4, 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, 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 7 0 0 0 0 0 0
0 0 1 0 0 0 0 7 0 0
0 7 0 0 0 0 1 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 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,836 | [
"<note1>\n<description>Locate the object by finding the minimal bounding rectangle that contains every non-background pixel; the object’s shape and size are defined by that rectangle. This isolates the pattern you will transform rather than being distracted by surrounding empty space.</description>\n<example>Imagin... | [{"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, 8, 9, 9, 0, 0], [0, 0, 0, 3, 6, 9, 0, 0], [0, 0, 0, 4, 3, 8, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]], "output": [[2, 2, 2, 3, 3, 3, 0, 0], [2, 2, 2, 3, 3, 3, 0, 0], [2, 2, 2, 3, 3, 3, 0, 0], [1, 1, 1, ... | [{"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, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 4, 1, 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], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[2, 2, 2, 3, 3, 3, 0, 0, 0], [2, 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... | ```
2 2 2 3 3 3 0 0 0
2 2 2 3 3 3 0 0 0
2 2 2 3 3 3 0 0 0
1 1 1 4 4 4 0 0 0
1 1 1 4 4 4 0 0 0
1 1 1 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
``` | 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... | 4,258 | [
"<note1>\n<description>Look for a color that appears as a single, compact connected component (one contiguous blob). When such a small cluster exists, it is often the anchor that drives the transformation: the rest of the grid is recolored relative to that blob.</description>\n<example>Imagine a 7×7 grid where almo... | [{"input": [[7, 0, 0, 7], [8, 8, 7, 0], [7, 7, 0, 7], [8, 7, 7, 7], [7, 8, 7, 7], [8, 7, 7, 0], [7, 7, 0, 8], [7, 7, 7, 7]], "output": [[2, 0, 0, 2], [8, 8, 2, 0], [2, 2, 0, 2], [8, 2, 2, 2], [8, 8, 2, 2], [8, 2, 2, 0], [2, 2, 0, 8], [8, 2, 0, 2]]}, {"input": [[6, 6, 6, 6, 6, 6, 6, 6, 6, 9, 6, 6, 9, 6, 6], [6, 6, 6, 6,... | [{"input": [[4, 4, 4, 4, 4, 4, 4, 4, 6, 3, 4, 4, 4, 4, 4, 4, 4, 4, 6, 4, 4, 4, 4, 6, 6, 4, 6, 4], [4, 4, 4, 4, 3, 4, 4, 4, 4, 4, 6, 6, 3, 4, 4, 4, 4, 6, 4, 4, 4, 4, 6, 4, 4, 3, 6, 3], [4, 4, 4, 4, 4, 4, 4, 6, 4, 3, 4, 4, 3, 4, 4, 4, 6, 6, 6, 4, 4, 3, 4, 4, 4, 4, 4, 4], [4, 4, 4, 6, 3, 4, 6, 6, 6, 4, 4, 4, 6, 4, 4, 4, 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... | ```
2 2 2 2 2 2 2 2 6 3 2 2 2 2 2 2 2 2 6 2 2 2 2 6 6 2 6 2
2 2 2 2 3 2 2 2 2 2 6 6 3 2 2 2 2 6 2 2 2 2 6 2 2 3 6 3
2 2 2 2 2 2 2 6 2 3 2 2 3 2 2 2 6 6 6 2 2 3 2 2 2 2 2 2
2 2 2 6 3 2 6 6 6 2 2 2 6 2 2 2 2 2 2 6 2 2 2 2 6 2 3 2
2 2 2 6 6 2 2 2 6 2 2 2 2 2 3 2 2 2 6 2 2 2 2 2 6 2 3 2
6 2 3 2 2 2 6 2 6 2 3 2 2 2 2 3 2 6 ... | 3,554 |
<|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>Find the anchors: locate every cell that is not the background color. These non-background cells are the seeds that determine the final pattern rather than the background zeros. Treat each seed independently when reasoning about what will change.</description>\n<example>Imagine a small grid w... | [{"input": [[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, 7, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[0, 0, 8, 0, 0, 0, 7, 0, 0], [0, 0,... | [{"input": [[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, 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]], "output": [[0, 7, 0, 0, 8, 0, 0, 0, 0], [8, 2,... | 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 7 0 0 8 0 0 0 0
8 2 8 8 8 8 8 8 8
0 7 0 0 8 0 0 0 0
0 7 0 0 8 0 0 0 0
0 7 0 0 8 0 0 0 0
0 7 0 0 8 0 0 0 0
7 7 7 7 2 7 7 7 7
0 7 0 0 8 0 0 0 0
0 7 0 0 8 0 0 0 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... | 3,632 | [
"<note1>\n<description>Look for a repeated block that tiles the grid. When the same small arrangement of colors repeats across rows and columns, the whole grid is often just that block repeated; finding the block reduces the problem to locating a single unit.</description>\n<example>Imagine a grid where every 3×2 p... | [{"input": [[5, 3, 9, 5, 3, 9, 5, 3, 9, 5, 3, 9, 5, 3, 9, 5, 3, 9, 5, 3, 9, 5, 3, 9], [4, 5, 3, 4, 5, 3, 4, 5, 3, 4, 5, 3, 4, 5, 3, 4, 5, 3, 4, 5, 3, 4, 5, 3], [1, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 5, 1, 1, 5, 1, 1, 5, 1], [4, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 5, 3, 4, 5, 3, 4, 5, 3], [5, 3, 0, 0,... | [{"input": [[5, 5, 5, 5, 4, 4, 5, 5, 5, 5, 5, 5, 4, 4, 5, 5, 5], [5, 5, 4, 4, 4, 5, 4, 4, 5, 5, 4, 4, 4, 5, 4, 4, 5], [5, 5, 5, 4, 4, 4, 4, 4, 5, 5, 5, 4, 4, 4, 4, 4, 5], [4, 5, 4, 5, 4, 5, 4, 4, 4, 5, 4, 5, 4, 5, 4, 4, 4], [5, 4, 5, 4, 4, 4, 4, 4, 5, 4, 5, 4, 4, 4, 4, 4, 5], [5, 5, 5, 5, 4, 4, 5, 5, 5, 5, 5, 5, 4, 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... | ```
5 4 4 4 4 4
5 5 4 4 5 5
4 4 4 5 4 4
5 4 4 4 4 4
4 5 4 5 4 4
5 4 4 4 4 4
5 5 4 4 5 5
4 4 4 5 4 4
5 4 4 4 4 4
``` | 2,928 |
<|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 compact, contiguous clusters of a single color that are surrounded by background (zeros). These clusters are often the objects being transformed: their exact shape and position are preserved while only their internal color is changed. This is effective because many ARC tasks treat sm... | [{"input": [[0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0], [0, 2, 2, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0, 2, 1, 1, 2], [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0], [0, 2, 0, 0, 3, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0], [2, 1, 0, 0, 3, 0, 0, 0, 0, 2, 2, 2, 0, 1, ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0], [0, 2, 2, 1, 2, 2, 0, 0, 3, 2, 3, 0, 0, 0], [0, 2, 1, 3, 1, 2, 0, 0, 0, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2], [2, 3, 2, 0, 0, 3, 2, 0, 2, 3, 0, 2, 2, 2], [0, 0, 0, 0, 0, 3, 2, 3, 2, 3, 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 4 0 0 0 0
0 1 1 4 1 1 0 0 4 4 4 0 0 0
0 1 4 4 4 1 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 0 0 0 0 0 0 1 1 1
1 1 1 0 0 1 1 0 1 1 0 1 1 1
0 0 0 0 0 1 1 1 1 1 0 0 0 0
1 1 0 0 0 0 4 1 4 0 0 1 1 0
1 1 0 1 1 0 0 0 0 0 0 1 1 0
1 1 0 1 1 0 0 0 0 0 1 1 1 1
0 0 0 0 0 0 0 0 0 0 0 1 1 0
0 0 1 1 ... | 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,314 | [
"<note1>\n<description>Scan the grid for a small, compact object (usually a contiguous 2×2 or 3×3 block) that is uniform in color and sits inside a larger patch of a different color. Such an object is often the only local 2×2 square of one color and is therefore the natural target for the transformation.</descripti... | [{"input": [[0, 2, 2], [1, 1, 2], [2, 2, 1], [1, 1, 2], [1, 1, 1], [1, 2, 0], [0, 0, 1], [0, 0, 1], [2, 2, 0], [1, 0, 2], [2, 1, 1], [2, 1, 1], [2, 2, 1], [0, 0, 1], [0, 0, 2], [1, 2, 1], [2, 2, 2], [0, 0, 0]], "output": [[0, 2, 2], [1, 1, 2], [2, 2, 1], [1, 1, 2], [1, 1, 1], [1, 2, 0], [6, 6, 1], [6, 6, 1], [2, 2, 0],... | [{"input": [[3, 3, 3, 9, 7, 5], [9, 3, 7, 1, 0, 0], [1, 1, 7, 0, 2, 9], [0, 0, 9, 0, 5, 7], [5, 7, 3, 9, 0, 9], [5, 7, 7, 7, 0, 0], [7, 7, 3, 0, 2, 2], [3, 0, 5, 3, 7, 7], [5, 7, 7, 5, 2, 2], [7, 1, 3, 5, 9, 1], [9, 3, 3, 7, 0, 7], [2, 5, 3, 3, 5, 1], [7, 5, 0, 9, 1, 9], [2, 3, 7, 0, 1, 5], [2, 7, 5, 0, 0, 3], [9, 7, 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... | ```
3 3 3 9 7 5
9 3 7 1 0 0
1 1 7 0 2 9
0 0 9 0 5 7
5 7 3 9 0 9
5 7 7 7 0 0
7 7 3 0 2 2
3 0 5 3 7 7
5 7 7 5 2 2
7 1 3 5 9 1
9 3 3 7 0 7
2 5 3 3 5 1
7 5 0 9 1 9
2 3 7 0 1 5
2 7 5 0 0 3
9 7 0 7 2 7
7 7 7 7 5 5
3 9 5 6 6 9
2 1 9 6 6 3
9 5 1 9 0 1
9 1 1 3 1 0
``` | 1,610 |
<|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,868 | [
"<note1>\n<description>When a grid is uniform across many rows or columns, treat it as a single band: a contiguous set of rows (or columns) that all share the same color. This band can be the whole grid or a continuous slice of it, and it is the natural unit to compress into a single representative value.</descript... | [{"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, 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], [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], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7... | [{"input": [[5, 5, 5, 5, 8, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 1, 1], [5, 5, 5, 5, 8, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 1, 1], [5, 5, 5, 5, 8, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 1, 1], [5, 5, 5, 5, 8, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 1, 1], [5, 5, 5, 5, 8, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 1, 1], [5, 5, 5, 5, 8, 5, 5, 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... | ```
5 8 5 6 1
``` | 3,164 |
<|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,038 | [
"<note1>\n<description>Check whether the transformation preserves every cell's color and position. If every color value remains the same in the output, the operation is a rigid reorientation rather than a recoloring or cropping.</description>\n<example>Imagine a 3×3 grid where the center cell is a special marker an... | [{"input": [[1, 9, 9, 9, 9, 9, 5, 1, 9, 9, 9, 1, 5, 9, 1, 9, 5, 9, 9, 5, 5, 1, 5, 5, 5, 5, 9], [5, 5, 9, 1, 1, 9, 1, 1, 5, 1, 9, 1, 9, 9, 9, 9, 5, 5, 9, 1, 1, 9, 9, 5, 9, 9, 1], [5, 1, 9, 5, 5, 5, 9, 9, 9, 1, 9, 1, 9, 9, 1, 9, 9, 5, 5, 9, 1, 9, 1, 1, 5, 9, 1], [9, 9, 9, 5, 5, 9, 1, 9, 1, 9, 9, 1, 9, 1, 9, 9, 9, 9, 5, 1... | [{"input": [[7, 7, 7, 7], [5, 4, 7, 7], [9, 7, 7, 1], [6, 3, 7, 7], [6, 4, 7, 7], [3, 7, 3, 7], [3, 5, 7, 1], [1, 7, 5, 7], [6, 7, 6, 7], [7, 0, 6, 7], [7, 7, 4, 7], [1, 7, 7, 6], [6, 7, 7, 4], [7, 1, 3, 7], [7, 7, 7, 7], [6, 3, 5, 6], [4, 7, 7, 3], [7, 7, 7, 4], [9, 7, 7, 3], [7, 7, 7, 7], [7, 7, 3, 6], [4, 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... | ```
9 5 9 3
7 4 4 4
7 7 7 5
9 7 1 7
7 1 3 7
4 7 7 7
7 7 3 6
7 7 7 7
9 7 7 3
7 7 7 4
4 7 7 3
6 3 5 6
7 7 7 7
7 1 3 7
6 7 7 4
1 7 7 6
7 7 4 7
7 0 6 7
6 7 6 7
1 7 5 7
3 5 7 1
3 7 3 7
6 4 7 7
6 3 7 7
9 7 7 1
5 4 7 7
7 7 7 7
``` | 2,334 |
<|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,119 | [
"<note1>\n<description>First confirm the output is built from whole copies of the input, not from pixel-wise changes. If the output’s non-background cells form exact rectangles and each rectangle matches the input’s shape and colors, the transformation is a tiling (repetition) operation.</description>\n<example>Ima... | [{"input": [[3, 2, 7], [2, 2, 7], [5, 5, 7]], "output": [[3, 2, 7, 0, 0, 0, 0, 0, 0], [2, 2, 7, 0, 0, 0, 0, 0, 0], [5, 5, 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, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]]}, ... | [{"input": [[9, 7, 9], [9, 9, 7], [7, 9, 7]], "output": [[0, 0, 0, 9, 7, 9, 0, 0, 0], [0, 0, 0, 9, 9, 7, 0, 0, 0], [0, 0, 0, 7, 9, 7, 0, 0, 0], [0, 0, 0, 0, 0, 0, 9, 7, 9], [0, 0, 0, 0, 0, 0, 9, 9, 7], [0, 0, 0, 0, 0, 0, 7, 9, 7], [9, 7, 9, 0, 0, 0, 9, 7, 9], [9, 9, 7, 0, 0, 0, 9, 9, 7], [7, 9, 7, 0, 0, 0, 7, 9, 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 9 7 9 0 0 0
0 0 0 9 9 7 0 0 0
0 0 0 7 9 7 0 0 0
0 0 0 0 0 0 9 7 9
0 0 0 0 0 0 9 9 7
0 0 0 0 0 0 7 9 7
9 7 9 0 0 0 9 7 9
9 9 7 0 0 0 9 9 7
7 9 7 0 0 0 7 9 7
``` | 1,415 |
<|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,410 | [
"<note1>\n<description>Look for a single non-background pixel that acts as the anchor: when one color appears exactly once and all other cells are background, that pixel is usually the center of the transformation. Identifying this anchor reduces the problem to a local operation around one point. </description>\n<e... | [{"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, 7, 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, 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, ... | 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 8 8 8 8 0
0 0 0 0 0 0 0 0 0 0 0 0 0 8 0 0 8 0
0 0 0 0 0 0 0 0 0 0 0 0 0 8 0 0 8 8
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 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 ... | 3,706 |
<|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,190 | [
"<note1>\n<description>Locate the object to transform: a contiguous block of a single non-background color. Treat that entire connected region as one object rather than many separate pixels; the operation will be applied to the whole object.</description>\n<example>Imagine a 3×3 green square sitting on a black back... | [{"input": [[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], [0, 0, 9, 9, 9, 0, 0, 0, 0, 0, 0, 8, 8], [0, 0, 9, 9, 9, 0, 0, 0, 0, 0, 0, 8, 8], [0, 0, 9, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0], [0, 0, 0, 6, 6, 6, 6, 0, 0, 6, 6, 6, 0], [0, 0, 0, 6, 6, 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], [5, 5, 5, 5, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0], [5, 5, 5, 5, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0], [5, 5, 5, 5, 0, 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], ... | 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
5 5 5 0 0 6 6 0 0 0 0 0 0 0
5 5 5 0 0 6 6 0 0 0 0 0 0 0
5 5 5 0 0 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 9 9 0 0 0 0
0 0 0 0 0 0 0 0 9 9 0 0 0 0
0 0 0 0 0 0 0 0 9 9 0 0 0 0
0 0 0 0 0 0 0 0 0 9 0 0 0 0
0 0 0 0 ... | 2,486 |
<|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 dominant color that appears in many disconnected pixels across the input; that color is the one being relocated. When one color is the most frequent (count-wise), treat it as the “seed” for the transformation. This is effective because the output often shows that color in a singl... | [{"input": [[0, 0, 0, 0, 0, 5, 5, 5, 0, 5], [0, 0, 0, 9, 9, 9, 0, 3, 3, 5], [0, 0, 0, 9, 6, 9, 0, 4, 4, 5], [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, 2, 0, 0], [0, 1, 0, 3, 1, 1, 1, 2, 0, 0], [1, 1, 1, 3, 3, 1, 1, 1, 1, 0], [0, 1, 0, 3, 1, 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, 1, 1], [0, 0, 0, 0, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 7, 1, 0, 5, 0], [0, 8, 8, 0, 0, 0, 0, 0, 4, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0, 1], [0, 8, 8, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 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... | ```
4 1 1 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0
0 0 1 6 0 0 0 0 0 0
0 0 0 6 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
7 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0 0
4 5 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... | 1,194 | [
"<note1>\n<description>Look for a single, consistent rearrangement of the four large uniform blocks that preserves their shape and size. When the transformation is a relabeling, the spatial arrangement of the blocks stays the same but their colors change according to a fixed mapping.</description>\n<example>Imagine... | [{"input": [[8, 8, 1, 1], [8, 8, 1, 1], [9, 9, 6, 6], [9, 9, 6, 6]], "output": [[8, 8, 9, 9], [8, 8, 9, 9], [2, 2, 5, 5], [2, 2, 5, 5]]}, {"input": [[2, 2, 6, 6], [2, 2, 6, 6], [2, 2, 8, 8], [2, 2, 8, 8]], "output": [[6, 6, 6, 6], [6, 6, 6, 6], [9, 9, 2, 2], [9, 9, 2, 2]]}, {"input": [[4, 4, 5, 5], [4, 4, 5, 5], [4, 4,... | [{"input": [[1, 1, 1, 1], [1, 1, 1, 1], [2, 2, 1, 1], [2, 2, 1, 1]], "output": [[6, 6, 5, 5], [6, 6, 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... | ```
6 6 5 5
6 6 5 5
5 5 5 5
5 5 5 5
``` | 490 |
<|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,632 | [
"<note1>\n<description>Look for full rows or full columns that are a single color — these act as separators and partition the grid into a regular array of tiles. When separators repeat regularly, the whole grid becomes a tiled layout (a matrix of tiles) rather than many independent pixels.</description>\n<example>I... | [{"input": [[1, 1, 1, 1, 1, 1, 1, 7, 1, 1, 1, 1, 1, 1, 1, 7, 4, 4, 4, 4, 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], [1, 1, 1, 1, 1, 1, 1, 7, 1, 1, 1, 1, 1, 1, 1, 7, 1, 1, 1, 1, 1, 1, 1], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [1, 1, 1, 1, 1, 1, 1, 7,... | [{"input": [[4, 0, 3, 0, 9, 0, 1, 0, 3, 0, 3, 0, 3, 0, 1, 0, 3, 0, 3, 0, 3, 0, 3, 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], [3, 0, 9, 0, 3, 0, 5, 0, 5, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 2, 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], ... | 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 1 3 3 3 1 9 3 4
3 2 3 3 3 3 3 3 5 5 3 9 3
3 2 2 3 3 3 3 5 3 6 7 3 3
5 3 6 3 8 7 3 3 3 3 3 3 3
3 8 3 3 3 3 3 3 4 3 3 3 1
1 3 3 3 6 3 3 3 3 3 6 9 3
9 3 1 3 3 6 1 3 3 9 3 3 9
``` | 3,928 |
<|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 all non-background cells and computing its minimal bounding rectangle. Knowing the rectangle's top-left, height and width tells you which cells are affected and which are background.</description>\n<example>Imagine a 7×7 grid with a single red pixel at (row 3, co... | [{"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, 8, 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, 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]], "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
6 0 0 0 0 0 0 0 0
0 6 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
0 0 0 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... | 3,734 | [
"<note1>\n<description>Look for a dominant (most frequent) non-background color in the input; that color is the likely candidate for a global recolor. This color is usually the one whose pixels are most numerous and is often changed across the whole grid in the outputs.</description>\n<example>Imagine a grid with m... | [{"input": [[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, 1, 0, 3, 2, 2, 2, 3], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 3, 2, 3, 2, 3], [0, 4, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0, 2, 3, 3, 3, 2], [4, 1, 4, 0, 0, 2, 2, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0], [0, 4, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, ... | [{"input": [[2, 4, 0, 0, 0, 0, 0, 0, 4, 2, 3, 0, 4, 0], [4, 4, 0, 0, 0, 0, 0, 0, 4, 1, 3, 1, 4, 0], [4, 1, 2, 1, 1, 2, 0, 0, 4, 4, 1, 4, 4, 0], [4, 4, 0, 0, 0, 0, 0, 0, 3, 2, 1, 2, 3, 0], [2, 4, 0, 0, 0, 0, 0, 0, 2, 1, 2, 1, 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], ... | 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 3 0 0 0 0 0 0 3 4 4 0 3 0
3 3 0 0 0 0 0 0 3 4 4 4 3 0
3 4 4 4 4 4 0 0 3 3 4 3 3 0
3 3 0 0 0 0 0 0 4 4 4 4 4 0
4 3 0 0 0 0 0 0 4 4 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 0 0
0 0 3 3 3 0 0 0 0 0 0 0 0 0
0 0 3 3 3 0 4 4 4 4 4 0 0 0
0 0 4 0 4 0 0 0 0 0 0 1 1 4
0 0 3 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... | 3,018 | [
"<note1>\n<description>Find the seeds: identify the small set of non-background pixels that are not part of the dominant background color. These isolated pixels are the only locations that trigger the transformation in the examples.</description>\n<example>Imagine a grid that is mostly color A with a few scattered ... | [{"input": [[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [2, 1, 2, 2, 2, 2, 2, 9, 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, 2, 2, 2, 2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2], [2, 9, 2, 2, 2, 2, 2, 1, 2, 2, 2], [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]], "output": [[9, 9, 9, 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, 1, 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, ... | 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 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 6 6 6 0 1 1 1 0 0 0 0 0
0 0 0 0 0 0 6 1 6 5 1 6 1 0 0 0 0 0
0 0 0 0 0 0 6 6 6 0 1 1 1 0 0 0 0 0
0 0 0 0 0 0 0 5 0 0 0 5 0 0 0 0 0 0
0 0 0 0 0 0 0 5 0 0 0 5 0 0 0 0 0 0
0 0 0 0 0 0 1 1 1 0 6 6 6 0 0 0 0 0
0 0 0 0 0 0 1 6 1 5 6 1 6 0 0 0 0 0
``` | 2,314 |
<|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,290 | [
"<note1>\n<description>Look for the background color by frequency: the color that fills most of the grid is usually the background and is preserved in the output. Identifying this color first narrows the problem to the few pixels that change.</description>\n<example>Imagine a 6×6 grid where 30 cells are color A and... | [{"input": [[7, 7, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 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, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 7, 5, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 7, 5, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 7, 5, ... | [{"input": [[5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [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, 6, 6, 6, 6, 7, 7], [5, 5, 5, 5, 7, 7, 7, 7, 7, 7, 7, 7]], "output": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [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... | ```
1 1 1 1 1 1 1 1 1 1 1 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 7 7
7 7 7 7 7 4 4 4 4 4 7 7
2 2 2 2 7 7 7 7 7 7 7 7
``` | 3,586 |
<|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,098 | [
"<note1>\n<description>Find the minimal bounding rectangle that contains all non-background pixels; treat that rectangle as the \"tile\" to be reused. This isolates the repeating unit and makes it easier to reason about what the transformation does.</description>\n<example>If a 6×6 grid has colored pixels only in r... | [{"input": [[8, 1, 9, 9, 0, 0, 0, 0], [3, 3, 6, 9, 0, 0, 0, 0], [4, 4, 3, 1, 0, 0, 0, 0], [4, 4, 3, 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]], "output": [[8, 1, 9, 9, 9, 9, 1, 8], [3, 3, 6, 9, 9, 6, 3, 3], [4, 4, 3, 1, 1, 3, 4, 4], [4, 4, 3, ... | [{"input": [[1, 1, 1, 0, 0, 0], [1, 4, 1, 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]], "output": [[1, 1, 1, 1, 1, 1], [1, 4, 1, 1, 4, 1], [1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1], [1, 4, 1, 1, 4, 1], [1, 1, 1, 1, 1, 1]]}] | 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 1 1 1 1 1
1 4 1 1 4 1
1 1 1 1 1 1
1 1 1 1 1 1
1 4 1 1 4 1
1 1 1 1 1 1
``` | 1,394 |
<|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 dominant geometric motif: many tasks compress a small cluster of several different colors into a single, uniform small square. The key is to detect that a contiguous group of pixels forms a compact block rather than isolated single pixels.</description>\n<example>Imagine a cluste... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 5, 6, 0, 0, 0, 0, 0], [0, 0, 0, 7, 9, 0, 4, 6, 0, 0], [0, 0, 0, 0, 0, 0, 9, 8, 0, 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, 7, 7, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 4, 8, 0, 0, 0, 0, 0], [0, 0, 0, 7, 6, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 6, 9, 0, 0, 5, 6, 0, 0], [0, 0, 5, 9, 0, 0, 5, 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, 1, 6, 0, 0, 0], [0, 0, 0, 0, 0, 5, 6, 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 1 1 0 0 1 1 0 0
0 0 1 1 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 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 0 1 1 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,750 | [
"<note1>\n<description>Look for the minimal axis-aligned bounding box that contains every non-background pixel. This rectangle is defined by the smallest and largest row and column indices that hold any colored cell, and it is the natural candidate for the output canvas.</description>\n<example>Imagine a grid where... | [{"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, 0, 0, 4, 4, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 4, 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... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 2, 2, 2, 1, 1, 0, 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, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 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 1 0
2 2 2 1 1
0 0 0 1 1
``` | 2,046 |
<|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,920 | [
"<note1>\n<description>Identify the background and the minority color that forms the objects to operate on. The background is usually the most frequent color and the target color is the one that appears as isolated pixels or small clusters; distinguishing these two colors tells you which pixels are candidates for c... | [{"input": [[7, 7, 7, 7, 7, 7, 4, 7, 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, 7, 7, 7, 7, 7, 4, 7, 7, 7, 7, 7, 7, 7, 4, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 7, 7, 7, 7, 7, 7], [7, 7, 4, 7, 4, 4, 7, 7, 7, 7, 4, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7,... | [{"input": [[5, 5, 4, 5, 5], [5, 5, 4, 5, 4], [5, 5, 4, 5, 5], [5, 5, 5, 5, 4], [5, 5, 5, 5, 5], [5, 5, 5, 5, 4], [5, 5, 5, 4, 4]], "output": [[5, 5, 4, 5, 5], [5, 5, 4, 8, 4], [5, 5, 4, 5, 8], [5, 5, 5, 5, 4], [5, 5, 5, 5, 8], [5, 5, 5, 5, 4], [5, 5, 5, 4, 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... | ```
5 5 4 5 5
5 5 4 8 4
5 5 4 5 8
5 5 5 5 4
5 5 5 5 8
5 5 5 5 4
5 5 5 4 4
``` | 3,216 |
<|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>Compare dimensions first: if the output’s width equals the input’s height and the output’s height equals the input’s width, the transformation is a 90° rotation rather than a simple crop or mirror. This is a quick, reliable dimensional clue to narrow the operation set.</description>\n<example... | [{"input": [[7, 7, 7, 0, 7, 0, 0, 0, 0, 7, 8, 0], [1, 5, 0, 7, 5, 0, 7, 7, 8, 0, 0, 0], [7, 5, 0, 8, 7, 0, 5, 8, 0, 5, 7, 0], [0, 0, 0, 1, 0, 5, 0, 0, 5, 0, 0, 1], [8, 5, 0, 1, 7, 0, 5, 7, 0, 0, 8, 0], [0, 0, 1, 8, 0, 0, 5, 0, 0, 1, 8, 0], [7, 0, 5, 8, 5, 5, 0, 0, 8, 0, 0, 0], [1, 5, 0, 5, 0, 0, 1, 0, 7, 0, 1, 0]], "ou... | [{"input": [[0, 9, 9, 4, 0, 1, 0, 4, 0], [0, 9, 0, 4, 0, 0, 4, 1, 0], [1, 0, 0, 1, 0, 0, 4, 9, 0], [0, 0, 0, 4, 0, 4, 0, 1, 4], [1, 0, 0, 1, 0, 0, 1, 0, 0], [9, 0, 0, 1, 4, 9, 9, 0, 9], [0, 4, 0, 4, 1, 0, 9, 0, 9], [4, 1, 0, 0, 9, 0, 1, 1, 0], [0, 0, 0, 4, 0, 4, 1, 4, 1]], "output": [[0, 4, 0, 9, 1, 0, 1, 0, 0], [0, 1,... | 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 4 0 9 1 0 1 0 0
0 1 4 0 0 0 0 9 9
0 0 0 0 0 0 0 0 9
4 0 4 1 1 4 1 4 4
0 9 1 4 0 0 0 0 0
4 0 0 9 0 4 0 0 1
1 1 9 9 1 0 4 4 0
4 1 0 0 0 1 9 1 4
1 0 9 9 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... | 2,636 | [
"<note1>\n<description>Look for a full row or full column that is a single color and spans the entire grid; this line usually separates two distinct regions. Treat that line as a divider rather than part of the objects you will keep.</description>\n<example>Imagine a 7×7 grid where column 4 is entirely blue while t... | [{"input": [[0, 0, 0, 0, 1, 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, 1, 0, 0, 3, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0], [0, 2, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 2, 0, 0, 1, 0, 0,... | [{"input": [[0, 0, 0, 0, 0, 0, 1, 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, 1, 0, 0, 3, 3, 3, 0], [0, 0, 2, 2, 0, 0, 1, 0, 0, 0, 3, 3, 0], [0, 0, 2, 0, 0, 0, 1, 0, 0, 3, 0, 0, 0], [0, 2, 0, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1,... | 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 2 2 3 3 3
0 2 0 0 3 3
2 0 2 3 0 0
0 6 6 0 4 0
6 0 6 4 0 4
6 6 0 0 4 0
``` | 1,932 |
<|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 for the invariant color: a single color that appears in the same cells in both input and output. When one color is unchanged across the whole grid, the transformation is likely a recoloring of the other colors rather than a structural change.</description>\n<example>Imagine a 5×5 grid wh... | [{"input": [[4, 8, 7, 6, 4], [4, 8, 7, 6, 4], [4, 8, 7, 6, 4], [4, 8, 7, 6, 4], [4, 8, 7, 6, 4]], "output": [[2, 8, 7, 6, 2], [2, 8, 7, 6, 2], [2, 8, 7, 6, 2], [2, 8, 7, 6, 2], [2, 8, 7, 6, 2]]}, {"input": [[3, 6, 7, 4, 1], [3, 6, 7, 4, 1], [3, 6, 7, 4, 1], [3, 6, 7, 4, 1], [3, 6, 7, 4, 1]], "output": [[1, 6, 7, 2, 3],... | [{"input": [[5, 5, 6, 5, 3], [5, 5, 6, 5, 3], [5, 5, 6, 5, 3], [5, 5, 6, 5, 3], [5, 5, 6, 5, 3]], "output": [[5, 5, 6, 5, 1], [5, 5, 6, 5, 1], [5, 5, 6, 5, 1], [5, 5, 6, 5, 1], [5, 5, 6, 5, 1]]}] | 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 6 5 1
5 5 6 5 1
5 5 6 5 1
5 5 6 5 1
5 5 6 5 1
``` | 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... | 3,782 | [
"<note1>\n<description>Compare shapes and counts first: if the output keeps the same arrangement of colored pixels and the same number of each color, the transformation is likely a rigid spatial operation (rotation or reflection). This narrows the search from recoloring or reshaping to only geometric relocations.</... | [{"input": [[3, 5, 3, 7, 1, 3, 7, 3, 3, 3, 2, 3, 2, 2, 5, 3, 5, 4, 3, 3, 3, 3, 3, 3], [7, 3, 4, 4, 3, 2, 3, 4, 5, 5, 4, 3, 4, 3, 3, 3, 4, 7, 7, 2, 3, 3, 4, 4], [3, 3, 2, 5, 7, 2, 7, 1, 7, 4, 3, 3, 4, 3, 3, 5, 4, 2, 2, 3, 7, 3, 3, 2], [7, 3, 3, 4, 4, 1, 5, 2, 2, 3, 3, 4, 7, 3, 3, 5, 7, 3, 7, 2, 4, 3, 3, 5], [3, 2, 4, 4,... | [{"input": [[8, 8, 8, 8, 7, 8, 5, 8, 8, 8, 8, 8, 8, 8, 5, 7, 7], [8, 8, 8, 7, 5, 7, 7, 5, 8, 8, 7, 8, 7, 8, 5, 5, 8], [5, 8, 7, 8, 8, 8, 8, 8, 7, 7, 8, 7, 7, 8, 7, 8, 8], [8, 8, 8, 5, 5, 8, 5, 8, 5, 8, 8, 7, 8, 7, 5, 5, 5], [7, 8, 8, 7, 8, 5, 8, 5, 8, 8, 7, 8, 5, 8, 7, 9, 5], [5, 8, 8, 8, 8, 5, 5, 8, 7, 8, 8, 7, 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 8 9 5 5 8 8 8 7 8 7 7 8 8 8 5 8
8 9 5 5 8 7 7 8 5 8 9 8 8 7 8 8 7
5 5 5 7 8 7 7 5 5 8 8 5 5 5 8 8 8
7 7 8 8 5 8 8 8 7 5 8 5 8 5 8 5 5
7 5 8 5 8 5 7 7 8 8 7 7 8 8 5 5 8
8 5 7 8 5 8 5 5 5 5 8 7 8 7 8 7 8
8 7 8 5 5 8 8 8 5 8 7 8 5 5 5 8 8
8 8 8 8 8 5 8 7 5 7 8 7 9 5 7 5 8
7 8 8 7 8 8 8 8 8 5 8 8 5 7 8 8 8
8 5 8 8 8 ... | 3,078 |
<|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,110 | [
"<note1>\n<description>Start by identifying the background: the color that occupies most of the grid. Treat any color that is not that dominant color as foreground and collect the connected components for each foreground color.</description>\n<example>Imagine a grid where 80% of cells are color A and the remaining ... | [{"input": [[5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 2, 2, 2, 2, 2, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 2, 2, 5, 5, 2, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [5, 5, 2, 2, 5, 5, 2, 5, 5, 8, 8, 8, 8, 8, 8, 8, 5, 5, 5, 5, 5], [5, 5, 2, 2, 5, 5, 2, 5, 5, 8, 8, 8, 8, 8, 8, 8,... | [{"input": [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 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... | ```
2
``` | 3,406 |
<|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 target object by color: the transformation usually targets a single non-background color that appears as a compact shape. Isolating that connected component (or the set of all pixels of that color) focuses attention on the relevant area for the next steps.</description>\n<example>Ima... | [{"input": [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 6, 6, 6, 6, 7, 7, 7, 6, 7], [7, 6, 7, 7, 6, 7, 7, 6, 7, 7], [7, 6, 7, 7, 6, 7, 7, 7, 7, 7], [7, 6, 6, 6, 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, 6, 7, 7, 6, 6, 6, 6, 7], [7, 6, 7, 7, 7, 6, 6, 6, 6, 7], [7, 7, 7, 7, 7, 7, 7... | [{"input": [[7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 6, 6, 6, 7, 7, 6, 6, 7, 7], [7, 6, 7, 6, 7, 7, 6, 6, 7, 7], [7, 6, 6, 6, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 7, 7, 7, 7, 6, 6, 6, 7, 7], [7, 6, 6, 7, 7, 6, 7, 6, 7, 7], [7, 6, 6, 7, 7, 6, 6, 6, 7, 7], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7], [7, 6, 6, 6, 6, 6, 6... | 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 2 7 2 7 7 2 2 7 7
2 6 6 6 2 2 6 6 2 7
7 6 7 6 7 2 6 6 2 7
2 6 6 6 2 7 2 2 7 7
7 2 7 2 7 2 7 2 7 7
7 2 2 7 2 6 6 6 2 7
2 6 6 2 7 6 7 6 7 7
2 6 6 2 2 6 6 6 2 7
7 2 2 7 7 2 7 2 7 7
7 6 6 6 6 6 6 6 6 7
``` | 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,672 | [
"<note1>\n<description>Focus first on the non-background color and treat every pixel of that color as part of one connected object. This simplifies the problem to a single shape rather than many isolated pixels.</description>\n<example>Imagine a grid with a single green cluster on a black background: collect all gr... | [{"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, 4, 0, 4, 0], [0, 0, 0, 0, 0, 4, 4, 4, 4, 0, 4, 0, 4, 0], [0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 0], [0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 0, 4, 4, 0], [0, 0, 0, 0, 0, 4, 4, 0, 0, 4, 4, 4, 4, 0], [0, 0, 0, 0, 0, 4, 4, 4, 0, 4, 4, 4, 0, 0], ... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 4, 4, 4, 0, 0, 4, 4, 4, 0, 0], [0, 4, 0, 0, 4, 0, 4, 4, 4, 0, 0], [0, 4, 0, 4, 4, 4, 4, 4, 4, 0, 0], [0, 4, 4, 4, 0, 4, 4, 4, 4, 0, 0], [0, 0, 0, 0, 4, 4, 0, 4, 4, 0, 0], [0, 0, 4, 0, 0, 4, 4, 0, 4, 0, 0], [0, 0, 4, 4, 4, 4, 4, 4, 4, 0, 0], [0, 4, 0, 0, 0, 4, 4, 4, 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... | ```
0 0 0 0 0 0 0 0 0 0 0
0 1 1 1 1 1 1 1 1 0 0
0 1 4 4 4 4 4 4 1 0 0
0 1 4 4 4 4 4 4 1 0 0
0 1 4 4 4 4 4 4 1 0 0
0 1 4 4 4 4 4 4 1 0 0
0 1 4 4 4 4 4 4 1 0 0
0 1 4 4 4 4 4 4 1 0 0
0 1 1 1 1 1 1 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
``` | 1,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... | 2,370 | [
"<note1>\n<description>Look for a single dominant color that fills a contiguous rectangular block and a single other color filling the remainder of the grid. When these two roles are consistent across examples, the transformation usually acts on that dominant block rather than on the background.</description>\n<exa... | [{"input": [[1, 1, 1, 1, 1, 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], [1, 1, 1, 1, 1, 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], [1, 1, 1, 1, 1, 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], [1, 1, 1, 1, 1, 0, 0... | [{"input": [[3, 3, 3, 3, 3, 0, 0, 0, 0, 0], [3, 3, 3, 3, 3, 0, 0, 0, 0, 0], [3, 3, 3, 3, 3, 0, 0, 0, 0, 0], [3, 3, 3, 3, 3, 0, 0, 0, 0, 0], [3, 3, 3, 3, 3, 0, 0, 0, 0, 0], [3, 3, 3, 3, 3, 0, 0, 0, 0, 0], [3, 3, 3, 3, 3, 0, 0, 0, 0, 0], [3, 3, 3, 3, 3, 0, 0, 0, 0, 0], [3, 3, 3, 3, 3, 0, 0, 0, 0, 0], [3, 3, 3, 3, 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... | ```
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 3 3 3
``` | 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 first at colors that never change between input and output: these are invariants and usually indicate background or structural cells. Treat those colors as fixed anchors so you can focus on the colors that are being remapped.</description>\n<example>Imagine a grid where black pixels rema... | [{"input": [[0, 2, 2, 2, 2, 3, 2, 3, 2, 0], [2, 2, 0, 2, 2, 0, 3, 3, 3, 2], [2, 2, 3, 2, 0, 2, 3, 2, 2, 3], [0, 3, 2, 0, 0, 0, 0, 3, 2, 3], [2, 2, 0, 3, 2, 3, 2, 3, 3, 3], [3, 2, 2, 2, 0, 3, 3, 2, 3, 2], [3, 0, 3, 3, 0, 3, 3, 2, 3, 3], [3, 3, 3, 3, 3, 2, 3, 0, 3, 2], [2, 2, 0, 0, 2, 0, 3, 2, 0, 3], [2, 2, 2, 2, 3, 3, 3... | [{"input": [[2, 3, 3, 2, 0, 3, 3, 2, 0, 2], [0, 0, 0, 2, 2, 3, 2, 3, 2, 0], [0, 0, 2, 2, 3, 3, 2, 2, 3, 2], [3, 2, 2, 0, 3, 0, 2, 3, 2, 2], [3, 3, 3, 0, 3, 3, 2, 3, 3, 2], [3, 2, 3, 0, 2, 3, 2, 2, 3, 3], [3, 3, 0, 2, 2, 3, 3, 3, 3, 3], [2, 2, 2, 3, 0, 2, 3, 0, 3, 2], [2, 3, 0, 2, 0, 0, 2, 0, 3, 2], [2, 2, 3, 3, 2, 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... | ```
1 4 4 1 0 4 4 1 0 1
0 0 0 1 1 4 1 4 1 0
0 0 1 1 4 4 1 1 4 1
4 1 1 0 4 0 1 4 1 1
4 4 4 0 4 4 1 4 4 1
4 1 4 0 1 4 1 1 4 4
4 4 0 1 1 4 4 4 4 4
1 1 1 4 0 1 4 0 4 1
1 4 0 1 0 0 1 0 4 1
1 1 4 4 1 1 0 4 1 4
``` | 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,810 | [
"<note1>\n<description>Look for a global color mapping: check whether every non-background color in the input appears as a single, uniform color across the entire output. When that happens, the transformation is a color substitution rather than a geometric rearrangement.</description>\n<example>Imagine an input wit... | [{"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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 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... | ```
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 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 4 4 4 4 4 4
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 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 9 9
9 9 9 9 ... | 3,106 |
<|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,750 | [
"<note1>\n<description>Separate background from objects by frequency and shape: the background is usually the most common color; objects are contiguous regions of other colors. This separation tells you which pixels are candidates for transformation and which should remain unchanged.</description>\n<example>Imagine... | [{"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, 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,... | [{"input": [[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, 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, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 5, 9, 9, 9, 9, 9], [9, 9, 9, 5, 9, 6, 6, 9, 9, 9], [9, 9, 9, 9, 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... | ```
9 9 9 9 9 9 9 9 9 9
9 9 9 9 9 9 9 9 9 9
5 9 9 9 9 9 9 9 9 9
5 5 9 9 9 9 9 9 9 9
5 5 9 9 9 9 9 9 9 9
5 9 5 5 9 9 9 9 9 9
9 5 5 5 5 9 9 9 9 9
9 5 5 5 5 9 9 9 9 9
9 9 5 5 9 6 6 9 9 9
9 9 9 9 6 6 6 6 9 9
9 9 9 9 6 6 6 6 9 9
9 9 9 9 9 6 6 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 9 9 9 9 9 9
9 9 9 9 9 9 9 9 ... | 4,046 |
<|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,990 | [
"<note1>\n<description>Focus first on rows that contain multiple colored pixels. When a single row contains several non-background cells, the transformation often acts by reorienting or repositioning those cells rather than moving whole shapes.</description>\n<example>Imagine a row that reads [A, B, C] with A at th... | [{"input": [[3, 4, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 5, 0, 0, 0], [0, 0, 0, 0, 0, 0, 9, 8, 0, 0], [0, 0, 0, 0, 0, 0, 0, 9, 0, 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]], "output": [[3, 4, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 5, 0, 0, 0], [0, 0, 0... | [{"input": [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 3], [0, 0, 0, 0, 0, 9], [0, 0, 0, 0, 0, 0], [0, 0, 8, 0, 0, 0], [2, 0, 6, 0, 0, 0], [8, 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, 3], [0, 0, 0, 0, 0, 3], [0, 0, 0, 0, 0, 0], [0, 0, 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 0 0 0 0 0
0 0 0 0 0 3
0 0 0 0 0 3
0 0 0 0 0 0
0 0 8 0 0 0
2 0 6 0 0 0
8 0 0 0 0 0
0 0 0 0 0 0
``` | 1,286 |
<|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,710 | [
"<note1>\n<description>Start by isolating the minority color (the one that appears much less often than the background). That color is the feature you will use to decide row-level behavior. Counting occurrences helps you pick the marker color reliably.</description>\n<example>Imagine a grid where one color fills mo... | [{"input": [[6, 6, 6, 6, 6, 6, 8, 6, 6, 6, 6, 6, 6, 6, 6], [6, 6, 6, 8, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6], [8, 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, 8, 6, 6, 6], [6, 6, 6, 6, 6, 6, 8, 6, 6, 6, 6, 6, 6, 6, 6], [8, 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, 1, 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, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5], [1, 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]], "output": [[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 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
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
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 2 2 2
``` | 2,006 |
<|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,070 | [
"<note1>\n<description>Look first for a global reorientation: many ARC tasks move the whole grid rather than changing colors. If the output looks like a rotated or transposed version of the input, the rule is a spatial permutation of coordinates rather than recoloring. This reduces the problem to finding which coor... | [{"input": [[4, 4, 4, 4, 4], [4, 9, 4, 1, 2], [3, 4, 4, 2, 7], [4, 1, 4, 4, 3], [4, 0, 9, 4, 4], [9, 9, 4, 9, 4], [4, 9, 5, 0, 4], [4, 4, 7, 4, 4], [2, 4, 4, 4, 7], [4, 4, 4, 4, 4], [0, 4, 4, 0, 4], [5, 4, 9, 4, 4], [4, 4, 4, 9, 4], [4, 2, 4, 4, 5], [4, 9, 4, 4, 3], [4, 3, 4, 9, 4], [4, 0, 4, 0, 4], [0, 7, 4, 4, 5], [9... | [{"input": [[7, 7, 0, 0, 0, 0, 3, 3, 0, 3], [6, 0, 8, 0, 6, 1, 3, 0, 0, 8], [0, 0, 0, 1, 0, 6, 0, 0, 8, 0], [6, 8, 3, 0, 0, 3, 0, 0, 7, 8], [6, 3, 0, 3, 0, 0, 8, 1, 7, 7]], "output": [[3, 0, 3, 3, 0, 0, 0, 0, 7, 7], [8, 0, 0, 3, 1, 6, 0, 8, 0, 6], [0, 8, 0, 0, 6, 0, 1, 0, 0, 0], [8, 7, 0, 0, 3, 0, 0, 3, 8, 6], [7, 7, 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... | ```
3 0 3 3 0 0 0 0 7 7
8 0 0 3 1 6 0 8 0 6
0 8 0 0 6 0 1 0 0 0
8 7 0 0 3 0 0 3 8 6
7 7 1 8 0 0 3 0 3 6
``` | 3,366 |
<|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,560 | [
"<note1>\n<description>Check the overall size change first: if the output dimensions are integer multiples of the input's, the transformation is likely a tiling or repetition of the input rather than a local modification. This tells you whether to search for a repeated copy or a mirrored arrangement.</description>\... | [{"input": [[0, 3, 0, 0, 0, 6, 3, 0], [6, 0, 6, 9, 7, 2, 0, 0], [9, 0, 6, 6, 8, 0, 8, 2], [6, 8, 0, 6, 0, 8, 6, 0], [8, 9, 2, 2, 0, 0, 8, 8]], "output": [[0, 3, 0, 0, 0, 6, 3, 0, 0, 3, 6, 0, 0, 0, 3, 0], [6, 0, 6, 9, 7, 2, 0, 0, 0, 0, 2, 7, 9, 6, 0, 6], [9, 0, 6, 6, 8, 0, 8, 2, 2, 8, 0, 8, 6, 6, 0, 9], [6, 8, 0, 6, 0, ... | [{"input": [[4, 4, 1, 1, 1], [4, 4, 8, 0, 4], [8, 2, 5, 0, 3]], "output": [[4, 4, 1, 1, 1, 1, 1, 1, 4, 4], [4, 4, 8, 0, 4, 4, 0, 8, 4, 4], [8, 2, 5, 0, 3, 3, 0, 5, 2, 8], [8, 2, 5, 0, 3, 3, 0, 5, 2, 8], [4, 4, 8, 0, 4, 4, 0, 8, 4, 4], [4, 4, 1, 1, 1, 1, 1, 1, 4, 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 4 1 1 1 1 1 1 4 4
4 4 8 0 4 4 0 8 4 4
8 2 5 0 3 3 0 5 2 8
8 2 5 0 3 3 0 5 2 8
4 4 8 0 4 4 0 8 4 4
4 4 1 1 1 1 1 1 4 4
``` | 1,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... | 4,264 | [
"<note1>\n<description>Look first at the overall grid dimensions: many tasks change size by an integer factor. If each output dimension is an integer multiple of the input dimension, the transformation is likely a uniform scaling (each input cell becomes a k×k block).</description>\n<example>For instance, if an inp... | [{"input": [[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, 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, 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], [7, ... | [{"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, 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, 1, 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, 0, 1, 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 1 1 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 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0
0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0
0 0 0 0 1 1 0 0 1 1 0 0 0 0 1 1 0 0 1 1 0 0 0 0
0 0 0 0 1 1 0 0 1 1 0 0 0 0 1 1 0 0 1 1 0 0 0 0
1 1 1 1 1 1 0 0 1 1 1 1 0 0 ... | 3,560 |
<|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,718 | [
"<note1>\n<description>Identify the anchor object: find the single connected component that has a unique color and a compact rectangular bounding box. That component is the reference for the transformation and is usually unchanged except for a single pixel added to its corner.</description>\n<example>Imagine a smal... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 2, 2, 2, 0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0], [0, 2, 2, 2, 0, 0, 0, 4, 4, 4, 4, 4, 4, 0, 0], [0, 2, 2, 2, 0, 0, 0, 4, 0, 4, 4, 0, 4, 0, 0], [2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0... | [{"input": [[8, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0], [8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0], [8, 8, 8, 8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0], [8, 0, 0, 0, 0, 8, 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, 8, 8, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 8, 8, 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 0 0 0 0 8 0 0 0 0 0 0 0 0
8 8 8 8 8 8 0 0 0 0 0 0 0 0
8 8 8 8 8 8 0 0 0 0 0 0 0 0
8 0 0 0 0 8 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 8 3 0 0 0 0
0 0 0 0 0 0 0 3 8 8 0 0 0 0
0 0 0 0 0 0 0 3 3 3 0 0 0 0
0 0 0 3 0 8 8 0 0 0 0 0 0 0
0 0 3 3 8 3 3 3 0 0 0 0 0 0
0 0 3 0 0 0 0 3 0 0 0 0 0 0
0 0 3 0 ... | 3,014 |
<|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,908 | [
"<note1>\n<description>Find the background and the special color(s): the background is the most frequent color and the special color(s) are the rare colors that act as the seeds for the transformation. Identifying these roles tells you which pixels are candidates for being expanded or copied.</description>\n<exampl... | [{"input": [[1, 1, 1, 1, 1, 1, 1, 1, 3, 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, 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, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], "output": [[1, 1, 1... | [{"input": [[8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 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, 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,... | 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 0 8 8 8
8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 0 8 0 8 8
8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 0 8 8 8
8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 0 8 0 8 8
8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 0 8 8 8
8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 0 8 0 8 8
8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 0 ... | 2,204 |
<|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>Look for a single color that acts as an \"anchor\": it appears repeatedly in the same relative positions across the grid. When one color occupies the same coordinates in input and output, it is usually the fixed reference for the transformation.</description>\n<example>Imagine a grid where co... | [{"input": [[7, 6, 4, 6, 9, 8, 5, 6, 7, 9, 3, 3], [7, 7, 9, 7, 5, 7, 1, 6, 3, 8, 3, 4], [8, 2, 7, 7, 3, 7, 1, 3, 3, 3, 3, 3], [4, 5, 9, 8, 9, 7, 4, 4, 3, 7, 3, 5], [6, 6, 8, 5, 9, 1, 8, 8, 4, 4, 5, 4], [6, 1, 3, 8, 9, 8, 1, 4, 2, 5, 6, 7], [2, 9, 2, 9, 2, 8, 8, 7, 6, 2, 7, 9], [1, 9, 5, 6, 1, 1, 4, 8, 1, 1, 7, 8]], "ou... | [{"input": [[6, 5, 3, 6, 9, 7, 9, 1, 6], [5, 6, 5, 6, 7, 7, 7, 6, 6], [6, 8, 9, 4, 1, 7, 7, 6, 5], [1, 2, 6, 9, 2, 8, 7, 1, 7], [4, 8, 3, 5, 7, 2, 6, 3, 3], [9, 7, 8, 8, 4, 1, 3, 2, 8], [8, 9, 7, 9, 4, 1, 6, 1, 4], [5, 5, 2, 8, 1, 2, 4, 7, 1], [5, 8, 7, 3, 8, 3, 6, 2, 4]], "output": [[6, 5, 3, 6, 9, 7, 9, 1, 6], [5, 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 5 3 6 9 7 9 1 6
5 6 5 6 7 4 7 6 6
6 8 9 4 1 7 7 6 5
1 2 6 9 2 8 7 1 7
4 8 3 5 7 2 6 3 3
9 7 8 8 4 1 3 2 8
8 9 7 9 4 1 6 1 4
5 5 2 8 1 2 4 7 1
5 8 7 3 8 3 6 2 4
``` | 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... | 4,157 | [
"<note1>\n<description>Find the background by frequency: the color that fills most of the grid is usually the canvas. Isolating that dominant color reduces the problem to a few smaller objects on a uniform field.</description>\n<example>Imagine a grid where one color appears in over 90% of cells and a few other col... | [{"input": [[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, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 1, 3, 3, 1], [1, 1, 1, 2, 2, 2, 2, 2, 1, 1, 1, 3, 1, 1, 1, 3, 1], [1, 1, 1, 2, 1, 2, 1, 2, 1, 1, 1, 3, 3, 3, 3, 3, 1], [1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 3, ... | [{"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, 1, 3, 1, 1, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 3, 1, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 3, 1, 1, 3, 3, 3, 3, 3], [3, 3, 3, 6, 3, 3, 3, 3, 3, ... | 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 6 3
6 6 6
3 6 3
6 6 6
``` | 3,453 |
<|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,648 | [
"<note1>\n<description>Look for the smallest rectangle that contains every non-background pixel of the target color; that rectangle is the natural candidate for the output shape. This reduces the problem to analyzing a compact block rather than the whole grid.</description>\n<example>Imagine a grid with many scatte... | [{"input": [[0, 0, 4, 0, 0, 0, 0, 4, 4], [0, 0, 0, 4, 4, 0, 0, 4, 4], [0, 0, 4, 4, 4, 0, 0, 0, 0], [4, 4, 0, 0, 0, 0, 0, 0, 0], [4, 4, 4, 4, 4, 0, 4, 4, 0], [0, 0, 0, 4, 4, 0, 4, 4, 0], [0, 0, 0, 0, 0, 4, 0, 0, 0], [0, 0, 0, 4, 4, 0, 0, 0, 0], [0, 0, 0, 4, 4, 0, 0, 4, 0]], "output": [[4], [4], [4], [4], [4]]}, {"input"... | [{"input": [[0, 0, 0, 0, 0, 0, 0, 0, 0], [4, 4, 0, 0, 0, 4, 0, 4, 4], [4, 4, 0, 0, 4, 4, 0, 4, 4], [0, 0, 0, 0, 4, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 4, 4, 0, 0, 0], [0, 0, 4, 0, 4, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]], "output": [[4], [4], [4], [4], [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... | ```
4
4
4
4
0
``` | 944 |
<|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,252 | [
"<note1>\n<description>Look for the color that forms the single largest connected component (by pixel count). The transformation usually isolates that dominant object rather than a small isolated pixel or a tiny cluster.</description>\n<example>Imagine a grid mostly filled with color A, with a single large blob of ... | [{"input": [[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, 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, 9, 9, 9, 9, 9, 9], [9, 9, 9, 9, 5, 9, 5, 9, 9, 9, 9, 9], [9, 9, 9, 9, 9, 5, 5, 9, 9, 9, 9, 9], [9, 9, 9, 9, 5, 5, 9, 9, 9, 9, 9, 9], [9, ... | [{"input": [[3, 3, 3, 3, 3, 6, 6, 3, 6, 6, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 3, 3, 3, 3, 3, 3, 0, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 3, 3, 0], [3, 8, 3, 8, 3, 3, 3, 3, 3, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3], [3, 3, 8, 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 3 3 1
3 1 1 3
3 1 1 3
``` | 3,548 |
<|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,620 | [
"<note1>\n<description>Look for a small, repeated motif: many ARC tasks contain one or more tiny 3×3 patterns that share the same internal arrangement of filled pixels (a hollow square or ring). Recognizing that motif is the first step because the transformation usually targets that motif rather than individual pix... | [{"input": [[0, 6, 6, 6, 0, 0, 0, 0], [0, 6, 0, 6, 0, 0, 0, 0], [0, 0, 0, 0, 0, 6, 6, 6], [0, 0, 0, 0, 0, 6, 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": [[0, 6, 6, 6, 0, 0, 0, 0], [0, 6, 0, 6, 0, 0, 0, 0], [0, 0, 0, 0, 0, 6, 6, 6], [0, 0, 0, ... | [{"input": [[0, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0], [0, 5, 0, 5, 0, 8, 8, 8, 0, 0, 0], [0, 0, 0, 0, 0, 8, 0, 8, 3, 3, 3], [0, 0, 0, 0, 0, 0, 0, 0, 3, 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]], "output": [[0, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0], [0, 5, 0, 5, 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 5 5 5 0 0 0 0 0 0 0
0 5 0 5 0 8 8 8 0 0 0
0 0 0 0 0 8 0 8 3 3 3
0 0 0 0 0 0 0 0 3 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 4 0 0 0 4 0 0 4 0
``` | 916 |
<|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,552 | [
"<note1>\n<description>Look for a single horizontal band that contains all non-black pixels: many ARC tasks use a bottom row (or a contiguous horizontal stripe) as the source pattern. Isolating that band simplifies the rest of the transformation because the rest of the grid is treated as background.</description>\n... | [{"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], [6, 1, 0, 6, 0, 0, 6, 5, 5]], "output": [[5, 0, 0, 0, 0, 0, 0, 0, 6], [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], [1, 7, 6, 3, 9, 0, 0]], "output": [[0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0], [9, 0, 0, 0, 1, 7, 6], [0, 0, 0, 0, 0, 0, 0], [6, 3, 9, 7, 6, 3, 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 1
0 0 0 0 0 0 0
9 0 0 0 1 7 6
0 0 0 0 0 0 0
6 3 9 7 6 3 9
0 0 0 0 0 0 0
1 7 6 3 9 0 0
``` | 1,848 |
<|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 locating the single non-background pixel in the input and treat it as the anchor of the transformation. Its row and column index determine where any new structure will be placed relative to the grid.</description>\n<example>Imagine a 7×7 grid with one blue pixel at (row 3, column 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, 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]], "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, ... | [{"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, 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]], "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 0 0 0 0 0
0 0 0 0 5 6 6 6 6
0 0 0 0 6 0 0 0 0
0 0 0 0 6 0 0 0 0
0 0 0 0 6 0 0 0 0
0 0 0 0 6 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,162 | [
"<note1>\n<description>Isolate the object by finding the minimal bounding box that contains every non-background pixel. This box captures the object's shape and relative layout without extra background noise.</description>\n<example>Imagine a small 5×5 grid with a 3×3 colored blob somewhere inside. Crop to the smal... | [{"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, 6, 6, 6, 0, 0, 0, 0], [0, 0, 6, 6, 6, 6, 6, 0, 0, 0], [0, 0, 0, 6, 6, 6, 0, 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... | [{"input": [[0, 0, 0, 0, 0, 0], [0, 0, 6, 0, 0, 0], [0, 6, 6, 6, 0, 0], [0, 0, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]], "output": [[0, 6, 0, 0, 6, 0], [6, 6, 6, 6, 6, 6], [0, 6, 0, 0, 6, 0], [0, 6, 0, 0, 6, 0], [6, 6, 6, 6, 6, 6], [0, 6, 0, 0, 6, 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 6 0 0 6 0
6 6 6 6 6 6
0 6 0 0 6 0
0 6 0 0 6 0
6 6 6 6 6 6
0 6 0 0 6 0
``` | 1,458 |
<|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,842 | [
"<note1>\n<description>First isolate the active objects: the background is the color that fills most of the grid, and the transformation only touches small contiguous clusters of other colors. Focusing on those clusters reduces the problem to a few local rules instead of the whole grid.</description>\n<example>Imag... | [{"input": [[3, 3, 3, 3, 3, 3, 3, 4, 3, 3], [4, 3, 3, 3, 3, 4, 3, 3, 8, 3], [3, 8, 3, 3, 8, 3, 3, 3, 3, 3], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3], [3, 3, 3, 3, 8, 8, 8, 3, 4, 3], [3, 3, 3, 3, 8, 8, 8, 3, 3, 8], [3, 3, 3, 3, 8, 8, 8, 3, 3, 3], [3, 4, 4, 4, 3, 3, 3, 3, 9, 4], [3, 4, 4, 4, 3, 3, 3, 3, 8, 9], [3, 4, 4, 4, 3, 3, 3... | [{"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, 4, 4, 8, 8, 8, 8, 8, 8], [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 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,... | 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 8 8 6 6 6 6 6 6 4 4 8 8 8 8 8 8
8 8 8 8 8 8 8 8 6 6 6 6 6 6 4 4 8 8 8 8 8 8
8 8 8 8 8 8 8 8 6 6 8 8 8 8 6 6 8 8 8 8 8 8
8 8 8 8 8 8 8 8 6 6 8 8 8 8 6 6 8 8 0 6 6 6
8 8 8 8 8 8 8 8 6 6 6 6 8 8 6 6 8 8 6 6 8 6
8 8 8 8 8 8 8 8 6 6 6 6 8 8 6 6 8 8 6 8 8 6
8 8 8 0 ... | 3,138 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.