বহুমাত্রিক অ্যারে — সারি আর কলামের টেবিল মেমরিতে কীভাবে থাকে

১ · মেমরি একটি লম্বা রাস্তা, টেবিল শুধু নম্বর দেওয়ার নিয়ম

পর্ব ১৬-এ দেখেছেন, অ্যারে মানে মেমরিতে পাশাপাশি সাজানো ঘর। সেখানে শেষের দিকে এক ঝলক 2D array-ও দেখেছিলেন। এই পর্বে সেই ধারণাটি পুরো গভীরে নিয়ে যাব — কারণ পরীক্ষার ফলাফল থেকে শুরু করে AI মডেলের ভেতরের হিসাব পর্যন্ত, বাস্তবের বেশিরভাগ ডেটাই আসে টেবিলের আকারে।

কয়েকটি টেবিলের কথা ভাবুন:

• ক্লাসের ফলাফলের খাতা: প্রতি সারিতে একজন শিক্ষার্থী, প্রতি কলামে একটি বিষয়।
• ঢাকা–চট্টগ্রাম বাসের আসনের নকশা: ১০টি সারি, প্রতি সারিতে ৪টি আসন — কোনটি বুক হয়েছে, কোনটি খালি।
• লুডো বা দাবার বোর্ড: লুডো ১৫ × ১৫ ঘরের, দাবা ৮ × ৮ ঘরের।
• মোবাইলে তোলা ছবি: হাজার হাজার সারি, প্রতি সারিতে হাজার হাজার pixel.

C-তে এমন টেবিল লেখা হয় দুটি বন্ধনী দিয়ে। প্রথম সংখ্যাটি সারি, দ্বিতীয়টি কলাম:

int marks[3][4] = {           /* ৩ জন শিক্ষার্থী × ৪টি বিষয় */
    {78, 65, 82, 90},         /* সারি 0: বাংলা, ইংরেজি, গণিত, বিজ্ঞান */
    {55, 72, 68, 61},         /* সারি 1 */
    {88, 91, 95, 84}          /* সারি 2 */
};

int seat[10][4] = {0};        /* বাসের ৪০টি আসন, সব খালি (0) */
int board[][8] = {{1, 2}, {3}}; /* প্রথম মাপ বাদ দেওয়া যায়: compiler গুনে 2 ধরে */

ভেতরের বন্ধনীগুলো (nested braces) প্রতিটি সারি আলাদা করে দেখায়। কোনো সারিতে কম মান দিলে বাকি ঘরগুলো 0 হয়ে যায়, যেমন উপরের board-এর বেশিরভাগ ঘর। খেয়াল করুন, শুধু প্রথম মাপটি বাদ দেওয়া যায়; কলামের সংখ্যা (8) সবসময় লিখতে হয়। কেন — তার উত্তর এই পর্বের মূল রহস্য, যা পরের অংশেই খুলবে।

২ · Row-major — a[i][j] আসলে কোন ঘরে থাকে

C যে চুক্তি মানে তার নাম row-major order: প্রথমে সারি 0-এর সব ঘর, তার ঠিক পরে সারি 1-এর সব ঘর, তারপর সারি 2 — মাঝে কোনো ফাঁক ছাড়া। নিচের ডায়াগ্রামে উপরের marks[3][4] টেবিলটি মেমরিতে বসিয়ে দেখি। ধরা যাক অ্যারেটি শুরু হয়েছে ঠিকানা 1000-এ (একে বলে base address), আর প্রতিটি int ৪ বাইটের।

          col 0  col 1  col 2  col 3
row 0  :   78     65     82     90
row 1  :   55     72     68     61
row 2  :   88     91     95     84

offset :  0   1   2   3   4   5   6   7   8   9   10  11
memory : [78][65][82][90][  ][  ][  ][  ][  ][  ][  ][  ]
address: 1000 ... 1012

offset :  0   1   2   3   4   5   6   7   8   9   10  11
memory : [78][65][82][90][55][72][68][61][88][91][95][84]
         |--- row 0 ----||--- row 1 ----||--- row 2 ----|
size   : 12 x 4 = 48 bytes, one unbroken block

offset :  0   1   2   3   4   5   6   7   8   9   10  11
memory : [78][65][82][90][55][72][68][61][88][91][95][84]
                                  ^
offset  = 1 * 4 + 2 = 6
address = 1000 + 6 * 4 = 1024    value = 68

&a[i][j] = base + (i * COLS + j) * sizeof(int)

