Hafta 2 — Bağlı Listeler, Diziler ve Matrisler¶

/* Week 2 -- Linked Lists, Arrays and Matrices
 * A fixed-capacity array with a running size: insert at an index k
 * (shifting the tail right, from the end backwards) and delete at an index
 * k (shifting the tail left). Matches the array-insert-delete.js animation.
 * The animation gives each preset its own #define CAP; this program keeps
 * one array big enough for every scenario (MAX_CAP) and tracks the
 * scenario's own capacity in the runtime variable `cap`, so insert_at and
 * delete_at are otherwise identical to the animation's code panel.
 * CEN207 Data Structures (formerly CE205)
 */
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

#define MAX_CAP 16
static int arr[MAX_CAP];
static int size;
static int cap;              /* this scenario's capacity, <= MAX_CAP */

/* insert v at index k; shifts arr[k..size-1] right, from the end backwards */
bool insert_at(int k, int v) {
    if (size == cap)
        return false;            /* full: overflow, nothing inserted */
    for (int i = size; i > k; i--)
        arr[i] = arr[i - 1];    /* shift right */
    arr[k] = v;
    size++;
    return true;
}

/* delete the value at index k; shifts arr[k+1..size-1] left */
bool delete_at(int k) {
    if (size == 0)
        return false;            /* empty: underflow, nothing to delete */
    for (int i = k; i < size - 1; i++)
        arr[i] = arr[i + 1];    /* shift left */
    size--;
    return true;
}

static void print_array(void) {
    printf("arr:");
    for (int i = 0; i < size; i++) printf(" %d", arr[i]);
    printf("  [size=%d cap=%d]\n", size, cap);
}

/* tokens: "iK:V" = insert_at(K, V); "dK" = delete_at(K) */
static void run_scenario(const char *label, int scenario_cap, const char *ops[], int n) {
    printf("-- %s --\n", label);
    size = 0;
    cap = scenario_cap;
    print_array();
    for (int i = 0; i < n; i++) {
        const char *op = ops[i];
        if (op[0] == 'i') {
            int k, v;
            sscanf(op + 1, "%d:%d", &k, &v);
            bool ok = insert_at(k, v);
            printf("insert_at(%d, %d): %s\n", k, v, ok ? "ok" : "overflow, rejected");
        } else {
            int k = atoi(op + 1);
            bool ok = delete_at(k);
            printf("delete_at(%d): %s\n", k, ok ? "ok" : "underflow, rejected");
        }
        print_array();
    }
    printf("\n");
}

int main(void) {
    /* normal: 16-capacity: 10 appends, an insert at the front, a middle and a front delete */
    const char *normal[] = {"i0:10", "i1:20", "i2:30", "i3:40", "i4:50", "i5:60", "i6:70", "i7:80", "i8:90", "i9:100", "i0:5", "d5", "d0"};
    run_scenario("normal: 16-capacity: 10 appends, an insert at the front, a middle and a front delete", 16, normal, 13);

    /* hard: 14-capacity: frequent front inserts, negative/duplicate values, mixed deletes */
    const char *hard[] = {"i0:7", "i1:-3", "i2:15", "i0:-3", "i4:22", "i5:-3", "i0:99", "i7:-40", "i8:100", "i9:-100", "d3", "i9:50", "i10:60", "i0:1000", "d0", "d5"};
    run_scenario("hard: 14-capacity: frequent front inserts, negative/duplicate values, mixed deletes", 14, hard, 16);

    /* edge: overflow: fill a 10-capacity array, then an insert is rejected */
    const char *overflow[] = {"i0:3", "i1:6", "i2:9", "i3:12", "i4:15", "i5:18", "i6:21", "i7:24", "i8:27", "i9:30", "i4:777", "i0:111", "d3", "i3:888"};
    run_scenario("edge: overflow: fill a 10-capacity array, then an insert is rejected", 10, overflow, 14);

    /* edge: underflow: delete from an empty array, then fill it and drain it completely */
    const char *delete_empty[] = {"d0", "i0:5", "i1:15", "i2:25", "i3:35", "i4:45", "i5:55", "i6:65", "i7:75", "i8:85", "i9:95",
                                   "d0", "d0", "d0", "d0", "d0", "d0", "d0", "d0", "d0", "d0", "d0"};
    run_scenario("edge: underflow: delete from an empty array, then fill it and drain it completely", 12, delete_empty, 22);

    return 0;
}

