লুপ — একই কাজ বারবার করানোর কৌশল (while, for, do-while)

১ · কম্পিউটারের আসল শক্তি — একই কাজ হাজারবার

নির্বাচনের রাতে একটি কেন্দ্রে ভোট গোনা হচ্ছে। দুই হাজার ব্যালট। প্রতিটি ব্যালট হাতে নিয়ে দেখা, কোন প্রার্থীর ঘরে সিল, তারপর সেই প্রার্থীর হিসাবে একটি দাগ। কাজটি কঠিন নয় — কিন্তু দুই হাজারবার করতে হবে। মানুষ ক্লান্ত হয়, মনোযোগ হারায়, গুনতে ভুল করে। কম্পিউটার এর কোনোটাই করে না।

প্রোগ্রামিংয়ের বেশিরভাগ বাস্তব কাজ আসলে এই রকম। একটি দোকানের পুরো মাসের বিক্রি যোগ করা। একটি স্কুলের ৮০০ ছাত্রের প্রত্যেকের ফল দেখে কে পাস, কে ফেল তা বের করা। bKash-এর মতো একটি সেবায় প্রতিটি লেনদেন যাচাই করা। প্রতিটি ক্ষেত্রে কাজটি একটাই, শুধু বারবার করতে হবে — প্রতিবার ভিন্ন ডেটা নিয়ে।

একই নির্দেশ বারবার চালানোর ব্যবস্থাকে বলে loop. লুপের প্রতিটি একবার ঘোরাকে বলে একটি iteration. যে অংশটি বারবার চলে, সেটি লুপের body, আর যে প্রশ্নের উত্তর দেখে লুপ ঠিক করে আরেকবার ঘুরবে কি না, সেটি loop condition.

পর্ব ০২-এ আপনি দেখেছিলেন, pattern recognition থেকেই লুপের জন্ম — একই ছাঁচ বারবার দেখা গেলে সেটিকে একবার লিখে বারবার ব্যবহার করা। আর পর্ব ১১-এ শিখেছেন if দিয়ে সিদ্ধান্ত নেওয়া। লুপকে আপনি ভাবতে পারেন “বারবার জিজ্ঞেস করা if” হিসেবে: শর্ত সত্য হলে কাজটি করো, তারপর আবার শর্তটি জিজ্ঞেস করো।

২ · while — শর্ত যতক্ষণ সত্য, ততক্ষণ চলো

সবচেয়ে সরল লুপ হলো while loop. ইংরেজি “while” মানে “যতক্ষণ”। এর গঠন:

while (condition) {
    /* body: condition সত্য থাকলে এই অংশ চলে */
}

নিয়মটি খুব সহজ। প্রথমে শর্ত যাচাই হয়। সত্য হলে body একবার চলে, তারপর আবার শর্তে ফিরে আসে। মিথ্যা হলে body বাদ দিয়ে লুপের পরের লাইনে চলে যায়। খেয়াল করুন, শর্ত আগে দেখা হয় — তাই শুরুতেই শর্ত মিথ্যা হলে body একবারও চলে না।

একটি চায়ের দোকানের কথা ভাবুন। সকালে ফ্লাস্কে ৩০ কাপ চা আছে। দোকানি জানেন না আজ কতজন খদ্দের আসবেন — তাঁর নিয়ম শুধু: “যতক্ষণ ফ্লাস্কে চা আছে, খদ্দের এলে এক কাপ দাও।” এখানে আগে থেকে জানা নেই লুপ কতবার ঘুরবে। জানা আছে শুধু কখন থামতে হবে। এমন পরিস্থিতিতেই while সবচেয়ে স্বাভাবিক।

int cups = 30;
while (cups > 0) {
    /* একজন খদ্দেরকে এক কাপ দেওয়া হলো */
    cups = cups - 1;        // অগ্রগতি: এটি না থাকলে লুপ কখনো থামবে না
}

৩ · for — গোনার কাজ, তিনটি অংশ এক লাইনে

অনেক লুপে আগে থেকেই জানা থাকে কতবার ঘুরবে — ১ থেকে ৬০ পর্যন্ত রোল, মাসের ৩০ দিন, ১২ মাস। এমন লুপে একটি counter ভ্যারিয়েবল থাকে, যা প্রতিবার এক এক করে বাড়ে। এই কাজটির জন্যই for loop:

for (init; condition; update) {
    /* body */
}

for (int roll = 1; roll <= 60; roll++) {
    /* roll নম্বর ছাত্রের উপস্থিতি নাও */
}

লক্ষ করুন, লেখার ক্রম আর চলার ক্রম এক নয়। update লেখা আছে শর্তের ঠিক পাশে, কিন্তু চলে body-র পরে। এই জায়গাটিতেই নতুনরা সবচেয়ে বেশি গুলিয়ে ফেলেন। নিচের debugger-এ ১, ৩, ৫ — এই বিজোড় সংখ্যাগুলোর যোগফল বের হচ্ছে, আর counter প্রতিবার ২ করে বাড়ছে। “পরে” চাপুন, আর ডানের “এখন চলছে” সারিটি খেয়াল করুন। সবুজ দাগের লাইনটি এইমাত্র চলেছে।

1#include <stdio.h>23int main(void) {4    int sum = 0;5    for (int i = 1; i <= 5; i += 2) {6        sum = sum + i;7    }8    printf("sum = %d\n", sum);9    return 0;10}

for আর while — আসলে একই জিনিস, দুই চেহারায়

উপরের for লুপটি while দিয়েও লেখা যায়। পাশাপাশি রাখলে বোঝা যায়, for আসলে কিছু নতুন করে না — শুধু ছড়িয়ে থাকা তিনটি অংশকে এক লাইনে গুছিয়ে রাখে।

int i = 1;              // ① init
while (i <= 5) {        // ② condition
    sum = sum + i;      // ③ body
    i += 2;             // ④ update
}

তাহলে for কেন? কারণ পাঠকের চোখ এক লাইনেই পুরো লুপের নিয়ন্ত্রণ দেখতে পায়: কোথা থেকে শুরু, কোথায় শেষ, কীভাবে এগোয়। body লম্বা হলে while-এর update লাইনটি নিচে কোথাও হারিয়ে যায়, আর ভুলে বাদ পড়ার সম্ভাবনা বাড়ে। for-এ তিনটি অংশ একসাথে থাকায় কোনোটি বাদ পড়লে চোখে লাগে।

৪ · do-while — আগে কাজ, পরে প্রশ্ন

কিছু কাজ আছে যা অন্তত একবার করতেই হবে, তারপর প্রশ্ন আসে আবার করব কি না। মোবাইলে *247# ডায়াল করলে আগে মেনু আসে — তারপরই আপনি বেছে নেন কী করবেন, নাকি বেরিয়ে যাবেন। মেনু না দেখিয়ে তো জিজ্ঞেস করা যায় না “আবার দেখাব?” এমন পরিস্থিতির জন্য do-while loop:

do {
    /* মেনু দেখাও, ব্যবহারকারীর পছন্দ পড়ো */
} while (choice != 0);      // শেষে সেমিকোলন লাগে!

এখানে শর্ত থাকে নিচে। তাই body আগে একবার চলে, তারপর শর্ত দেখা হয়। শর্ত শুরু থেকেই মিথ্যা হলে কী হয়, দুটি লুপ পাশাপাশি রেখে দেখুন:

1int choice = 0;2while (choice != 0) {3    printf("while body\n");4}5do {6    printf("do body\n");7} while (choice != 0);8printf("done\n");

কোন লুপ কখন বেছে নেবেন

৫ · লুপের তিন ধরন আর জমানোর ছাঁচ

লুপ কীভাবে থামে, সেই অনুযায়ী তাদের তিন ভাগে ভাবা যায়। এই ভাগগুলো চিনলে নতুন সমস্যা দেখে দ্রুত বুঝবেন কোন ছাঁচ লাগবে।

তৃতীয় ধরনটি একটু বুঝিয়ে বলি। ধরুন দোকানের ক্যাশিয়ার একের পর এক জিনিসের দাম টাইপ করছেন। কয়টি জিনিস, তা প্রোগ্রাম জানে না। তাই নিয়ম করা হলো: “দাম শেষ হলে 0 লিখুন।” এই 0 কোনো আসল দাম নয় — এটি একটি পাহারাদার সংকেত, যাকে বলে sentinel. শর্ত হলো: “যতক্ষণ পড়া মান sentinel নয়, ততক্ষণ চলো।”

Accumulator — লুপের ভেতরে ফল জমানো