marks[i]      -> type int[4], a whole row (16 bytes)
marks + 1     -> jumps 16 bytes, to the start of row 1
marks[1] + 2  -> 1016 + 2 * 4 = 1024
/* ROWS never appears in the formula; COLS always does */

এই সূত্রের একটি সরাসরি ফল হলো গতি। পর্ব ১৬-এর অংশ ৮-এ দেখেছেন, CPU মেমরি থেকে একবারে একটি cache line (সাধারণত ৬৪ বাইট) আনে, আর পাশাপাশি ঘর পরপর ছুঁলে তার পুরো সুবিধা পাওয়া যায় — যাকে বলে spatial locality. Row-major বিন্যাসে a[i][0], a[i][1], a[i][2]… পাশাপাশি থাকে। তাই:

দুটি লুপ ঠিক একই উত্তর দেয়, একই সংখ্যক যোগ করে। ছোট টেবিলে পার্থক্য চোখেই পড়বে না। কিন্তু হাজার × হাজার মাপের টেবিলে দ্বিতীয়টি কয়েক গুণ ধীর হতে পারে — কত গুণ, তা কম্পিউটার আর টেবিলের মাপের ওপর নির্ভর করে। নিজে মাপতে চাইলে clock() দিয়ে দুটি লুপের সময় তুলনা করে দেখতে পারেন — সময় মাপার এই কৌশল পর্ব ৩৯-এ বিস্তারিত আসবে।

৩ · Nested loop-এর চারটি কাজ — যোগফল, গড়, transpose, গুণ

2D অ্যারের প্রায় সব কাজ হয় nested loop দিয়ে: বাইরের লুপ একটি মাত্রা ধরে, ভেতরের লুপ আরেকটি। চারটি কাজ শিখলে বাকিগুলো এদেরই রূপান্তর।

ক. ফলাফলের খাতা — সারির যোগফল, কলামের গড়, সর্বোচ্চ নম্বর

নিচের প্রোগ্রামটি আমাদের ৩ জন শিক্ষার্থী × ৪ বিষয়ের খাতা থেকে প্রত্যেকের মোট নম্বর, প্রতিটি বিষয়ের গড় আর সর্বোচ্চ মোট নম্বর পাওয়া শিক্ষার্থীকে বের করে। চালিয়ে দেখুন, তারপর নিচের ব্যাখ্যা পড়ুন।

#include <stdio.h>
#define ST 3   /* students */
#define SB 4   /* subjects */
int main(void) {
    int m[ST][SB] = {{78, 65, 82, 90}, {55, 72, 68, 61}, {88, 91, 95, 84}};
    int best = 0, bestTotal = -1;
    for (int i = 0; i < ST; i++) {               /* one row = one student */
        int total = 0;
        for (int j = 0; j < SB; j++) total += m[i][j];
        printf("Student %d total: %d\n", i, total);
        if (total > bestTotal) { bestTotal = total; best = i; }
    }
    for (int j = 0; j < SB; j++) {               /* one column = one subject */
        int sum = 0;
        for (int i = 0; i < ST; i++) sum += m[i][j];
        printf("Subject %d average: %.2f\n", j, (double)sum / ST);
    }
    printf("Top: student %d with %d\n", best, bestTotal);
    return 0;
}

খ. Transpose — সারিকে কলাম বানানো

Matrix মানে সংখ্যার একটি আয়তাকার টেবিল — গণিতের ভাষায় 2D অ্যারে। একটি matrix-এর transpose মানে সারিগুলোকে কলাম বানিয়ে দেওয়া: ২ × ৩ matrix হয়ে যায় ৩ × ২. নিয়ম একটাই — T[j][i] = A[i][j]. নিচের debugger-সিমুলেটরে প্রতিটি ঘর কোথা থেকে কোথায় যায় দেখুন:

1int A[2][3] = {{1, 2, 3},2               {4, 5, 6}};3int T[3][2];4for (int i = 0; i < 2; i++)5    for (int j = 0; j < 3; j++)6        T[j][i] = A[i][j];7/* T is now 3 rows x 2 cols */

গ. Matrix গুণ — তিনটি লুপ

Matrix multiplication-এ C = A × B হলে C[i][j] হলো A-এর সারি i আর B-এর কলাম j-এর ঘরগুলো জোড়ায় জোড়ায় গুণ করে যোগফল। শর্ত একটাই — A-এর কলাম সংখ্যা আর B-এর সারি সংখ্যা সমান হতে হবে। ছোট একটি ২ × ২ উদাহরণে দেখি:

কোডে এটি তিনটি নেস্টেড লুপ:

for (int i = 0; i < N; i++)
    for (int j = 0; j < N; j++) {
        int sum = 0;
        for (int k = 0; k < N; k++)
            sum += A[i][k] * B[k][j];    /* B পড়া হচ্ছে কলাম ধরে — লাফিয়ে লাফিয়ে */
        C[i][j] = sum;
    }

মন্তব্যটি খেয়াল করুন: ভেতরের লুপে B[k][j] প্রতিবার একটি পুরো সারি লাফায় — cache-এর জন্য খারাপ। একটি পরিচিত কৌশল হলো লুপের ক্রম i, k, j করে দেওয়া (আগে C শূন্য করে নিয়ে): তখন ভেতরের লুপে B[k][j] আর C[i][j] দুটিই সারি ধরে হাঁটে। উত্তর একই, কিন্তু বড় matrix-এ অনেক দ্রুত। সাধারণ নিয়ম: শেষ index-টি সবচেয়ে ভেতরের লুপে বদলাক।

৪ · ফাংশনে 2D অ্যারে পাঠানো — কলাম সংখ্যা কেন লাগে

পর্ব ১৮-এ দেখেছেন, ফাংশনে অ্যারে পাঠালে পুরো অ্যারে কপি হয় না — শুধু প্রথম ঘরের ঠিকানা যায় (array decay). 2D অ্যারের বেলাতেও একই কথা, শুধু “প্রথম ঘর” এখন একটি পুরো সারি। তাই int marks[3][4] পাঠালে ফাংশন পায় একটি pointer to array — টাইপ int (*)[4], অর্থাৎ “৪টি int-এর একটি সারির ঠিকানা।”

এখন অংশ ২-এর সূত্রটি মনে করুন: a[i][j] খুঁজতে compiler-কে জানতে হবে এক সারিতে কয়টি ঘর। সারির সংখ্যা সূত্রে নেই। এজন্যই:

void print_sheet(int rows, int a[][4]) {      /* প্রথম মাপ বাদ, কলাম 4 বাধ্যতামূলক */
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < 4; j++)
            printf("%d ", a[i][j]);
}
/* int a[][4], int a[3][4], int (*a)[4] — তিনটি লেখাই এখানে হুবহু এক জিনিস */

void print_any(int rows, int cols, int a[rows][cols]) {
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++)
            printf("%d ", a[i][j]);
}
/* rows আর cols আগে, অ্যারে পরে — ক্রমটা জরুরি */

void print_flat(int rows, int cols, const int *a) {
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++)
            printf("%d ", a[i * cols + j]);       /* সূত্রটি নিজের হাতে */
}
/* ডাকা: print_flat(3, 4, &marks[0][0]); */

সবচেয়ে বড় ফাঁদ: int ** আর int[3][4] এক নয়

নতুনরা (এবং AI-ও!) প্রায়ই ভাবেন, “1D অ্যারে মানে int *, তাহলে 2D মানে নিশ্চয়ই int **.” এই যুক্তি শুনতে ঠিক, কিন্তু সম্পূর্ণ ভুল:

void show(int **a);        /* ভুল প্রত্যাশা */
int marks[3][4];
show(marks);

warning: passing argument 1 of 'show' from incompatible pointer type
note: expected 'int **' but argument is of type 'int (*)[4]'

GCC ১৪ থেকে এটি আর শুধু warning নয়, ডিফল্টভাবে error. কেন মেলে না, দুটি ছবি পাশাপাশি রাখলেই বোঝা যায়:

জোর করে cast করে marks-কে int ** হিসেবে পাঠালে কী হয়? ফাংশন p[1] পড়ার সময় মনে করবে সেখানে একটি ঠিকানা আছে — অথচ সেখানে আছে নম্বর 82 আর 90-এর বাইট! সেই “ঠিকানায়” যেতে চাইলে প্রায় নিশ্চিত segmentation fault. নিয়মটি মনে রাখুন: অ্যারে একবারই pointer-এ decay হয়, শুধু বাইরের মাত্রায়। int[3][4] হয় int (*)[4], কখনোই int ** নয়।

৫ · Heap-এ 2D অ্যারে — তিনটি উপায়, তিনটি free-নিয়ম