/* Week 2 -- Linked Lists, Arrays and Matrices
 * A fixed-capacity array with a running size: insert at an index k
 * (shifting the tail right, from the end backwards) and delete at an index
 * k (shifting the tail left). Matches the array-insert-delete.js animation.
 * The animation gives each preset its own capacity constant; this program
 * keeps one array big enough for every scenario (MAX_CAP) and tracks the
 * scenario's own capacity in the runtime field `cap`, so insertAt and
 * deleteAt are otherwise identical to the animation's code panel.
 * CEN207 Data Structures (formerly CE205)
 */
public class ArrayInsertDelete {
    static final int MAX_CAP = 16;
    static int[] arr = new int[MAX_CAP];
    static int size;
    static int cap;              // this scenario's capacity, <= MAX_CAP

    // insert v at index k; shifts arr[k..size-1] right, from the end backwards
    static boolean insertAt(int k, int v) {
        if (size == cap)
            return false;            // full: overflow, nothing inserted
        for (int i = size; i > k; i--)
            arr[i] = arr[i - 1];    // shift right
        arr[k] = v;
        size++;
        return true;
    }

    // delete the value at index k; shifts arr[k+1..size-1] left
    static boolean deleteAt(int k) {
        if (size == 0)
            return false;            // empty: underflow, nothing to delete
        for (int i = k; i < size - 1; i++)
            arr[i] = arr[i + 1];    // shift left
        size--;
        return true;
    }

    static void printArray() {
        StringBuilder sb = new StringBuilder("arr:");
        for (int i = 0; i < size; i++) sb.append(' ').append(arr[i]);
        sb.append("  [size=").append(size).append(" cap=").append(cap).append(']');
        System.out.println(sb);
    }

    // tokens: "iK:V" = insertAt(K, V); "dK" = deleteAt(K)
    static void runScenario(String label, int scenarioCap, String[] ops) {
        System.out.println("-- " + label + " --");
        size = 0;
        cap = scenarioCap;
        printArray();
        for (String op : ops) {
            if (op.charAt(0) == 'i') {
                String[] parts = op.substring(1).split(":");
                int k = Integer.parseInt(parts[0]), v = Integer.parseInt(parts[1]);
                boolean ok = insertAt(k, v);
                System.out.println("insert_at(" + k + ", " + v + "): " + (ok ? "ok" : "overflow, rejected"));
            } else {
                int k = Integer.parseInt(op.substring(1));
                boolean ok = deleteAt(k);
                System.out.println("delete_at(" + k + "): " + (ok ? "ok" : "underflow, rejected"));
            }
            printArray();
        }
        System.out.println();
    }

    public static void main(String[] args) {
        // normal: 16-capacity: 10 appends, an insert at the front, a middle and a front delete
        String[] normal = {"i0:10", "i1:20", "i2:30", "i3:40", "i4:50", "i5:60", "i6:70", "i7:80", "i8:90", "i9:100", "i0:5", "d5", "d0"};
        runScenario("normal: 16-capacity: 10 appends, an insert at the front, a middle and a front delete", 16, normal);

        // hard: 14-capacity: frequent front inserts, negative/duplicate values, mixed deletes
        String[] hard = {"i0:7", "i1:-3", "i2:15", "i0:-3", "i4:22", "i5:-3", "i0:99", "i7:-40", "i8:100", "i9:-100", "d3", "i9:50", "i10:60", "i0:1000", "d0", "d5"};
        runScenario("hard: 14-capacity: frequent front inserts, negative/duplicate values, mixed deletes", 14, hard);

        // edge: overflow: fill a 10-capacity array, then an insert is rejected
        String[] overflow = {"i0:3", "i1:6", "i2:9", "i3:12", "i4:15", "i5:18", "i6:21", "i7:24", "i8:27", "i9:30", "i4:777", "i0:111", "d3", "i3:888"};
        runScenario("edge: overflow: fill a 10-capacity array, then an insert is rejected", 10, overflow);

        // edge: underflow: delete from an empty array, then fill it and drain it completely
        String[] deleteEmpty = {"d0", "i0:5", "i1:15", "i2:25", "i3:35", "i4:45", "i5:55", "i6:65", "i7:75", "i8:85", "i9:95",
                                 "d0", "d0", "d0", "d0", "d0", "d0", "d0", "d0", "d0", "d0", "d0"};
        runScenario("edge: underflow: delete from an empty array, then fill it and drain it completely", 12, deleteEmpty);
    }
}