লুপ নিজে কোনো উত্তর দেয় না — উত্তর জমা হয় একটি ভ্যারিয়েবলে, প্রতিবার একটু একটু করে। এই ভ্যারিয়েবলকে বলে accumulator, অনেকটা মাটির ব্যাংকের মতো, যেখানে প্রতিদিন কয়েকটি টাকা পড়ে। চারটি ছাঁচ প্রায় সব প্রোগ্রামে বারবার দেখবেন:

সর্বোচ্চ খোঁজার ছাঁচটি পর্ব ০২-এ আপনি loop invariant দিয়ে প্রমাণ করেছিলেন — “এখন পর্যন্ত দেখা মানগুলোর সবচেয়ে বড়টি max-এ আছে।” একই চিন্তা বাকি তিনটিতেও খাটে: sum হলো “এখন পর্যন্ত দেখা মানগুলোর যোগফল”, count হলো “এখন পর্যন্ত কয়টি দেখা হয়েছে”। লুপ শেষে “এখন পর্যন্ত” মানে “সবগুলো” — তাই উত্তর ঠিক।

নিচের প্রোগ্রামটি একসাথে চারটি ছাঁচই ব্যবহার করে। নম্বর পড়ে -1 না আসা পর্যন্ত, তারপর কয়টি, গড় আর সর্বোচ্চ দেখায়। ইনপুট আগে থেকেই দেওয়া আছে: 72 85 64 91 -1.

#include <stdio.h>

int main(void) {
    int mark, count = 0, sum = 0, max = 0;
    printf("Enter marks (-1 to stop):\n");
    while (scanf("%d", &mark) == 1 && mark != -1) {
        if (count == 0 || mark > max)
            max = mark;          // first mark, or a new highest
        sum += mark;             // accumulator: total
        count++;                 // counter: how many
    }
    if (count == 0) {
        printf("No marks entered.\n");
    } else {
        printf("Count: %d\n", count);
        printf("Average: %.2f\n", (double)sum / count);
        printf("Highest: %d\n", max);
    }
    return 0;
}

৬ · Off-by-one — বেড়ার খুঁটির পুরোনো ধাঁধা

একটি প্রশ্ন দিয়ে শুরু করি। আপনার বাড়ির সামনে ১০ মিটার লম্বা একটি বেড়া দেবেন। প্রতি ১ মিটার পরপর একটি খুঁটি পুঁততে হবে, দুই মাথাতেও খুঁটি থাকবে। কয়টি খুঁটি কিনবেন?

প্রথম মনে আসে ১০। কিন্তু উত্তর ১১। কারণ খুঁটি বসে মিটারের দাগে — ০, ১, ২, … ১০ — আর ০ থেকে ১০ পর্যন্ত দাগ ১১টি। খুঁটির মাঝের ফাঁক (রেলিং) ১০টি। “ফাঁক গুনছি, না খুঁটি গুনছি?” — এই গুলিয়ে ফেলাকে বলে fencepost error. আর লুপ একবার বেশি বা একবার কম ঘুরলে তাকে বলে off-by-one error — প্রোগ্রামিংয়ের সবচেয়ে পরিচিত বাগগুলোর একটি।

নিচের প্রোগ্রামটি ৪ মিটারের একটি বেড়া এঁকে খুঁটি গুনছে। + হলো খুঁটি, --- হলো দুই খুঁটির মাঝের রেলিং। ধাপে ধাপে দেখুন, শেষ খুঁটিটি কোন iteration-এ আসে:

1#include <stdio.h>23int main(void) {4    int posts = 0;5    for (int m = 0; m <= 4; m++) {6        printf("+");7        posts++;8        if (m < 4) printf("---");9    }10    printf("\nposts = %d\n", posts);11    return 0;12}

< নাকি <= — একটি সহজ অভ্যাস

C-তে প্রায় সব গোনা 0 থেকে শুরু হয় (পর্ব ১৬-এ array-তে এর কারণ পরিষ্কার হবে)। তাই সবচেয়ে প্রচলিত ও নিরাপদ ছাঁচটি হলো:

এই ধরনের পরিসরকে বলে half-open range — শুরুর মানটি ভেতরে, শেষের মানটি বাইরে। এর তিনটি সুবিধা: কতবার ঘুরবে তা সরাসরি পড়া যায় (শেষ − শুরু = n), খালি পরিসর (n = 0) নিজে থেকেই ঠিকমতো সামলায়, আর দুটি পরিসর জোড়া দিলে মাঝখানে কিছু দুবার গোনা হয় না, বাদও পড়ে না।

