{
  "id": "arrays/2d-arrays",
  "version": 1,
  "deterministic": true,
  "url": "/dsa/arrays/2d-arrays",
  "topic": {
    "slug": "arrays",
    "title": "Arrays"
  },
  "title": "2D Arrays",
  "tagline": "The grid is a fiction. Memory is one flat line — and that's why row-major is fast.",
  "vizKind": "grid",
  "complexity": {
    "time": {
      "best": "O(1) to read a cell",
      "average": "O(r × c) to scan",
      "worst": "O(r × c)"
    },
    "space": "O(r × c)",
    "growth": "quadratic",
    "note": "Reading a[r][c] is O(1) — one multiply, one add, one jump. Scanning it all is O(rows × cols), which for a square grid is n². The row-major-versus-column-major difference doesn't change the Big-O at all, and can still make your code several times slower."
  },
  "code": {
    "javascript": "// A 2D array is a lie. Memory is flat — it's one long row.\nconst ROWS = 4, COLS = 5;\nconst flat = new Array(ROWS * COLS);\n\n// The computer turns (r, c) into a single index:\nfunction at(r, c) {\n  return r * COLS + c;        // row-major order\n}\n\n// So a[2][3] really means flat[2 * 5 + 3] = flat[13].\n\n// Walking it row by row is fast (memory is read in order):\nfor (let r = 0; r < ROWS; r++) {\n  for (let c = 0; c < COLS; c++) {\n    visit(flat[at(r, c)]);\n  }\n}",
    "python": "# A 2D array is a lie. Memory is flat — it's one long row.\nROWS, COLS = 4, 5\nflat = [0] * (ROWS * COLS)\n\n# Python turns (r, c) into a single index:\ndef at(r, c):\n    return r * COLS + c          # row-major order\n\n\n# So a[2][3] really means flat[2 * 5 + 3] = flat[13].\n\n# Walking it row by row is fast (memory is read in order):\nfor r in range(ROWS):\n    for c in range(COLS):\n        visit(flat[at(r, c)])\n",
    "java": "// A 2D array is a lie. Memory is flat — it's one long row.\nfinal int ROWS = 4, COLS = 5;\nint[] flat = new int[ROWS * COLS];\n\n// The computer turns (r, c) into a single index:\nint at(int r, int c) {\n  return r * COLS + c;        // row-major order\n}\n\n// So a[2][3] really means flat[2 * 5 + 3] = flat[13].\n\n// Walking it row by row is fast (memory is read in order):\nfor (int r = 0; r < ROWS; r++) {\n  for (int c = 0; c < COLS; c++) {\n    visit(flat[at(r, c)]);\n  }\n}",
    "cpp": "// A 2D array is a lie. Memory is flat — it's one long row.\nconst int ROWS = 4, COLS = 5;\nvector<int> flat(ROWS * COLS);\n\n// The computer turns (r, c) into a single index:\nint at(int r, int c) {\n  return r * COLS + c;        // row-major order\n}\n\n// So a[2][3] really means flat[2 * 5 + 3] = flat[13].\n\n// Walking it row by row is fast (memory is read in order):\nfor (int r = 0; r < ROWS; r++) {\n  for (int c = 0; c < COLS; c++) {\n    visit(flat[at(r, c)]);\n  }\n}"
  },
  "defaultInput": [
    1
  ],
  "defaultTarget": null,
  "inputHint": "Watch each (row, col) become one flat index: r × 5 + c.",
  "pitfalls": [
    {
      "wrong": "Mixing up a[row][col] and a[col][row].",
      "right": "The single most common bug in grid code. Fix a convention — row first, always — and never deviate. Half of all 'my matrix is transposed' bugs are this."
    },
    {
      "wrong": "Walking column by column on a big grid.",
      "right": "Same Big-O, several times slower in reality, because each step jumps past the cached memory. Prefer row-major order — read memory the way it's laid out."
    },
    {
      "wrong": "Creating rows that all point at the same array.",
      "right": "In several languages, filling a grid with a shared row reference means writing to one row writes to all of them. Build each row separately."
    }
  ],
  "quiz": [
    {
      "q": "How does the computer find a[2][3] in a grid with 5 columns?",
      "options": [
        "It searches row by row",
        "It computes 2 × 5 + 3 = 13 and jumps to flat[13]",
        "It follows pointers between rows",
        "It uses a hash table"
      ],
      "answer": 1,
      "why": "row × COLS + col. One multiply, one add, one jump — O(1), exactly like a 1D array. The grid is arithmetic, not structure."
    },
    {
      "q": "Why is walking a grid row by row faster than column by column?",
      "options": [
        "It does fewer operations",
        "It reads memory in order, so the CPU cache serves the next value; column-major jumps past cached data",
        "Rows are shorter than columns",
        "It isn't faster"
      ],
      "answer": 1,
      "why": "Both do exactly the same number of operations and have the same Big-O. Row-major reads memory in a straight line and the cache keeps up; column-major leaps COLS positions each step and keeps missing."
    },
    {
      "q": "What does this lesson teach about Big-O?",
      "options": [
        "Big-O is always the whole story",
        "Two algorithms with the same Big-O can still differ several-fold in real speed",
        "Big-O only applies to sorting",
        "Cache behaviour changes the Big-O"
      ],
      "answer": 1,
      "why": "Row-major and column-major are both O(r × c) and one is materially faster. Big-O tells you how cost *grows*, not how fast something actually runs."
    }
  ],
  "problems": [
    {
      "name": "Rotate Image",
      "difficulty": "Medium",
      "url": "https://leetcode.com/problems/rotate-image/"
    },
    {
      "name": "Spiral Matrix",
      "difficulty": "Medium",
      "url": "https://leetcode.com/problems/spiral-matrix/"
    },
    {
      "name": "Set Matrix Zeroes",
      "difficulty": "Medium",
      "url": "https://leetcode.com/problems/set-matrix-zeroes/"
    },
    {
      "name": "Number of Islands",
      "difficulty": "Medium",
      "url": "https://leetcode.com/problems/number-of-islands/"
    }
  ],
  "trace": {
    "note": "Each frame is one immutable step: data snapshot, pointers, per-index roles, executing code line, and a one-sentence explanation.",
    "length": 23,
    "frames": [
      {
        "data": {
          "cells": [
            [
              {
                "value": 0
              },
              {
                "value": 1
              },
              {
                "value": 2
              },
              {
                "value": 3
              },
              {
                "value": 4
              }
            ],
            [
              {
                "value": 5
              },
              {
                "value": 6
              },
              {
                "value": 7
              },
              {
                "value": 8
              },
              {
                "value": 9
              }
            ],
            [
              {
                "value": 10
              },
              {
                "value": 11
              },
              {
                "value": 12
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "4 × 5 — but memory is one flat line of 20"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 2,
        "variables": {
          "rows": 4,
          "cols": 5,
          "cells": 20
        },
        "explanation": "A 2D array looks like a grid. It isn't. Memory is one long line — the grid is a fiction, and the computer keeps it up with a single piece of arithmetic.",
        "stats": {
          "comparisons": 0,
          "swaps": 0
        },
        "accent": "active"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0
              },
              {
                "value": 1
              },
              {
                "value": 2
              },
              {
                "value": 3
              },
              {
                "value": 4
              }
            ],
            [
              {
                "value": 5
              },
              {
                "value": 6
              },
              {
                "value": 7
              },
              {
                "value": 8
              },
              {
                "value": 9
              }
            ],
            [
              {
                "value": 10
              },
              {
                "value": 11
              },
              {
                "value": 12
              },
              {
                "value": 13,
                "role": "active"
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "a[2][3] → flat[2 × 5 + 3] → flat[13]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 7,
        "variables": {
          "row": 2,
          "col": 3,
          "flatIndex": 13
        },
        "explanation": "Ask for a[2][3] and the computer works out row × 5 + col = 2 × 5 + 3 = 13, then jumps straight to that one spot in the flat line. It's the same O(1) jump as a 1D array — just with one multiplication first.",
        "stats": {
          "comparisons": 0,
          "swaps": 0
        },
        "accent": "pivot"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "active"
              },
              {
                "value": 1
              },
              {
                "value": 2
              },
              {
                "value": 3
              },
              {
                "value": 4
              }
            ],
            [
              {
                "value": 5
              },
              {
                "value": 6
              },
              {
                "value": 7
              },
              {
                "value": 8
              },
              {
                "value": 9
              }
            ],
            [
              {
                "value": 10
              },
              {
                "value": 11
              },
              {
                "value": 12
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 0, col 0 → flat[0]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 0,
          "c": 0,
          "flatIndex": 0,
          "value": 0
        },
        "explanation": "Starting row 0. Walking left-to-right means we read flat[0], flat[1], flat[2]… — straight down the memory line, in order.",
        "stats": {
          "comparisons": 1,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "active"
              },
              {
                "value": 2
              },
              {
                "value": 3
              },
              {
                "value": 4
              }
            ],
            [
              {
                "value": 5
              },
              {
                "value": 6
              },
              {
                "value": 7
              },
              {
                "value": 8
              },
              {
                "value": 9
              }
            ],
            [
              {
                "value": 10
              },
              {
                "value": 11
              },
              {
                "value": 12
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 0, col 1 → flat[1]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 0,
          "c": 1,
          "flatIndex": 1,
          "value": 1
        },
        "explanation": "(0, 1) is flat[1], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 2,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "active"
              },
              {
                "value": 3
              },
              {
                "value": 4
              }
            ],
            [
              {
                "value": 5
              },
              {
                "value": 6
              },
              {
                "value": 7
              },
              {
                "value": 8
              },
              {
                "value": 9
              }
            ],
            [
              {
                "value": 10
              },
              {
                "value": 11
              },
              {
                "value": 12
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 0, col 2 → flat[2]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 0,
          "c": 2,
          "flatIndex": 2,
          "value": 2
        },
        "explanation": "(0, 2) is flat[2], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 3,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "active"
              },
              {
                "value": 4
              }
            ],
            [
              {
                "value": 5
              },
              {
                "value": 6
              },
              {
                "value": 7
              },
              {
                "value": 8
              },
              {
                "value": 9
              }
            ],
            [
              {
                "value": 10
              },
              {
                "value": 11
              },
              {
                "value": 12
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 0, col 3 → flat[3]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 0,
          "c": 3,
          "flatIndex": 3,
          "value": 3
        },
        "explanation": "(0, 3) is flat[3], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 4,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "active"
              }
            ],
            [
              {
                "value": 5
              },
              {
                "value": 6
              },
              {
                "value": 7
              },
              {
                "value": 8
              },
              {
                "value": 9
              }
            ],
            [
              {
                "value": 10
              },
              {
                "value": 11
              },
              {
                "value": 12
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 0, col 4 → flat[4]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 0,
          "c": 4,
          "flatIndex": 4,
          "value": 4
        },
        "explanation": "(0, 4) is flat[4], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 5,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "active"
              },
              {
                "value": 6
              },
              {
                "value": 7
              },
              {
                "value": 8
              },
              {
                "value": 9
              }
            ],
            [
              {
                "value": 10
              },
              {
                "value": 11
              },
              {
                "value": 12
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 1, col 0 → flat[5]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 1,
          "c": 0,
          "flatIndex": 5,
          "value": 5
        },
        "explanation": "Starting row 1. Walking left-to-right means we read flat[5], flat[6], flat[7]… — straight down the memory line, in order.",
        "stats": {
          "comparisons": 6,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "active"
              },
              {
                "value": 7
              },
              {
                "value": 8
              },
              {
                "value": 9
              }
            ],
            [
              {
                "value": 10
              },
              {
                "value": 11
              },
              {
                "value": 12
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 1, col 1 → flat[6]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 1,
          "c": 1,
          "flatIndex": 6,
          "value": 6
        },
        "explanation": "(1, 1) is flat[6], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 7,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "active"
              },
              {
                "value": 8
              },
              {
                "value": 9
              }
            ],
            [
              {
                "value": 10
              },
              {
                "value": 11
              },
              {
                "value": 12
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 1, col 2 → flat[7]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 1,
          "c": 2,
          "flatIndex": 7,
          "value": 7
        },
        "explanation": "(1, 2) is flat[7], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 8,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "sorted"
              },
              {
                "value": 8,
                "role": "active"
              },
              {
                "value": 9
              }
            ],
            [
              {
                "value": 10
              },
              {
                "value": 11
              },
              {
                "value": 12
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 1, col 3 → flat[8]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 1,
          "c": 3,
          "flatIndex": 8,
          "value": 8
        },
        "explanation": "(1, 3) is flat[8], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 9,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "sorted"
              },
              {
                "value": 8,
                "role": "sorted"
              },
              {
                "value": 9,
                "role": "active"
              }
            ],
            [
              {
                "value": 10
              },
              {
                "value": 11
              },
              {
                "value": 12
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 1, col 4 → flat[9]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 1,
          "c": 4,
          "flatIndex": 9,
          "value": 9
        },
        "explanation": "(1, 4) is flat[9], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 10,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "sorted"
              },
              {
                "value": 8,
                "role": "sorted"
              },
              {
                "value": 9,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 10,
                "role": "active"
              },
              {
                "value": 11
              },
              {
                "value": 12
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 2, col 0 → flat[10]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 2,
          "c": 0,
          "flatIndex": 10,
          "value": 10
        },
        "explanation": "Starting row 2. Walking left-to-right means we read flat[10], flat[11], flat[12]… — straight down the memory line, in order.",
        "stats": {
          "comparisons": 11,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "sorted"
              },
              {
                "value": 8,
                "role": "sorted"
              },
              {
                "value": 9,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 10,
                "role": "sorted"
              },
              {
                "value": 11,
                "role": "active"
              },
              {
                "value": 12
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 2, col 1 → flat[11]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 2,
          "c": 1,
          "flatIndex": 11,
          "value": 11
        },
        "explanation": "(2, 1) is flat[11], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 12,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "sorted"
              },
              {
                "value": 8,
                "role": "sorted"
              },
              {
                "value": 9,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 10,
                "role": "sorted"
              },
              {
                "value": 11,
                "role": "sorted"
              },
              {
                "value": 12,
                "role": "active"
              },
              {
                "value": 13
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 2, col 2 → flat[12]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 2,
          "c": 2,
          "flatIndex": 12,
          "value": 12
        },
        "explanation": "(2, 2) is flat[12], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 13,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "sorted"
              },
              {
                "value": 8,
                "role": "sorted"
              },
              {
                "value": 9,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 10,
                "role": "sorted"
              },
              {
                "value": 11,
                "role": "sorted"
              },
              {
                "value": 12,
                "role": "sorted"
              },
              {
                "value": 13,
                "role": "active"
              },
              {
                "value": 14
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 2, col 3 → flat[13]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 2,
          "c": 3,
          "flatIndex": 13,
          "value": 13
        },
        "explanation": "(2, 3) is flat[13], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 14,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "sorted"
              },
              {
                "value": 8,
                "role": "sorted"
              },
              {
                "value": 9,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 10,
                "role": "sorted"
              },
              {
                "value": 11,
                "role": "sorted"
              },
              {
                "value": 12,
                "role": "sorted"
              },
              {
                "value": 13,
                "role": "sorted"
              },
              {
                "value": 14,
                "role": "active"
              }
            ],
            [
              {
                "value": 15
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 2, col 4 → flat[14]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 2,
          "c": 4,
          "flatIndex": 14,
          "value": 14
        },
        "explanation": "(2, 4) is flat[14], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 15,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "sorted"
              },
              {
                "value": 8,
                "role": "sorted"
              },
              {
                "value": 9,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 10,
                "role": "sorted"
              },
              {
                "value": 11,
                "role": "sorted"
              },
              {
                "value": 12,
                "role": "sorted"
              },
              {
                "value": 13,
                "role": "sorted"
              },
              {
                "value": 14,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 15,
                "role": "active"
              },
              {
                "value": 16
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 3, col 0 → flat[15]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 3,
          "c": 0,
          "flatIndex": 15,
          "value": 15
        },
        "explanation": "Starting row 3. Walking left-to-right means we read flat[15], flat[16], flat[17]… — straight down the memory line, in order.",
        "stats": {
          "comparisons": 16,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "sorted"
              },
              {
                "value": 8,
                "role": "sorted"
              },
              {
                "value": 9,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 10,
                "role": "sorted"
              },
              {
                "value": 11,
                "role": "sorted"
              },
              {
                "value": 12,
                "role": "sorted"
              },
              {
                "value": 13,
                "role": "sorted"
              },
              {
                "value": 14,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 15,
                "role": "sorted"
              },
              {
                "value": 16,
                "role": "active"
              },
              {
                "value": 17
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 3, col 1 → flat[16]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 3,
          "c": 1,
          "flatIndex": 16,
          "value": 16
        },
        "explanation": "(3, 1) is flat[16], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 17,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "sorted"
              },
              {
                "value": 8,
                "role": "sorted"
              },
              {
                "value": 9,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 10,
                "role": "sorted"
              },
              {
                "value": 11,
                "role": "sorted"
              },
              {
                "value": 12,
                "role": "sorted"
              },
              {
                "value": 13,
                "role": "sorted"
              },
              {
                "value": 14,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 15,
                "role": "sorted"
              },
              {
                "value": 16,
                "role": "sorted"
              },
              {
                "value": 17,
                "role": "active"
              },
              {
                "value": 18
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 3, col 2 → flat[17]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 3,
          "c": 2,
          "flatIndex": 17,
          "value": 17
        },
        "explanation": "(3, 2) is flat[17], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 18,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "sorted"
              },
              {
                "value": 8,
                "role": "sorted"
              },
              {
                "value": 9,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 10,
                "role": "sorted"
              },
              {
                "value": 11,
                "role": "sorted"
              },
              {
                "value": 12,
                "role": "sorted"
              },
              {
                "value": 13,
                "role": "sorted"
              },
              {
                "value": 14,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 15,
                "role": "sorted"
              },
              {
                "value": 16,
                "role": "sorted"
              },
              {
                "value": 17,
                "role": "sorted"
              },
              {
                "value": 18,
                "role": "active"
              },
              {
                "value": 19
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 3, col 3 → flat[18]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 3,
          "c": 3,
          "flatIndex": 18,
          "value": 18
        },
        "explanation": "(3, 3) is flat[18], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 19,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "sorted"
              },
              {
                "value": 8,
                "role": "sorted"
              },
              {
                "value": 9,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 10,
                "role": "sorted"
              },
              {
                "value": 11,
                "role": "sorted"
              },
              {
                "value": 12,
                "role": "sorted"
              },
              {
                "value": 13,
                "role": "sorted"
              },
              {
                "value": 14,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 15,
                "role": "sorted"
              },
              {
                "value": 16,
                "role": "sorted"
              },
              {
                "value": 17,
                "role": "sorted"
              },
              {
                "value": 18,
                "role": "sorted"
              },
              {
                "value": 19,
                "role": "active"
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "row 3, col 4 → flat[19]"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 15,
        "variables": {
          "r": 3,
          "c": 4,
          "flatIndex": 19,
          "value": 19
        },
        "explanation": "(3, 4) is flat[19], sitting right next to the last one. This is why row-by-row is fast: the CPU cache loads a chunk of memory and you use all of it.",
        "stats": {
          "comparisons": 20,
          "swaps": 0
        },
        "accent": "compare"
      },
      {
        "data": {
          "cells": [
            [
              {
                "value": 0,
                "role": "sorted"
              },
              {
                "value": 1,
                "role": "sorted"
              },
              {
                "value": 2,
                "role": "sorted"
              },
              {
                "value": 3,
                "role": "sorted"
              },
              {
                "value": 4,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 5,
                "role": "sorted"
              },
              {
                "value": 6,
                "role": "sorted"
              },
              {
                "value": 7,
                "role": "sorted"
              },
              {
                "value": 8,
                "role": "sorted"
              },
              {
                "value": 9,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 10,
                "role": "sorted"
              },
              {
                "value": 11,
                "role": "sorted"
              },
              {
                "value": 12,
                "role": "sorted"
              },
              {
                "value": 13,
                "role": "sorted"
              },
              {
                "value": 14,
                "role": "sorted"
              }
            ],
            [
              {
                "value": 15,
                "role": "sorted"
              },
              {
                "value": 16,
                "role": "sorted"
              },
              {
                "value": 17,
                "role": "sorted"
              },
              {
                "value": 18,
                "role": "sorted"
              },
              {
                "value": 19,
                "role": "sorted"
              }
            ]
          ],
          "rowLabels": [
            "r0",
            "r1",
            "r2",
            "r3"
          ],
          "colLabels": [
            "c0",
            "c1",
            "c2",
            "c3",
            "c4"
          ],
          "caption": "all 20 cells, in memory order"
        },
        "pointers": [],
        "highlights": [],
        "codeLine": 17,
        "variables": {
          "visited": 20
        },
        "explanation": "Done. Had we walked column by column instead, we'd have jumped 5 steps through memory each time — skipping past cached data and reloading constantly. Same work on paper; measurably slower in reality. That's what row-major means.",
        "stats": {
          "comparisons": 20,
          "swaps": 0
        },
        "accent": "sorted"
      }
    ]
  }
}