C-তে অ্যারে আর ফাংশন — সমস্যা সমাধান

১ · অ্যারে — এক নামে অনেক মান

পর্ব ৩৯-এ আপনি ভ্যারিয়েবল, শর্ত আর লুপ শিখেছেন। এবার একটি বাস্তব কাজ ধরুন: একটি ক্লাসের ৫০ জন শিক্ষার্থীর ICT নম্বর রাখতে হবে, তারপর গড়, সর্বোচ্চ আর মেধাক্রম বের করতে হবে। ৫০টি আলাদা ভ্যারিয়েবল — m1, m2, … m50? লেখা যাবে, কিন্তু যোগ করতে ৫০টি নাম লিখতে হবে, আর শিক্ষার্থী ৫০০ জন হলে প্রোগ্রামটাই অচল।

সমাধান হলো array (অ্যারে): একই ধরনের অনেকগুলো মান, একটি নামে, ক্রমিক নম্বর দেওয়া ঘরে।

ঘোষণা, মান বসানো আর index

int marks[5];                          /* ৫টি int-এর জায়গা, মান এখনো অজানা */
int roll[5] = {11, 12, 13, 14, 15};    /* ঘোষণার সাথেই মান */
int a[5] = {7, 3};                     /* বাকি তিনটি ঘর হবে 0 */
int b[] = {4, 8, 15, 16};              /* আকার compiler নিজে গুনে নেয়: 4 */
float price[3];
char grade[4] = {'A', 'B', 'C', 'F'};

marks[0] = 72;                         /* প্রথম ঘর */
marks[4] = 90;                         /* শেষ ঘর — marks[5] নয়! */
printf("%d", roll[2]);                 /* ছাপবে 13 */

বন্ধনীর ভেতরের সংখ্যাটি দুই জায়গায় দুই অর্থে বসে, এটিই নতুনদের প্রথম বিভ্রান্তি। ঘোষণায় int marks[5]-এর ৫ মানে মোট ঘর কয়টি। ব্যবহারে marks[4]-এর ৪ মানে কোন ঘর — একে বলে index. index শুরু ০ থেকে, তাই ৫ ঘরের অ্যারের বৈধ index ০, ১, ২, ৩, ৪ — শেষটি সবসময় আকারের চেয়ে এক কম।

মেমরিতে অ্যারে দেখতে কেমন

পর্ব ২৪-এ দেখেছেন, RAM হলো ক্রমিক নম্বর দেওয়া অসংখ্য বাইটের সারি, আর প্রতিটি বাইটের নিজস্ব memory address আছে। অ্যারের ঘরগুলো RAM-এ একটির পর একটি, কোনো ফাঁক ছাড়া বসে। সাধারণ কম্পিউটারে একটি int ৪ বাইট, তাই int roll[5] নেয় ৫ × ৪ = ২০ বাইট:

সীমার বাইরে গেলে — C পাহারা দেয় না

২ · লুপ দিয়ে অ্যারে — পরীক্ষার ক্লাসিক প্রোগ্রাম

অ্যারের আসল শক্তি আসে লুপের সাথে। index যেহেতু একটি সংখ্যা, তাই i ভ্যারিয়েবল দিয়ে ০ থেকে n − 1 পর্যন্ত ঘুরলেই সব ঘরে একে একে পৌঁছানো যায়। ৫টি হোক বা ৫০০০টি — কোড একই থাকে, শুধু n বদলায়। প্রায় সব অ্যারে-প্রোগ্রামের কাঠামো তিন ভাগে: পড়া (scanf লুপ) → প্রক্রিয়া (হিসাবের লুপ) → লেখা (printf লুপ)। নিচের প্রতিটি ট্যাবে একটি করে ক্লাসিক প্রোগ্রাম — পরীক্ষার খাতায় যেভাবে লেখা হয়, সেভাবেই:

#include <stdio.h>
int main()
{
    int a[100], n, i, sum = 0;
    float avg;
    printf("How many numbers? ");
    scanf("%d", &n);
    for (i = 0; i < n; i++)
        scanf("%d", &a[i]);
    for (i = 0; i < n; i++)
        sum = sum + a[i];
    avg = (float)sum / n;
    printf("Sum = %d\nAverage = %.2f\n", sum, avg);
    return 0;
}