৭ · অসীম লুপ — কখনো দুর্ঘটনা, কখনো নকশা

যে লুপের শর্ত কখনো মিথ্যা হয় না, সেটি চিরকাল ঘুরতে থাকে — একে বলে infinite loop. প্রোগ্রাম আটকে যায়, CPU-র ব্যবহার বেড়ে যায়, কিছুই ছাপা হয় না (বা অনবরত ছাপা হতেই থাকে)। Terminal-এ এমন প্রোগ্রাম থামাতে Ctrl + C চাপুন।

দুর্ঘটনায় তৈরি অসীম লুপ — চারটি পরিচিত ফাঁদ

/* ১. অগ্রগতি ভুলে যাওয়া */
int i = 0;
while (i < 10) { printf("%d\n", i); }       // i কখনো বাড়ে না

/* ২. ঠিক মানটি লাফিয়ে পার হয়ে যাওয়া */
for (int x = 0; x != 10; x += 3) { }        // 0, 3, 6, 9, 12 ... 10 কখনো আসে না

/* ৩. শর্তের পরে ভুল সেমিকোলন */
while (i < 10);                              // ; নিজেই একটি ফাঁকা body!
{ i++; }

/* ৪. দশমিক সংখ্যার সমতা */
for (double d = 0.0; d != 1.0; d += 0.1) { } // 0.1 দশবার যোগে ঠিক 1.0 হয় না

দ্বিতীয় আর চতুর্থ ফাঁদের সমাধান একই: থামার শর্তে != না লিখে < লিখুন। x < 10 হলে 12-তে পৌঁছেও লুপ থামবে। চতুর্থটির কারণ আপনি পর্ব ০৫-এ দেখেছেন — 0.1 বাইনারিতে হুবহু রাখা যায় না, তাই floating-point যোগফল 1.0-এর খুব কাছে গিয়েও সমান হয় না। তৃতীয়টি সবচেয়ে চতুর: সেমিকোলনটিকেই compiler লুপের body ভাবে, নিচের { i++; } লুপের অংশই নয়।

ইচ্ছা করে বানানো অসীম লুপ

মজার ব্যাপার হলো, পৃথিবীর অনেক গুরুত্বপূর্ণ প্রোগ্রাম ইচ্ছা করেই চিরকাল চলে। C-তে এটি সাধারণত এভাবে লেখা হয়:

while (1) {             // অথবা for (;;)
    wait_for_next_event();
    handle_it();
}

৮ · break, continue আর লুপের ভেতরে লুপ

break — কাজ হয়ে গেছে, এবার বের হও

৬০ জনের তালিকায় একটি নির্দিষ্ট রোল খুঁজছেন। ১২ নম্বরেই পেয়ে গেলেন। বাকি ৪৮টি দেখার আর দরকার নেই। break লুপটিকে সেই মুহূর্তেই থামিয়ে লুপের পরের লাইনে নিয়ে যায় — শর্ত যা-ই থাকুক।

for (int roll = 1; roll <= 60; roll++) {
    if (roll == target) {
        printf("Found roll %d\n", roll);
        break;              // বাকি iteration বাদ, লুপ থেকে সোজা বাইরে
    }
}

continue — এটি বাদ দাও, পরেরটিতে যাও

continue লুপ থামায় না — শুধু এই iteration-এর বাকি অংশ বাদ দিয়ে পরের iteration-এ চলে যায়। ধরুন নম্বর পড়ার সময় কেউ ভুল করে 150 লিখল। সেটি বাদ দিয়ে পরের নম্বর পড়তে চান:

while (scanf("%d", &mark) == 1 && mark != -1) {
    if (mark < 0 || mark > 100)
        continue;           // অবৈধ নম্বর: যোগ না করেই পরের ইনপুটে
    sum += mark;
    count++;
}

লুপের ভেতরে লুপ — সারি আর আসন