এতক্ষণ মাপ আগে থেকে জানা ছিল। কিন্তু ধরুন একটি স্কুলের ফলাফল সফটওয়্যার — কতজন শিক্ষার্থী আর কয়টি বিষয়, তা জানা যাবে ফাইল পড়ার পরে। তখন পর্ব ২০-এর malloc দিয়ে heap থেকে জায়গা নিতে হবে। 2D অ্যারের জন্য এর তিনটি প্রচলিত উপায় আছে।

উপায় ১ — একটি একটানা block, সূত্র নিজের হাতে

int *p = malloc((size_t)rows * cols * sizeof *p);   /* rows × cols ঘর, একবারে */
if (p == NULL) { /* সামলান */ }
p[i * cols + j] = 90;                                /* "a[i][j]" */
free(p);                                             /* একটি malloc, একটি free */

স্থির অ্যারের মতোই সব ঘর পাশাপাশি, cache-বান্ধব। একটি malloc, একটি free — ভুলের সুযোগ সবচেয়ে কম। (size_t) cast-টি গুণফলকে বড় টাইপে করায়, যাতে বড় মাপে int-এর overflow না হয়। সূত্রটি বারবার লিখতে না চাইলে একটি ছোট ফাংশন বানিয়ে নিন: size_t idx(size_t i, size_t j, size_t cols) { return i * cols + j; }. NumPy, OpenCV-র মতো বড় library-গুলোও ভেতরে ঠিক এভাবেই ডেটা রাখে।

উপায় ২ — সারির pointer-এর অ্যারে (jagged)

প্রথমে একটি অ্যারে নিন, যার প্রতিটি ঘরে একটি সারির ঠিকানা থাকবে; তারপর প্রতিটি সারির জন্য আলাদা malloc. এতে সারিগুলোর দৈর্ঘ্য আলাদা হতে পারে — একে বলে jagged array. যেমন একটি কলেজে বিভাগভেদে শিক্ষার্থীর সংখ্যা আলাদা। ধাপে ধাপে দেখুন, আর শেষের free-এর ক্রমটি বিশেষভাবে খেয়াল করুন:

এই উপায়ে আরেকটি ঝামেলা আছে: ৩টি সারির মাঝখানে, ধরুন দ্বিতীয় সারির malloc ব্যর্থ হলো। তখন আগের সারিটি আর ঠিকানার অ্যারেটি ছেড়ে তারপর বের হতে হবে — নইলে leak. মোট malloc সংখ্যা rows + 1, তাই ভুলের জায়গাও তত বেশি।

উপায় ৩ — pointer to array: একটি block, তবু a[i][j]

কলামের সংখ্যা যদি জানা থাকে (ধরুন সবসময় ৪টি বিষয়), কিন্তু সারির সংখ্যা চলার সময় ঠিক হয়, তাহলে সবচেয়ে সুন্দর উপায় এটি:

#define COLS 4
int (*a)[COLS] = malloc(rows * sizeof *a);   /* sizeof *a = 4 × 4 = 16 বাইট, একটি সারি */
a[i][j] = 90;                                /* স্বাভাবিক লেখা, সূত্র compiler করে */
free(a);                                     /* একটি malloc, একটি free */

int (*a)[COLS] পড়ুন ভেতর থেকে বাইরে: “a একটি pointer, যা ৪টি int-এর একটি অ্যারেকে দেখায়।” বন্ধনী না দিলে int *a[COLS] হয়ে যেত সম্পূর্ণ অন্য জিনিস — ৪টি pointer-এর অ্যারে। এই পড়ার কৌশল পর্ব ৪৫-এ বিস্তারিত দেখবেন। C99 থেকে কলামের সংখ্যাও ভ্যারিয়েবল হতে পারে — নিচের প্রোগ্রামে ঠিক সেটাই, সাথে VLA প্যারামিটার দিয়ে transpose:

#include <stdio.h>
#include <stdlib.h>

void transpose(int r, int c, int a[r][c], int t[c][r]) {
    for (int i = 0; i < r; i++)
        for (int j = 0; j < c; j++)
            t[j][i] = a[i][j];
}

int main(void) {
    int r = 2, c = 3;                      /* sizes known only at run time */
    int (*a)[c] = malloc(sizeof(int[r][c]));
    int (*t)[r] = malloc(sizeof(int[c][r]));
    if (a == NULL || t == NULL) { free(a); free(t); return 1; }
    for (int i = 0; i < r; i++)
        for (int j = 0; j < c; j++)
            a[i][j] = i * c + j + 1;       /* 1 2 3 / 4 5 6 */
    transpose(r, c, a, t);
    for (int i = 0; i < c; i++) printf("%d %d\n", t[i][0], t[i][1]);
    free(a); free(t);
    return 0;
}