How many numbers? 5
10 20 30 40 45
Sum = 145
Average = 29.00

#include <stdio.h>
int main()
{
    int a[6] = {45, 12, 78, 34, 90, 23};
    int i, max = a[0], min = a[0];
    for (i = 1; i < 6; i++) {
        if (a[i] > max) max = a[i];
        if (a[i] < min) min = a[i];
    }
    printf("Largest = %d, Smallest = %d\n", max, min);
    return 0;
}

Largest = 90, Smallest = 12

#include <stdio.h>
int main()
{
    int a[9] = {12, 7, 9, 20, 33, 18, 5, 6, 11};
    int i, even = 0, odd = 0;
    for (i = 0; i < 9; i++) {
        if (a[i] % 2 == 0)
            even++;
        else
            odd++;
    }
    printf("Even = %d, Odd = %d\n", even, odd);
    return 0;
}

Even = 4, Odd = 5

#include <stdio.h>
int main()
{
    int a[7] = {15, 8, 23, 42, 4, 16, 31};
    int i, key = 42, pos = -1;
    for (i = 0; i < 7; i++) {
        if (a[i] == key) {
            pos = i;
            break;
        }
    }
    if (pos == -1)
        printf("%d not found\n", key);
    else
        printf("%d found at index %d (position %d)\n", key, pos, pos + 1);
    return 0;
}

42 found at index 3 (position 4)

#include <stdio.h>
int main()
{
    int a[5] = {1, 2, 3, 4, 5};
    int i, n = 5, temp;
    for (i = 0; i < n / 2; i++) {
        temp = a[i];
        a[i] = a[n - 1 - i];
        a[n - 1 - i] = temp;
    }
    for (i = 0; i < n; i++)
        printf("%d ", a[i]);
    printf("\n");
    return 0;
}

5 4 3 2 1

#include <stdio.h>
int main()
{
    int a[8] = {2, 5, 2, 8, 5, 2, 9, 0};
    int freq[10] = {0};          /* 0-9 প্রতিটি অঙ্কের গণনা */
    int i;
    for (i = 0; i < 8; i++)
        freq[a[i]]++;
    for (i = 0; i < 10; i++)
        if (freq[i] > 0)
            printf("%d occurs %d time(s)\n", i, freq[i]);
    return 0;
}

0 occurs 1 time(s)
2 occurs 3 time(s)
5 occurs 2 time(s)
8 occurs 1 time(s)
9 occurs 1 time(s)

৩ · Bubble sort — পাশাপাশি তুলনা করে সাজানো

মেধাতালিকা বানাতে নম্বরগুলো সাজাতে হয়। সাজানোর সবচেয়ে সহজ algorithm হলো bubble sort (পর্ব ৩৮-এ দেখেছেন, algorithm মানে ধাপে ধাপে সুনির্দিষ্ট নিয়ম)। নিয়ম মাত্র একটি: পাশাপাশি দুটি মান দেখুন; বাঁয়েরটি বড় হলে জায়গা বদলান। বাঁ থেকে ডানে একবার পুরো ঘোরাকে বলে একটি pass. প্রতিটি pass শেষে সবচেয়ে বড় মানটি পানির বুদবুদের মতো ভেসে শেষ প্রান্তে পৌঁছে যায় — নামটি সেখান থেকেই।

নিচে {5, 1, 4, 2, 8} সাজানো হচ্ছে। “পরে” চাপুন, আর প্রতিটি ধাপে কোন দুটি ঘর তুলনা হলো, সেটি খেয়াল করুন:

1for (i = 0; i < n - 1; i++)2    for (j = 0; j < n - 1 - i; j++)3        if (a[j] > a[j + 1]) {4            temp = a[j];5            a[j] = a[j + 1];6            a[j + 1] = temp;7        }