/* Week 2 -- Linked Lists, Arrays and Matrices
 * A dynamic array: append n values into a block that starts tiny and grows
 * by a factor whenever it is full; count every element copy to show why
 * appending is amortized O(1) even though a single growing append is
 * O(n). Matches the dynamic-array-growth.js animation. The animation bakes
 * cap0/factor/shrink into the source text per preset; this program keeps
 * them as runtime globals set per scenario, so da_resize/da_append/
 * da_remove_last are otherwise identical to the animation's code panel.
 * CEN207 Data Structures (formerly CE205)
 */
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int *data;
    int size;
    int cap;
} DynArray;

static double factor;   /* growth factor, e.g. 2 or 1.5 */
static int cap0;        /* starting capacity, for the shrink floor */
static int shrink_on;   /* whether da_remove_last shrinks at all */
static int copies;      /* total elements copied by resizes, this scenario */
static int growths, shrinks;

static void da_resize(DynArray *a, int new_cap) {
    int *fresh = malloc(new_cap * sizeof(int));
    for (int i = 0; i < a->size; i++)
        fresh[i] = a->data[i];      /* copy every element to the new block */
    copies += a->size;
    free(a->data);                  /* old block is freed */
    a->data = fresh;
    a->cap = new_cap;
}

void da_append(DynArray *a, int v) {
    if (a->size == a->cap) {
        int new_cap = (int)(a->cap * factor);   /* growth factor `factor` */
        if (new_cap <= a->cap) new_cap = a->cap + 1;
        da_resize(a, new_cap);       /* full: grow before writing */
        growths++;
    }
    a->data[a->size++] = v;
}

void da_remove_last(DynArray *a) {
    if (a->size == 0) return;
    a->size--;
    if (shrink_on && a->size <= a->cap / 4 && a->cap / 2 >= cap0) {
        da_resize(a, a->cap / 2);    /* quarter full: shrink to save memory */
        shrinks++;
    }
}

static void print_array(DynArray *a) {
    printf("arr:");
    for (int i = 0; i < a->size; i++) printf(" %d", a->data[i]);
    printf("  [size=%d cap=%d]\n", a->size, a->cap);
}

/* tokens: "aV" = da_append(V); "r" = da_remove_last() */
static void run_scenario(const char *label, int scenario_cap0, double scenario_factor, int scenario_shrink, const char *ops[], int n) {
    printf("-- %s --\n", label);
    cap0 = scenario_cap0;
    factor = scenario_factor;
    shrink_on = scenario_shrink;
    copies = 0; growths = 0; shrinks = 0;
    DynArray a;
    a.cap = cap0;
    a.size = 0;
    a.data = malloc((size_t) cap0 * sizeof(int));
    print_array(&a);
    for (int i = 0; i < n; i++) {
        const char *op = ops[i];
        if (op[0] == 'a') {
            int v = atoi(op + 1);
            da_append(&a, v);
            printf("da_append(%d)\n", v);
        } else {
            da_remove_last(&a);
            printf("da_remove_last()\n");
        }
        print_array(&a);
    }
    printf("growths=%d shrinks=%d copies=%d\n\n", growths, shrinks, copies);
    free(a.data);
}