কোনটি কখন?

অনেক অভিজ্ঞ প্রোগ্রামারের পরামর্শ: সব সারি সমান হলে একটানা block-ই নিন। Jagged অ্যারে তখনই, যখন তার নমনীয়তা সত্যিই দরকার — যেমন প্রতিটি শিক্ষার্থীর আলাদা সংখ্যক বিষয়, বা দুটি সারি অদলবদল করতে চান শুধু দুটি pointer বদলে।

৬ · তিন মাত্রা আর স্ট্রিংয়ের অ্যারে

3D অ্যারে — ভবন × তলা × কক্ষ

একটি হাসপাতালের কথা ভাবুন: ২টি ভবন, প্রতিটিতে ৬টি তলা, প্রতি তলায় ২০টি কক্ষ। কোন কক্ষে কতজন রোগী, তা রাখতে লাগবে একটি 3D array:

int patients[2][6][20];               /* ২ × ৬ × ২০ = ২৪০টি int */
patients[1][3][7] = 2;                /* ভবন 1, তলা 3, কক্ষ 7 */

/* ঘর নম্বর = (b × 6 + f) × 20 + r  →  (1 × 6 + 3) × 20 + 7 = 187 */

সূত্রটি একই চিন্তার সম্প্রসারণ: আগে আগের পুরো ভবনগুলো পার হতে হয় (প্রতিটি ৬ × ২০ ঘর), তারপর আগের তলাগুলো (প্রতিটি ২০ ঘর), তারপর কক্ষ। শেষ মাত্রাটি সবচেয়ে দ্রুত বদলায়। ফাংশনে পাঠাতে প্রথমটি ছাড়া সব মাপ লাগবে: void f(int b, int p[][6][20]). বাস্তবে সবচেয়ে পরিচিত 3D অ্যারে হলো রঙিন ছবি — unsigned char img[1080][1920][3]: সারি × কলাম × রঙ (লাল, সবুজ, নীল)। মাপটি দেখুন — ১০৮০ × ১৯২০ × ৩ = ৬২,২০,৮০০ বাইট, প্রায় ৬ MB. Local ভ্যারিয়েবল হিসেবে ঘোষণা করলে Windows-এ (stack সাধারণত ১ MB) জায়গাই হবে না, আর Linux-এর সাধারণ ৮ MB stack-এরও প্রায় পুরোটা চলে যাবে — stack overflow-এর ঝুঁকি। এত বড় অ্যারে heap-এ নিন।

স্ট্রিংয়ের অ্যারে — char names[5][20] বনাম char *names[5]

পর্ব ১৯-এ দেখেছেন, স্ট্রিং মানে char-এর অ্যারে। তাহলে অনেকগুলো নাম রাখার array of strings দুইভাবে বানানো যায়, আর এই দুটির পার্থক্য পরীক্ষা ও ইন্টারভিউর প্রিয় প্রশ্ন:

main-এর char *argv[] ঠিক দ্বিতীয় ধরনের — প্রতিটি কমান্ড-লাইন আর্গুমেন্টের দৈর্ঘ্য আলাদা। পর্ব ২৫-এ এটি নিয়ে কাজ করবেন।

৭ · সীমার বাইরে — পাশের সারি চুপচাপ নষ্ট হয়

পর্ব ১৬-এ দেখেছেন, C অ্যারের সীমা পাহারা দেয় না। 2D অ্যারেতে বিপদটা আরও সূক্ষ্ম, কারণ সারিগুলো গায়ে গা লাগিয়ে থাকে। int marks[3][4]-এ ভুল করে marks[0][4] লিখলেন (কলাম 4 নেই, আছে 0–3). সূত্রে বসান: 0 × 4 + 4 = ৪ — যা আসলে marks[1][0]-এর ঘর! অর্থাৎ শিক্ষার্থী 0-এর “পঞ্চম বিষয়ের” নম্বর বসাতে গিয়ে আপনি শিক্ষার্থী 1-এর বাংলার নম্বর মুছে দিলেন। কোনো crash নেই, কোনো error নেই — শুধু ভুল ফলাফল।