এবার সব একসাথে: একটি ক্লাসের নম্বর পড়ে মোট, গড়, সর্বোচ্চ, সর্বনিম্ন আর সাজানো তালিকা। ইনপুট আগে থেকে দেওয়া আছে (প্রথমে শিক্ষার্থীর সংখ্যা, তারপর নম্বরগুলো) — চালিয়ে দেখুন, তারপর হাতে মিলিয়ে নিন:

#include <stdio.h>

int main(void) {
    int m[50], n, sum = 0;
    if (scanf("%d", &n) != 1 || n < 1 || n > 50) return 1;   /* bounds check */
    for (int i = 0; i < n; i++) { scanf("%d", &m[i]); sum += m[i]; }
    int max = m[0], min = m[0];
    for (int i = 1; i < n; i++) {
        if (m[i] > max) max = m[i];
        if (m[i] < min) min = m[i];
    }
    printf("Total = %d, Average = %.2f\n", sum, (float)sum / n);
    printf("Highest = %d, Lowest = %d\n", max, min);
    for (int i = 0; i < n - 1; i++)                 /* bubble sort */
        for (int j = 0; j < n - 1 - i; j++)
            if (m[j] > m[j + 1]) { int t = m[j]; m[j] = m[j + 1]; m[j + 1] = t; }
    printf("Sorted:");
    for (int i = 0; i < n; i++) printf(" %d", m[i]);
    printf("\n");
    return 0;
}

৪ · 2D অ্যারে — সারি আর কলামের ম্যাট্রিক্স

পরীক্ষার ফলাফলের শিটে সারি = শিক্ষার্থী, কলাম = বিষয়। এমন টেবিলের জন্য আছে two-dimensional array: int r[3][4]; মানে ৩টি সারি, ৪টি কলাম, মোট ১২টি ঘর। কোনো ঘর ধরতে দুটি index লাগে — r[সারি][কলাম], দুটোই ০ থেকে। Excel-এর সেল যেমন “B3” (পর্ব ১০), তেমনি এখানে r[2][1] — শুধু গোনা শুরু ০ থেকে। আর দুটি index মানে দুটি লুপ: বাইরের লুপ সারি ধরে, ভেতরের লুপ কলাম ধরে।

মেমরিতে কিন্তু টেবিল বলে কিছু নেই — RAM একটিই লম্বা সারি। C তাই সারিগুলো পরপর বসায়: আগে প্রথম সারির সব ঘর, তারপর দ্বিতীয় সারি (row-major order). HSC-র ক্লাসিক প্রশ্ন — ম্যাট্রিক্স যোগ:

#include <stdio.h>
int main()
{
    int A[2][3] = {{1, 2, 3}, {4, 5, 6}};
    int B[2][3] = {{6, 5, 4}, {3, 2, 1}};
    int C[2][3], i, j;
    for (i = 0; i < 2; i++)
        for (j = 0; j < 3; j++)
            C[i][j] = A[i][j] + B[i][j];
    printf("Sum matrix:\n");
    for (i = 0; i < 2; i++) {
        for (j = 0; j < 3; j++)
            printf("%4d", C[i][j]);
        printf("\n");             /* প্রতিটি সারি শেষে নতুন লাইন */
    }
    return 0;
}

প্রত্যাশিত আউটপুট

Sum matrix:
   7   7   7
   7   7   7

ইনপুট নিতে হলে প্রথম লুপের ভেতরে scanf("%d", &A[i][j]); — কাঠামো একই। ম্যাট্রিক্স যোগের শর্ত হলো দুটির মাপ এক হতে হবে। ভেতরের printf("\n") বাইরের লুপে, ভেতরের লুপের পরে — এটি ভুল জায়গায় বসালে সব সংখ্যা এক লাইনে বা প্রতিটি আলাদা লাইনে চলে আসে, পরীক্ষায় খুব সাধারণ ভুল।

Transpose (সারিকে কলাম বানানো) — শুধু index দুটি উল্টে দিন: T[j][i] = A[i][j];. 2 × 3 ম্যাট্রিক্সের transpose হয় 3 × 2:

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

৫ · String — char-এর অ্যারে আর শেষের '\0'