int main(void) {
    /* normal: cap0=1, factor 2: 12 appends, total copies < 2n */
    const char *normal[] = {"a5", "a12", "a8", "a19", "a3", "a27", "a14", "a6", "a31", "a9", "a22", "a17"};
    run_scenario("normal: cap0=1, factor 2: 12 appends, total copies < 2n", 1, 2.0, 0, normal, 12);

    /* hard: cap0=2, factor 2: 14 appends with 2 removes in between (no shrinking) */
    const char *hard[] = {"a10", "a-4", "a21", "a7", "r", "a33", "a-15", "a2", "a40", "r", "a18", "a-9", "a25", "a11", "a6", "a29"};
    run_scenario("hard: cap0=2, factor 2: 14 appends with 2 removes in between (no shrinking)", 2, 2.0, 0, hard, 16);

    /* edge: growth factor 1.5 (instead of 2): more frequent, smaller growths */
    const char *factor15[] = {"a4", "a9", "a15", "a2", "a23", "a8", "a31", "a6", "a19", "a1", "a27", "a13"};
    run_scenario("edge: growth factor 1.5 (instead of 2): more frequent, smaller growths", 1, 1.5, 0, factor15, 12);

    /* edge: shrinking: capacity halves once the array is only a quarter full */
    const char *shrink_quarter[] = {"a3", "a8", "a15", "a1", "a22", "a9", "a30", "a4", "a17", "a6", "a25", "a11", "r", "r", "r", "r", "r", "r", "r", "r", "r"};
    run_scenario("edge: shrinking: capacity halves once the array is only a quarter full", 2, 2.0, 1, shrink_quarter, 21);

    return 0;
}

/* Week 2 -- Linked Lists, Arrays and Matrices
 * A dynamic array: append n values into a block that starts tiny and grows
 * by a factor whenever it is full; count every element copy to show why
 * appending is amortized O(1) even though a single growing append is
 * O(n). Matches the dynamic-array-growth.js animation. The animation bakes
 * cap0/factor/shrink into the source text per preset; this program keeps
 * them as runtime fields set per scenario, so resize/append/removeLast are
 * otherwise identical to the animation's code panel.
 * CEN207 Data Structures (formerly CE205)
 */
public class DynamicArrayGrowth {
    static class DynArray {
        int[] data;
        int size;
        int cap;
    }

    static double factor;   // growth factor, e.g. 2 or 1.5
    static int cap0;        // starting capacity, for the shrink floor
    static boolean shrinkOn; // whether removeLast shrinks at all
    static int copies;      // total elements copied by resizes, this scenario
    static int growths, shrinks;

    static void resize(DynArray a, int newCap) {
        int[] fresh = new int[newCap];
        for (int i = 0; i < a.size; i++)
            fresh[i] = a.data[i];        // copy every element to the new block
        copies += a.size;
        a.data = fresh;                  // old block is now garbage -- freed by the GC
        a.cap = newCap;
    }

    static void append(DynArray a, int v) {
        if (a.size == a.cap) {
            int newCap = (int) (a.cap * factor);   // growth factor `factor`
            if (newCap <= a.cap) newCap = a.cap + 1;
            resize(a, newCap);           // full: grow before writing
            growths++;
        }
        a.data[a.size++] = v;
    }

    static void removeLast(DynArray a) {
        if (a.size == 0) return;
        a.size--;
        if (shrinkOn && a.size <= a.cap / 4 && a.cap / 2 >= cap0) {
            resize(a, a.cap / 2);        // quarter full: shrink to save memory
            shrinks++;
        }
    }

    static void printArray(DynArray a) {
        StringBuilder sb = new StringBuilder("arr:");
        for (int i = 0; i < a.size; i++) sb.append(' ').append(a.data[i]);
        sb.append("  [size=").append(a.size).append(" cap=").append(a.cap).append(']');
        System.out.println(sb);
    }

    // tokens: "aV" = append(V); "r" = removeLast()
    static void runScenario(String label, int scenarioCap0, double scenarioFactor, boolean scenarioShrink, String[] ops) {
        System.out.println("-- " + label + " --");
        cap0 = scenarioCap0;
        factor = scenarioFactor;
        shrinkOn = scenarioShrink;
        copies = 0; growths = 0; shrinks = 0;
        DynArray a = new DynArray();
        a.cap = cap0;
        a.size = 0;
        a.data = new int[cap0];
        printArray(a);
        for (String op : ops) {
            if (op.charAt(0) == 'a') {
                int v = Integer.parseInt(op.substring(1));
                append(a, v);
                System.out.println("da_append(" + v + ")");
            } else {
                removeLast(a);
                System.out.println("da_remove_last()");
            }
            printArray(a);
        }
        System.out.println("growths=" + growths + " shrinks=" + shrinks + " copies=" + copies);
        System.out.println();
    }