হলরুমে পরীক্ষার আসন সাজানো হচ্ছে। প্রতিটি সারির জন্য সেই সারির প্রতিটি আসনে একটি রোল নম্বর বসাতে হবে। “প্রতিটি সারির জন্য” একটি লুপ, আর তার ভেতরে “প্রতিটি আসনের জন্য” আরেকটি লুপ। একে বলে nested loop. ২টি সারি আর প্রতি সারিতে ৩টি আসন নিয়ে দেখুন, ভেতরের লুপ কীভাবে প্রতিটি সারিতে নতুন করে শুরু হয়:

1for (int r = 1; r <= 2; r++) {2    for (int s = 1; s <= 3; s++) {3        printf("R%dS%d  ", r, s);4    }5    printf("\n");6}

এবার একটি পরিচিত nested loop নিজে চালিয়ে দেখুন — নামতার ছক। বাইরের লুপ সারি (r), ভেতরের লুপ কলাম (c), আর প্রতিটি ঘরে r × c. %4d প্রতিটি সংখ্যাকে ৪ ঘর চওড়া জায়গায় বসায়, তাই কলামগুলো সোজা থাকে।

#include <stdio.h>

int main(void) {
    int n = 5;
    printf("   |");
    for (int c = 1; c <= n; c++)
        printf("%4d", c);                 // header row
    printf("\n---+--------------------\n");
    for (int r = 1; r <= n; r++) {        // outer loop: rows
        printf("%2d |", r);
        for (int c = 1; c <= n; c++) {    // inner loop: columns
            printf("%4d", r * c);
        }
        printf("\n");                     // end of one row
    }
    return 0;
}

লুপের ভেতরে লুপ — খরচ কত দ্রুত বাড়ে

এই গুণের নিয়মটি নিরীহ দেখালেও বাস্তবে খুব গুরুত্বপূর্ণ। ধরুন একটি কলেজের ১০,০০০ ছাত্রের মধ্যে একই মোবাইল নম্বর দুবার আছে কি না দেখতে চান, আর প্রত্যেককে বাকি প্রত্যেকের সাথে মিলিয়ে দেখছেন — দুটি nested loop দিয়ে। তুলনা হবে প্রায় ১০,০০০ × ১০,০০০ = ১০ কোটি বার। ছাত্র ১০ গুণ বাড়লে কাজ বাড়বে ১০০ গুণ। এক লুপের ভেতরে আরেক লুপ মানেই খরচ গুণ হয়ে যাওয়া। এই খরচ মাপার আনুষ্ঠানিক ভাষা — time complexity আর Big-O — আসবে পর্ব ৩৯-এ। আপাতত শুধু অভ্যাসটি গড়ুন: nested loop দেখলেই জিজ্ঞেস করুন, “n বড় হলে কী হবে?”

৯ · AI-এর যুগে — লুপ যাচাইয়ের দক্ষতা

লুপ লেখা AI-এর জন্য খুব সহজ কাজ, আর বেশিরভাগ সময় সে ঠিকই লেখে। সমস্যা হলো, লুপের ভুলগুলো চোখে পড়ে না — কোড পরিপাটি দেখায়, compile হয়, সাধারণ ইনপুটে ঠিক উত্তরও দেয়। ভুলটি ধরা পড়ে সীমানায়: খালি তালিকা, শেষ উপাদান, খুব বড় সংখ্যা। AI-এর দেওয়া লুপ হাতে পেলে তাই কোড পড়ার আগে তিনটি প্রশ্ন করুন: কোথা থেকে শুরু? কখন থামে? সত্যিই কি থামে?

AI-এর লেখা লুপে যেসব ভুল প্রায়ই দেখা যায়

AI-এর লুপ হাতে পেলে — যাচাইয়ের চেকলিস্ট

• প্রতিটি লুপের শুরু, শর্ত আর অগ্রগতি — তিনটিই খুঁজে পেয়েছি, আর অগ্রগতি সত্যিই শর্তকে মিথ্যার দিকে নিয়ে যায়
• প্রথম ও শেষ iteration-এ counter-এর মান হাতে বের করেছি — < আর <= ঠিক জায়গায় আছে
• খালি ইনপুট (০টি), একটি ইনপুট আর অনেক বড় ইনপুট দিয়ে চালিয়েছি
• উল্টো গোনার লুপে unsigned নেই, আর যোগফলের টাইপ যথেষ্ট বড়
• প্রতিটি accumulator ঠিক জায়গায় শূন্য করা হয়েছে, আর nested loop-এর খরচ n বড় হলে কতটা বাড়বে তা ভেবে দেখেছি