নাম, ঠিকানা, বাক্য — এগুলো string. C-তে আলাদা কোনো “string টাইপ” নেই; string হলো char-এর অ্যারে, আর প্রতিটি অক্ষর একটি ঘরে (তার সংখ্যামান ASCII অনুযায়ী — পর্ব ১৮)। কিন্তু অ্যারে তো নিজের দৈর্ঘ্য জানে না — তাহলে লেখা কোথায় শেষ? উত্তর: শেষে একটি বিশেষ অক্ষর বসে, '\0' (null character, যার মান ০)। char city[] = "Dhaka"; লিখলে মেমরিতে যা থাকে:

৫টি অক্ষরের জন্য ৬টি ঘর — শেষেরটি '\0'-এর। তাই strlen(city) = 5 (অক্ষর গোনে, '\0' বাদে), কিন্তু sizeof(city) = 6 (অ্যারের মোট বাইট)। ১০ অক্ষরের নাম রাখতে অ্যারে লাগে অন্তত ১১ ঘরের।

String ইনপুট — কোনটি নিরাপদ

অনেক পুরোনো বই ও গাইডে এখনো gets() আছে, আর আধুনিক compiler-এ সেটি warning বা error দেয়। জায়গার চেয়ে বেশি ডেটা লিখে পাশের মেমরি নষ্ট করাকে বলে buffer overflow — ভাবনার প্রশ্ন ২-এ দেখবেন, এটি কত বড় বিপদ ডেকে আনতে পারে। scanf-এও সীমা দেওয়া যায়: scanf("%19s", name); (২০ ঘরের অ্যারের জন্য)।

string.h-এর চারটি কাজের ফাংশন

#include <stdio.h>
#include <string.h>
int main()
{
    char a[20] = "Dhaka", b[20];
    strcpy(b, a);                    /* b = "Dhaka" (কপি) */
    strcat(b, " City");              /* b = "Dhaka City" (জোড়া) */
    printf("%s, length = %d\n", b, (int)strlen(b));
    printf("%d\n", strcmp(a, "Dhaka") == 0);   /* সমান হলে strcmp দেয় 0 */
    return 0;
}

প্রত্যাশিত আউটপুট

Dhaka City, length = 10
1

দুটি ফাঁদ মনে রাখুন। এক, string-এ b = a; বা if (a == b) চলে না — অ্যারের নাম ঠিকানা, তাই প্রথমটি error, আর দ্বিতীয়টি অক্ষর নয়, ঠিকানা তুলনা করে। কপিতে strcpy, তুলনায় strcmp. দুই, strcpy আর strcat-ও জায়গা যাচাই করে না — b যথেষ্ট বড় কি না, সেটি আপনার দায়িত্ব। Palindrome (উল্টো পড়লেও একই, যেমন “madam”, “level”) যাচাইয়ের প্রোগ্রাম আছে অংশ ৮-এর চালানো যায় এমন উদাহরণে।

৬ · ফাংশন — একটি কাজ, একটি নাম

এতক্ষণ সব কোড main-এর ভেতরে লিখেছি। ছোট প্রোগ্রামে চলে, কিন্তু একটি স্কুলের ফলাফল সফটওয়্যারে গড় বের করার কোড যদি দশ জায়গায় লাগে? দশবার কপি করবেন, আর একটি ভুল পেলে দশ জায়গায় ঠিক করবেন? Function এই সমস্যার সমাধান: একটি নির্দিষ্ট কাজের কোডকে একটি নাম দিয়ে প্যাকেট করা, যাতে যখন খুশি নাম ধরে ডাকা যায়।

ফাংশনের সুবিধা তিনটি: পুনর্ব্যবহার (একবার লিখে বহুবার ডাকা), আলাদা করে পরীক্ষা (gcd(48, 18) ঠিক ৬ দেয় কি না, বাকি প্রোগ্রাম ছাড়াই যাচাই করা যায়), আর ভাগ করে কাজ (modularity — বড় সমস্যাকে ছোট ছোট নামওয়ালা টুকরোয় ভাঙা)।

দুই রকম ফাংশন