    public static void main(String[] args) {
        // normal: cap0=1, factor 2: 12 appends, total copies < 2n
        String[] normal = {"a5", "a12", "a8", "a19", "a3", "a27", "a14", "a6", "a31", "a9", "a22", "a17"};
        runScenario("normal: cap0=1, factor 2: 12 appends, total copies < 2n", 1, 2.0, false, normal);

        // hard: cap0=2, factor 2: 14 appends with 2 removes in between (no shrinking)
        String[] hard = {"a10", "a-4", "a21", "a7", "r", "a33", "a-15", "a2", "a40", "r", "a18", "a-9", "a25", "a11", "a6", "a29"};
        runScenario("hard: cap0=2, factor 2: 14 appends with 2 removes in between (no shrinking)", 2, 2.0, false, hard);

        // edge: growth factor 1.5 (instead of 2): more frequent, smaller growths
        String[] factor15 = {"a4", "a9", "a15", "a2", "a23", "a8", "a31", "a6", "a19", "a1", "a27", "a13"};
        runScenario("edge: growth factor 1.5 (instead of 2): more frequent, smaller growths", 1, 1.5, false, factor15);

        // edge: shrinking: capacity halves once the array is only a quarter full
        String[] shrinkQuarter = {"a3", "a8", "a15", "a1", "a22", "a9", "a30", "a4", "a17", "a6", "a25", "a11", "r", "r", "r", "r", "r", "r", "r", "r", "r"};
        runScenario("edge: shrinking: capacity halves once the array is only a quarter full", 2, 2.0, true, shrinkQuarter);
    }
}

/* Week 2 -- Linked Lists, Arrays and Matrices
 * A 2D matrix is really flat, 1D memory underneath. Row-major storage
 * places mat[i][j] at word offset i*COLS+j (column-major: j*ROWS+i).
 * Matches the matrix-row-major.js animation. The animation bakes the
 * layout into the source text per preset; this program keeps a runtime
 * flag `row_major` so addr/traverse_row_major/traverse_col_major are
 * otherwise identical to the animation's code panel.
 * CEN207 Data Structures (formerly CE205)
 */
#include <stdio.h>

#define MAX_ROWS 4
#define MAX_COLS 5

static int rows, cols;
static int row_major;   /* 1 = row-major layout, 0 = column-major layout */

/* address of mat[i][j], counted in ints from the start of the array */
int addr(int i, int j) {
    return row_major ? i * cols + j : j * rows + i;
}

void traverse_row_major(int mat[MAX_ROWS][MAX_COLS]) {
    int prev = -1;
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++) {
            int a = addr(i, j);
            printf("  M[%d][%d]=%d addr=%d%s\n", i, j, mat[i][j], a,
                   prev < 0 ? "" : (a - prev == 1 ? " (adjacent)" : " (jump)"));
            prev = a;
        }
}

void traverse_col_major(int mat[MAX_ROWS][MAX_COLS]) {
    int prev = -1;
    for (int j = 0; j < cols; j++)
        for (int i = 0; i < rows; i++) {
            int a = addr(i, j);
            printf("  M[%d][%d]=%d addr=%d%s\n", i, j, mat[i][j], a,
                   prev < 0 ? "" : (a - prev == 1 ? " (adjacent)" : " (jump)"));
            prev = a;
        }
}

static void run_scenario(const char *label, int r, int c, int mat[MAX_ROWS][MAX_COLS], int layout_row_major, int traversal_row) {
    printf("-- %s --\n", label);
    rows = r; cols = c; row_major = layout_row_major;
    printf("layout=%s traversal=%s\n", row_major ? "row-major" : "column-major", traversal_row ? "row" : "column");
    if (traversal_row) traverse_row_major(mat); else traverse_col_major(mat);
    printf("\n");
}

int main(void) {
    /* normal: 3x4 row-major, row-by-row traversal: always adjacent */
    int normal[MAX_ROWS][MAX_COLS] = {{8, 16, 24, 32}, {40, 48, 56, 64}, {72, 80, 88, 96}};
    run_scenario("normal: 3x4 row-major, row-by-row traversal: always adjacent", 3, 4, normal, 1, 1);

    /* hard: 4x4 row-major, column-by-column traversal: a jump on every step */
    int hard[MAX_ROWS][MAX_COLS] = {{3, -7, 15, 22}, {9, -14, 31, 6}, {18, -2, 27, 11}, {5, -19, 33, 8}};
    run_scenario("hard: 4x4 row-major, column-by-column traversal: a jump on every step", 4, 4, hard, 1, 0);

    /* edge: 3x5 column-major, row-by-row traversal: jumpy */
    int col_row[MAX_ROWS][MAX_COLS] = {{4, 9, -3, 16, 21}, {7, -12, 25, 2, 18}, {-6, 14, 8, -20, 30}};
    run_scenario("edge: 3x5 column-major, row-by-row traversal: jumpy", 3, 5, col_row, 0, 1);

    /* edge: 3x4 column-major, column-by-column traversal: adjacent again */
    int col_col[MAX_ROWS][MAX_COLS] = {{2, 5, -8, 13}, {19, -4, 7, 22}, {10, -15, 26, 1}};
    run_scenario("edge: 3x4 column-major, column-by-column traversal: adjacent again", 3, 4, col_col, 0, 0);

    return 0;
}