আরেকটি ভুল আসে Python বা MATLAB থেকে আসা মানুষের হাত থেকে: marks[i, j]. C-তে এটি ভুল নয়, আরও খারাপ — বৈধ কোড! কমা এখানে একটি অপারেটর, যা বাঁ দিকেরটা ফেলে দিয়ে ডান দিকেরটা রাখে। ফলে marks[i, j] হয়ে যায় marks[j] — একটি পুরো সারি। -Wall চালু থাকলে GCC সাধারণত সতর্ক করে: left-hand operand of comma expression has no effect.

যন্ত্র দিয়ে ধরা

পর্ব ৩১-এ ডিবাগিংয়ের যন্ত্রগুলো বিস্তারিত দেখবেন। এখানে শুধু 2D অ্যারের জন্য একটি গুরুত্বপূর্ণ সূক্ষ্মতা:

• AddressSanitizer (-fsanitize=address): পুরো অ্যারের বাইরে গেলে — যেমন marks[3][0] — হাতেনাতে ধরে। কিন্তু marks[0][4] তখনো অ্যারের নিজের ৪৮ বাইটের ভেতরে, তাই ASan-এর চোখে এটি বৈধ মেমরি!
• UBSan (-fsanitize=bounds): স্থির মাপের অ্যারেতে প্রতিটি index তার ঘোষিত মাপের সাথে মিলিয়ে দেখে, তাই marks[0][4]-এ বলে index 4 out of bounds for type 'int [4]'. Heap-এর একটানা block-এ (p[i*cols + j]) কিন্তু এই সুবিধা নেই — সেখানে সূত্রের ভুল আপনাকেই ধরতে হবে।

তাই পরীক্ষার সময় দুটোই একসাথে চালান: gcc -Wall -Wextra -g -fsanitize=address,undefined. UBSan-এর undefined গ্রুপের ভেতরেই bounds আছে।

৮ · বাস্তব জগতে — ছবি, স্প্রেডশিট, গেম, AI আর DP

এই পর্বের ধারণাগুলো কোনো পাঠ্যবইয়ের খেলনা নয়। আপনার ফোনের প্রায় প্রতিটি অ্যাপ ভেতরে কোথাও না কোথাও 2D বা 3D অ্যারে নিয়ে কাজ করছে।

আরও একটি জায়গা, যা এই কোর্সেই আসছে: পর্ব ৪২-এর dynamic programming-এ প্রায়ই একটি 2D টেবিল dp[i][j] ভরাতে হয় — যেমন দুটি শব্দ কতটা আলাদা (edit distance), যা বানান-সংশোধক আর DNA মেলানোর সফটওয়্যারে লাগে। পর্ব ৩৮-এর গ্রাফেও একটি পরিচিত রূপ হলো adjacency matrix — g[u][v] = 1 মানে u থেকে v-তে রাস্তা আছে।

Matrix-এর গণিত গভীরে বুঝতে চাইলে Math for AI কোর্সের linear algebra অংশ, আর matrix কীভাবে neural network হয়ে ওঠে তা দেখতে Deep Learning কোর্স দেখুন।

৯ · AI-এর যুগে — matrix-কোডে AI কোথায় ভুল করে

“একটি matrix গুণের C প্রোগ্রাম লিখে দাও” — যেকোনো AI কয়েক সেকেন্ডে লিখে দেবে, আর ৩ × ৩ উদাহরণে উত্তরও মিলবে। সমস্যা হলো, এই পর্বের প্রায় সব ভুল ঠিক বর্গাকার, ছোট উদাহরণেই লুকিয়ে থাকে। AI সাধারণত অবর্গাকার matrix, বড় মাপ বা sanitizer দিয়ে নিজের কোড চালিয়ে দেখে না।

AI সাধারণত যেসব 2D-অ্যারে ভুল করে

AI-এর 2D-অ্যারে কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• প্যারামিটারের টাইপ অ্যারের আসল টাইপের সাথে মেলে — স্থির অ্যারের জন্য কোথাও int ** নেই
• প্রতিটি লুপের সীমা মিলিয়েছি: i চলে সারি পর্যন্ত, j চলে কলাম পর্যন্ত, কোথাও <= নেই
• অন্তত একটি অবর্গাকার মাপে (যেমন ২ × ৫) চালিয়ে হাতে হিসাব মিলিয়েছি
• malloc আর free গুনেছি — সংখ্যা সমান, আর jagged হলে সারিগুলো আগে ছাড়া হয়েছে
• শেষ index সবচেয়ে ভেতরের লুপে বদলায়; -fsanitize=address,undefined দিয়ে চালিয়ে একটিও রিপোর্ট নেই