একটি ফাংশনের তিনটি অংশ

#include <stdio.h>

long power(int base, int exp);         /* ১. prototype (ঘোষণা) — শেষে ; */

int main()
{
    long p = power(2, 10);             /* ২. call — 2 আর 10 হলো argument */
    printf("2^10 = %ld\n", p);
    return 0;
}

long power(int base, int exp)          /* ৩. definition — base, exp হলো parameter */
{
    long result = 1;                   /* local variable */
    int i;
    for (i = 1; i <= exp; i++)
        result = result * base;
    return result;                     /* ফেরত মান */
}

প্রত্যাশিত আউটপুট

2^10 = 1024

• Prototype: compiler ওপর থেকে নিচে পড়ে। main যখন power ডাকে, তখনো definition আসেনি — prototype আগেভাগে জানিয়ে রাখে “এই নামে একটি ফাংশন আছে, দুটি int নেয়, long ফেরত দেয়।” Definition main-এর ওপরে লিখলে prototype না দিলেও চলে।
• Call: power(2, 10) — প্রোগ্রাম ফাংশনে লাফ দেয়, কাজ শেষে ফেরত মান নিয়ে এখানেই ফিরে আসে।
• Definition: header লাইন (ফেরত টাইপ, নাম, parameter) আর { }-এর ভেতরে আসল কাজ। Parameter হলো ফাংশনের “খালি ঘর”, argument হলো ডাকার সময় সেই ঘরে দেওয়া মান।
• return আর void: ফাংশন একবারে একটিই মান ফেরত দিতে পারে। কিছু ফেরত দেওয়ার না থাকলে (যেমন শুধু একটি লাইন ছাপা) ফেরত টাইপ লিখুন void — void printLine(int n).

Scope — কোন ভ্যারিয়েবল কোথায় দেখা যায়

power-এর ভেতরের result আর i হলো local variable — জন্ম ফাংশন ডাকার সময়, মৃত্যু ফাংশন শেষে। main এদের দেখতেই পায় না; চাইলে main-এও আলাদা একটি i রাখা যায়, দুটির মধ্যে কোনো সম্পর্ক নেই। একটি ভ্যারিয়েবলকে কোথা থেকে দেখা যায়, সেটিই তার scope. সব ফাংশনের বাইরে ঘোষণা করলে হয় global variable, যাকে সব ফাংশন দেখে ও বদলাতে পারে। সুবিধাজনক মনে হলেও বড় প্রোগ্রামে global এড়িয়ে চলাই নিয়ম — কোন ফাংশন মানটি বদলাল, খুঁজে বের করা দুঃসাধ্য হয়ে ওঠে। ফাংশনের যা লাগে, parameter দিয়ে নিন; যা দেওয়ার, return দিয়ে দিন।

ফাংশনে অ্যারে পাঠানো

float average(int a[], int n)          /* অ্যারে + তার দৈর্ঘ্য */
{
    int i, sum = 0;
    for (i = 0; i < n; i++)
        sum += a[i];
    return (float)sum / n;
}
/* main-এ: int marks[4] = {60, 70, 80, 90};
           printf("%.1f", average(marks, 4));   ছাপবে 75.0 */

অ্যারের বেলায় দুটি বিশেষ নিয়ম। এক, পুরো অ্যারে কপি হয় না — যায় শুধু শুরুর ঠিকানা। তাই ফাংশন অ্যারের ঘর বদলালে main-এর আসল অ্যারেই বদলায় (এজন্যই একটি sort(a, n) ফাংশন লেখা যায়)। দুই, ঠিকানার সাথে দৈর্ঘ্য যায় না — তাই n আলাদা করে পাঠাতে হয়। ফাংশনের ভেতরে sizeof(a) অ্যারের মাপ দেয় না, দেয় একটি ঠিকানার মাপ।

৭ · Call by value — যে swap কাজ করে না