/* Week 2 -- Linked Lists, Arrays and Matrices
 * A 2D matrix is really flat, 1D memory underneath. Row-major storage
 * places mat[i][j] at word offset i*COLS+j (column-major: j*ROWS+i).
 * Matches the matrix-row-major.js animation. The animation bakes the
 * layout into the source text per preset; this program keeps a runtime
 * flag `rowMajor` so addr/traverseRowMajor/traverseColMajor are otherwise
 * identical to the animation's code panel.
 * CEN207 Data Structures (formerly CE205)
 */
public class MatrixRowMajor {
    static int rows, cols;
    static boolean rowMajor;   // true = row-major layout, false = column-major layout

    // address of mat[i][j], counted in ints from the start of the array
    static int addr(int i, int j) {
        return rowMajor ? i * cols + j : j * rows + i;
    }

    static void traverseRowMajor(int[][] mat) {
        int prev = -1;
        for (int i = 0; i < rows; i++)
            for (int j = 0; j < cols; j++) {
                int a = addr(i, j);
                System.out.println("  M[" + i + "][" + j + "]=" + mat[i][j] + " addr=" + a
                        + (prev < 0 ? "" : (a - prev == 1 ? " (adjacent)" : " (jump)")));
                prev = a;
            }
    }

    static void traverseColMajor(int[][] mat) {
        int prev = -1;
        for (int j = 0; j < cols; j++)
            for (int i = 0; i < rows; i++) {
                int a = addr(i, j);
                System.out.println("  M[" + i + "][" + j + "]=" + mat[i][j] + " addr=" + a
                        + (prev < 0 ? "" : (a - prev == 1 ? " (adjacent)" : " (jump)")));
                prev = a;
            }
    }

    static void runScenario(String label, int[][] mat, boolean layoutRowMajor, boolean traversalRow) {
        System.out.println("-- " + label + " --");
        rows = mat.length; cols = mat[0].length; rowMajor = layoutRowMajor;
        System.out.println("layout=" + (rowMajor ? "row-major" : "column-major") + " traversal=" + (traversalRow ? "row" : "column"));
        if (traversalRow) traverseRowMajor(mat); else traverseColMajor(mat);
        System.out.println();
    }

    public static void main(String[] args) {
        // normal: 3x4 row-major, row-by-row traversal: always adjacent
        int[][] normal = {{8, 16, 24, 32}, {40, 48, 56, 64}, {72, 80, 88, 96}};
        runScenario("normal: 3x4 row-major, row-by-row traversal: always adjacent", normal, true, true);

        // hard: 4x4 row-major, column-by-column traversal: a jump on every step
        int[][] hard = {{3, -7, 15, 22}, {9, -14, 31, 6}, {18, -2, 27, 11}, {5, -19, 33, 8}};
        runScenario("hard: 4x4 row-major, column-by-column traversal: a jump on every step", hard, true, false);

        // edge: 3x5 column-major, row-by-row traversal: jumpy
        int[][] colRow = {{4, 9, -3, 16, 21}, {7, -12, 25, 2, 18}, {-6, 14, 8, -20, 30}};
        runScenario("edge: 3x5 column-major, row-by-row traversal: jumpy", colRow, false, true);

        // edge: 3x4 column-major, column-by-column traversal: adjacent again
        int[][] colCol = {{2, 5, -8, 13}, {19, -4, 7, 22}, {10, -15, 26, 1}};
        runScenario("edge: 3x4 column-major, column-by-column traversal: adjacent again", colCol, false, false);
    }
}