সাধারণ ভ্যারিয়েবলের বেলায় C-এর নিয়ম হলো call by value: ফাংশন ডাকার সময় argument-এর মানটি কপি হয়ে parameter-এ যায়। ফাংশন নিজের কপি নিয়ে যা খুশি করুক, আসল ভ্যারিয়েবল অক্ষত। এর সবচেয়ে বিখ্যাত প্রমাণ — দুটি সংখ্যা অদলবদলের এই ফাংশন, যা দেখতে নিখুঁত, কিন্তু কাজ করে না:

1void swap(int x, int y) {2    int t = x;3    x = y;4    y = t;5}6int main(void) {7    int a = 10, b = 20;8    swap(a, b);9    printf("a=%d b=%d\n", a, b);10}

৮ · Recursion — যে ফাংশন নিজেকে ডাকে

৪! = ৪ × ৩ × ২ × ১. কিন্তু আরেকভাবেও লেখা যায়: ৪! = ৪ × ৩! — অর্থাৎ বড় সমস্যার উত্তর একই ধরনের একটি ছোট সমস্যার উত্তর দিয়ে। ফাংশন যখন এভাবে নিজেকেই ডাকে, তাকে বলে recursion. কিন্তু “৩! = ৩ × ২!, ২! = ২ × ১!…” — কোথাও থামতে হবে। যে শর্তে ফাংশন আর নিজেকে না ডেকে সরাসরি উত্তর দেয়, সেটি base case: ১! = ১.

প্রতিটি ডাকের তথ্য (তার নিজস্ব n, কোথায় ফিরতে হবে) মেমরির একটি অংশে থাক করে রাখা হয় — একে বলে call stack, অনেকটা ক্যান্টিনে প্লেটের স্তূপের মতো: সবশেষে রাখা প্লেটটি সবার আগে তোলা হয়। factorial(4)-এর পুরো যাত্রা দেখুন:

1long factorial(int n) {2    if (n <= 1) return 1;      /* base case */3    return n * factorial(n - 1);4}5/* main-এ: */6printf("%ld", factorial(4));

Fibonacci (০, ১, ১, ২, ৩, ৫, ৮, …) আরেকটি ক্লাসিক — প্রতিটি সংখ্যা আগের দুটির যোগফল, তাই এখানে base case দুটি:

int fib(int n)
{
    if (n == 0) return 0;              /* base case ১ */
    if (n == 1) return 1;              /* base case ২ */
    return fib(n - 1) + fib(n - 2);
}
/* for (i = 0; i < 8; i++) printf("%d ", fib(i));
   ছাপবে: 0 1 1 2 3 5 8 13 */

সুন্দর, কিন্তু অপচয়ী — fib(5) হিসাব করতে fib(3) দুবার, fib(2) তিনবার আলাদাভাবে হিসাব হয়। n বড় হলে ডাকার সংখ্যা বিস্ফোরণের মতো বাড়ে (ভাবনার প্রশ্ন ৩)। একটি সাধারণ লুপে এটি অনেক দ্রুত হয়।

ক্লাসিক ফাংশন একসাথে — চালিয়ে দেখুন

নিচের প্রোগ্রামে চারটি ফাংশন: মৌলিক সংখ্যা যাচাই, recursive factorial, গসাগু (GCD — ইউক্লিডের পদ্ধতিতে, এটিও recursive), আর palindrome string যাচাই। definition-গুলো main-এর ওপরে, তাই prototype লাগেনি:

#include <stdio.h>
#include <string.h>
int isPrime(int n) {
    if (n < 2) return 0;
    for (int i = 2; i * i <= n; i++)
        if (n % i == 0) return 0;
    return 1;
}
long factorial(int n) { return (n <= 1) ? 1 : n * factorial(n - 1); }
int gcd(int a, int b) { return (b == 0) ? a : gcd(b, a % b); }
int isPalindrome(char s[]) {
    for (int i = 0, j = (int)strlen(s) - 1; i < j; i++, j--)
        if (s[i] != s[j]) return 0;
    return 1;
}
int main(void) {
    printf("isPrime(29) = %d, isPrime(21) = %d\n", isPrime(29), isPrime(21));
    printf("factorial(10) = %ld\n", factorial(10));
    printf("gcd(48, 18) = %d\n", gcd(48, 18));
    printf("madam -> %d, dhaka -> %d\n", isPalindrome("madam"), isPalindrome("dhaka"));
    return 0;
}

সব জোড়া দিয়ে — menu-driven প্রোগ্রাম

বাস্তব প্রোগ্রাম এভাবেই দাঁড়ায়: main শুধু মেনু দেখায় আর সিদ্ধান্ত নেয়, আসল কাজ করে আলাদা ফাংশন। পরীক্ষায় “ফাংশন ব্যবহার করে মেনুভিত্তিক প্রোগ্রাম” প্রায়ই চাওয়া হয়:

#include <stdio.h>

long factorial(int n);
int isPrime(int n);
int gcd(int a, int b);

int main()
{
    int choice, x, y;
    do {
        printf("\n1. Factorial  2. Prime check  3. GCD  0. Exit\nChoice: ");
        if (scanf("%d", &choice) != 1) break;
        switch (choice) {
        case 1: printf("n = ");  scanf("%d", &x);
                printf("%d! = %ld\n", x, factorial(x)); break;
        case 2: printf("n = ");  scanf("%d", &x);
                printf(isPrime(x) ? "Prime\n" : "Not prime\n"); break;
        case 3: printf("a b = "); scanf("%d %d", &x, &y);
                printf("GCD = %d\n", gcd(x, y)); break;
        case 0: printf("Bye\n"); break;
        default: printf("Invalid choice\n");
        }
    } while (choice != 0);
    return 0;
}
/* factorial, isPrime, gcd-এর definition ওপরের প্রোগ্রামের মতোই — main-এর নিচে বসান */

নমুনা চালানো (ইনপুট: 1, 5, 3, 48 18, 0)

1. Factorial  2. Prime check  3. GCD  0. Exit
Choice: 1
n = 5
5! = 120

1. Factorial  2. Prime check  3. GCD  0. Exit
Choice: 3
a b = 48 18
GCD = 6

1. Factorial  2. Prime check  3. GCD  0. Exit
Choice: 0
Bye

৯ · সাধারণ ভুল আর পরীক্ষার প্রস্তুতি

১০ · AI-এর যুগে — AI-এর লেখা C কোড যাচাই

“HSC-র জন্য bubble sort-এর C প্রোগ্রাম দাও” — AI কয়েক সেকেন্ডে দেবে, আর বেশিরভাগ সময় সেটি চলবেও। সমস্যা অন্য জায়গায়। AI শিখেছে ইন্টারনেটের পুরোনো লেখা থেকে, যেখানে gets(), void main(), conio.h আর getch() ভরপুর। আর AI সাধারণত “সুখী পথ” পরীক্ষা করে — n = 0, ঋণাত্মক সংখ্যা, ৫০-এর বেশি শিক্ষার্থী, ফাঁকা string — এসব নিয়ে ভাবে না।

AI-এর C কোড হাতে পেলে — চেকলিস্ট

• gets, conio.h, void main নেই; string ইনপুটে fgets বা সীমাসহ scanf
• প্রতিটি অ্যারে-লুপ i < n, আর n কখনো অ্যারের আকার ছাড়ায় না — যাচাই করা আছে
• edge case-এ চালিয়েছি: n = 1, n = 0, ঋণাত্মক, সব সমান, আগে থেকে সাজানো
• প্রতিটি recursive ফাংশনের base case খুঁজে পেয়েছি, এবং বুঝেছি সেটি সবসময় পৌঁছানো যায়
• অন্তত একটি ফাংশন হাতে dry run করে AI-এর দেওয়া আউটপুটের সাথে মিলিয়েছি

পরীক্ষার খাতায় AI থাকবে না, compiler-ও না। তাই সবচেয়ে কাজের অভ্যাস হলো: প্রতিদিন একটি ক্লাসিক প্রোগ্রাম খাতায় নিজে লিখুন, dry run করুন, তারপর কম্পিউটারে চালিয়ে মিলিয়ে দেখুন। AI-কে বলুন আপনার লেখা কোডের ভুল খুঁজে দিতে — উল্টোটা নয়।