লুপ — for, while, for-each, break আর continue

১ · লুপ কেন — একই কাজ বারবার, শর্ত যতক্ষণ সত্য

পর্ব ১০-এ আপনি শিখেছেন প্রোগ্রাম কীভাবে সিদ্ধান্ত নেয় — শর্ত সত্য হলে এক পথে, মিথ্যা হলে আরেক পথে। কিন্তু সেই সিদ্ধান্ত হয় একবারই। এখন ভাবুন, একটি দোকানের সারাদিনের বিক্রি যোগ করতে হবে। বিক্রি হয়েছে ৩টি, না ৩০০টি — আগে থেকে জানা নেই। প্রতিটির জন্য একটি করে লাইন লেখা অসম্ভব।

এখানেই আসে loop. লুপের মূল ধারণা একটি বাক্যে বলা যায়: একটি শর্ত যতক্ষণ সত্য, ততক্ষণ একই কাজ বারবার করো। প্রতিবার কাজটি একবার করাকে বলে একটি iteration — বাংলায় একটি “ঘোরা”। প্রতিটি ঘোরার আগে (বা পরে) শর্তটি আবার যাচাই হয়। শর্ত মিথ্যা হলেই লুপ শেষ, আর প্রোগ্রাম লুপের পরের লাইনে চলে যায়।

Java আপনাকে চারটি লুপ দেয়। এরা সবাই একই কাজ পারে — যেকোনো একটি দিয়ে বাকিগুলো বানানো যায়। তবু চারটি আছে, কারণ প্রতিটি একটি আলাদা প্রশ্নের সবচেয়ে পরিষ্কার উত্তর। সঠিক লুপ বাছলে কোড পড়েই বোঝা যায় লেখক কী ভাবছিলেন।

২ · for লুপ — শুরু; শর্ত; পরিবর্তন

for লুপ উপরের তিনটি প্রশ্নের উত্তর এক লাইনে, পাশাপাশি লিখতে দেয়। এর গঠন:

• init — শুরুতে একবারই চলে। সাধারণত এখানে একটি loop variable তৈরি হয়, যেমন int i = 0.
• condition — প্রতিটি ঘোরার আগে যাচাই হয়। true হলে body চলে, false হলে লুপ শেষ। Java-তে এটি অবশ্যই boolean হতে হবে।
• update — প্রতিটি ঘোরার শেষে চলে, যেমন i++. এটিই লুপকে থামার দিকে এগিয়ে নেয়।

লেখার ক্রম আর চলার ক্রম এক নয় — update লেখা থাকে শর্তের পরে, কিন্তু চলে body-র পরে। নিচের ছোট সঞ্চয়-হিসাবে প্রতি মাসে ৫০০ টাকা জমা হয়, দুই মাসের জন্য। “পরে” চেপে দেখুন কোন অংশ কখন চলে:

1int total = 0;2for (int m = 1; m <= 2; m++) {3    total += 500;4}5System.out.println("জমা: " + total);

loop variable কোথায় বাঁচে — scope

init-এ তৈরি ভ্যারিয়েবলের scope শুধু লুপের ভেতরে। লুপ শেষ হলে নামটিই মুছে যায়। নিচের কোড compile-ই হবে না:

for (int i = 0; i < 3; i++) {
    System.out.println(i);
}
System.out.println(i);   // লুপের বাইরে i নেই

Main.java:6: error: cannot find symbol
        System.out.println(i);
                           ^
  symbol:   variable i
  location: class Main
1 error

এটি বিরক্তিকর নয়, বরং সুরক্ষা। একটি বড় method-এ পাঁচটি লুপ থাকলে পাঁচটিতেই নিশ্চিন্তে i নাম ব্যবহার করা যায়, কেউ কারও মান নষ্ট করে না। লুপের পরে শেষ মানটি সত্যিই দরকার হলে ভ্যারিয়েবলটি লুপের আগে তৈরি করুন: int i; for (i = 0; i < 3; i++) { … }.

৩ · while আর do-while — কখন থামবে আগে জানা নেই

একটি মুদি দোকানে দিনের শেষে দোকানদার একটি একটি করে বিক্রির টাকা কম্পিউটারে লেখেন। সব লেখা হলে লেখেন 0 — মানে “আজকের হিসাব শেষ”। প্রোগ্রাম জানে না কয়টি সংখ্যা আসবে; জানে শুধু কোন সংকেতে থামতে হবে। এই বিশেষ থামার সংকেতকে বলে sentinel (পাহারাদার)। এমন কাজের জন্য সবচেয়ে মানানসই while লুপ:

for-এর মতো init বা update-এর জন্য আলাদা জায়গা নেই — শুধু শর্ত। শুরু করার কাজ লুপের আগে, আর পরিবর্তনের কাজ body-র ভেতরে নিজেকে করতে হয়। ইনপুট পড়া হয় Scanner দিয়ে (পর্ব ০৯)। ধরুন দোকানদার লিখলেন 250, 1200, 480, তারপর 0:

1int total = 0;2int sale = in.nextInt();3while (sale != 0) {4    total += sale;5    sale = in.nextInt();6}7System.out.println("মোট " + total);

এবার একই ধারণা পুরো প্রোগ্রামে, সাথে গোনা (count), সবচেয়ে বড় (max) আর সবচেয়ে ছোট (min) বিক্রি। নিচের রান বোতাম চাপুন:

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int total = 0, count = 0;
        int max = Integer.MIN_VALUE, min = Integer.MAX_VALUE;
        int sale = in.nextInt();            // প্রথম বিক্রি
        while (sale != 0) {                 // 0 = আজকের হিসাব শেষ
            total += sale;
            count++;
            max = Math.max(max, sale);
            min = Math.min(min, sale);
            sale = in.nextInt();            // পরের বিক্রি
        }
        if (count == 0) {
            System.out.println("আজ কোনো বিক্রি হয়নি");
        } else {
            System.out.println("বিক্রি " + count + "টি, মোট " + total + " টাকা");
            System.out.println("সবচেয়ে বড় " + max + ", সবচেয়ে ছোট " + min);
            System.out.println("গড় " + (total / count) + " টাকা");
        }
    }
}

do-while — আগে একবার, তারপর শর্ত

bKash-এর USSD মেনু ভাবুন: মেনুটি অন্তত একবার দেখাতেই হবে, তারপর ব্যবহারকারী বেছে নেবেন — আবার দেখাব, না বের হব। এখানে শর্ত যাচাই body-র পরে হওয়াই স্বাভাবিক। এজন্য আছে do-while লুপ:

Scanner in = new Scanner(System.in);
int choice;                     // লুপের বাইরে — নিচের শর্তে লাগবে
do {
    System.out.println("1. ব্যালান্স  2. টাকা পাঠান  0. বের হন");
    choice = in.nextInt();
    // পছন্দ অনুযায়ী কাজ — পর্ব ১০-এর switch এখানে বসবে
} while (choice != 0);          // শেষে সেমিকোলন লাগে

দুটি জিনিস খেয়াল করুন। প্রথমত, while (...)-এর পরে ; বাধ্যতামূলক — শুধু do-while-এ। দ্বিতীয়ত, choice তৈরি হয়েছে লুপের বাইরে। body-র { }-এর ভেতরে তৈরি করলে নিচের শর্তে তাকে দেখা যেত না, কারণ শর্তটি block-এর বাইরে — সেই scope-এর নিয়ম। বাস্তবে do-while তুলনামূলক কম ব্যবহৃত হয়; বেশিরভাগ কাজ while বা for দিয়েই পরিষ্কারভাবে হয়ে যায়। তবে “অন্তত একবার” কথাটি সত্যিই সমস্যার অংশ হলে do-while-ই সৎ উত্তর।

৪ · for-each — index ছাড়াই প্রতিটি জিনিস

বেশিরভাগ লুপের আসল কাজ একটাই: একটি তালিকার প্রতিটি জিনিস একবার করে দেখা। Index দিয়ে করলে তিনটি জিনিস ঠিক রাখতে হয় — শুরু 0 থেকে, থামা length-এর আগে, আর প্রতিবার i++. তিনটিতেই ভুলের সুযোগ। Java 5 (২০০৪) থেকে এর একটি সরল রূপ আছে — enhanced for, যাকে সবাই বলে for-each লুপ:

int[] marks = {72, 28, 20};          // array — বিস্তারিত পর্ব ১৩-এ
for (int m : marks) {                 // পড়ুন: "marks-এর প্রতিটি m-এর জন্য"
    System.out.println(m);
}

List<String> subjects = List.of("বাংলা", "গণিত", "ইংরেজি");
for (String s : subjects) {           // List-এও একইভাবে (পর্ব ৩০)
    System.out.println(s);
}

এখানে array আর List দুটোই ছোট উদাহরণ হিসেবে ব্যবহার করা হয়েছে — array পুরোপুরি শিখবেন পর্ব ১৩-এ, আর List পর্ব ৩০-এ। আপাতত এটুকু জানলেই চলবে: দুটোতেই কয়েকটি মান সারি বেঁধে থাকে। কোলনটিকে (:) পড়ুন “এর মধ্যে” — marks-এর মধ্যের প্রতিটি m-এর জন্য। কোনো index নেই, কোনো length নেই, তাই off-by-one ভুলের সুযোগও নেই। Java 10 থেকে টাইপের জায়গায় var লেখা যায়: for (var s : subjects).

ভেতরে কী হয়? Array হলে compiler নিজেই একটি সাধারণ index লুপ বানিয়ে নেয়। আর List-এর মতো collection হলে ব্যবহার করে একটি Iterator — একটি ছোট object, যে মনে রাখে কোথায় আছে আর “পরেরটা আছে?” (hasNext()) ও “পরেরটা দাও” (next()) প্রশ্নের উত্তর দেয়। যে class Iterable interface মানে, তার ওপর for-each চলে। তাই আপনার নিজের বানানো class-ও চাইলে for-each-এ চালানো যায় (interface পর্ব ২১-এ)।

কখন তবু index লাগে

for-each সবসময় যথেষ্ট নয়। চারটি পরিস্থিতিতে সাধারণ for লাগে:

• অবস্থান জানতে হলে — “৩ নম্বর বিষয়ে ফেল”। for-each জিনিস দেয়, তার ক্রমিক নম্বর দেয় না।
• দুটি তালিকা পাশাপাশি চালাতে হলে — subjects[i] আর marks[i] একসাথে।
• উল্টো দিকে বা লাফিয়ে চলতে হলে — শেষ থেকে শুরুতে, বা প্রতি দ্বিতীয়টি।
• array-র ঘরে নতুন মান বসাতে হলে — এটি সবচেয়ে বিভ্রান্তিকর, নিচে দেখুন।

৫ · break আর continue — লুপ থামানো আর একটি ঘোরা বাদ দেওয়া

কখনো শর্ত যাচাইয়ের নির্দিষ্ট জায়গার আগেই লুপ থামানো দরকার। ধরুন রেজাল্ট দেখছেন, আর জানতে চান প্রথম কোন বিষয়ে ফেল। প্রথমটি পেয়ে গেলে বাকি বিষয় দেখার কোনো মানে নেই। এজন্য break — এটি সবচেয়ে কাছের লুপটি সঙ্গে সঙ্গে শেষ করে দেয় (পর্ব ১০-এ switch-এর ভেতরেও break দেখেছেন — কাজ একই, “এই কাঠামো থেকে বেরিয়ে যাও”)।

আর continue লুপ থামায় না — শুধু এই ঘোরার বাকি অংশ বাদ দিয়ে পরের ঘোরায় চলে যায়। for লুপে continue-এর পর update (i++) ঠিকই চলে, তারপর শর্ত। নিচের প্রোগ্রামে দুটোই আছে — একজনের ১২ মাসের সঞ্চয় পরিকল্পনা (প্রতি তিন মাসে একবার ছাপা), আর প্রথম ফেল করা বিষয় খোঁজা:

class Main {
    public static void main(String[] args) {
        int monthly = 1500;                   // প্রতি মাসে জমা, টাকা
        int saved = 0;
        for (int month = 1; month <= 12; month++) {
            saved += monthly;
            if (month == 6) monthly += 500;   // ৬ মাস পর জমা বাড়ল
            if (month % 3 != 0) continue;     // শুধু প্রতি ৩ মাসে ছাপো
            System.out.println("মাস " + month + ": " + saved + " টাকা");
        }

        String[] subjects = {"বাংলা", "গণিত", "ইংরেজি"};
        int[] marks = {72, 28, 20};
        for (int i = 0; i < subjects.length; i++) {
            if (marks[i] < 33) {
                System.out.println("প্রথম ফেল: " + subjects[i] + " (" + marks[i] + ")");
                break;                        // ইংরেজি আর দেখাই হবে না
            }
        }
    }
}

৬ · লুপের ভেতরে লুপ — নামতা, প্যাটার্ন আর labeled break

একটি লুপের body-তে আরেকটি লুপ থাকতে পারে — একে বলে nested loop. বাইরের লুপের প্রতিটি ঘোরায় ভেতরের লুপ পুরোটা চলে। ঘড়ির কাঁটার মতো: মিনিটের কাঁটা একবার ঘুরলে ঘণ্টার কাঁটা এক ঘর এগোয়। বাইরের লুপ ৪ বার আর ভেতরের ৪ বার হলে ভেতরের body চলে ৪ × ৪ = ১৬ বার।

ধরুন ছোট ভাইয়ের জন্য ১ থেকে ৪-এর নামতার একটি ছক বানাবেন। বাইরের লুপ সারি (i), ভেতরের লুপ কলাম (j):

for (int i = 1; i <= 4; i++) {           // প্রতিটি সারি
    for (int j = 1; j <= 4; j++) {       // সেই সারির প্রতিটি কলাম
        System.out.printf("%4d", i * j);  // ৪ ঘর জায়গা নিয়ে ছাপো
    }
    System.out.println();                 // সারি শেষ — নতুন লাইন
}

   1   2   3   4
   2   4   6   8
   3   6   9  12
   4   8  12  16

তারার প্যাটার্ন একই কৌশল, শুধু ভেতরের লুপ কতবার চলবে তা বাইরের লুপের ওপর নির্ভর করে — সারি ১-এ ১টি তারা, সারি ২-এ ২টি:

for (int row = 1; row <= 4; row++) {
    for (int star = 1; star <= row; star++) {   // row যত, তারা তত
        System.out.print("*");
    }
    System.out.println();
}

*
**
***
****

(Java 11 থেকে ভেতরের লুপটি এক লাইনে লেখা যায়: System.out.println("*".repeat(row)); — তবে প্যাটার্ন বানানোর প্রশ্নে পরীক্ষক সাধারণত nested loop-ই দেখতে চান।)

দুই লুপ থেকে একবারে বের হওয়া — labeled break

একটি সমস্যা আছে: ভেতরের লুপে break লিখলে শুধু ভেতরের লুপ থামে, বাইরেরটি পরের সারিতে চলতে থাকে। কিন্তু ধরুন খুঁজছেন প্রথম কোন সারি-কলামে গুণফল 4 — পেয়ে গেলে দুটো লুপই থামাতে চান। Java-র উত্তর labeled break: বাইরের লুপের আগে একটি নাম (label) আর কোলন বসান, তারপর break সেই_নাম;:

1outer:2for (int r = 1; r <= 3; r++) {3    for (int c = 1; c <= 3; c++) {4        if (r * c == 4) {5            System.out.println(r + " x " + c);6            break outer;7        }8    }9}10System.out.println("শেষ");

একইভাবে continue outer; ভেতরের লুপের বাকি অংশ বাদ দিয়ে সরাসরি বাইরের লুপের পরের ঘোরায় চলে যায় — যেমন “এই সারিতে একটি খারাপ মান পেলেই পুরো সারিটা বাদ”।

৭ · লুপের তিন চেনা ফাঁদ — অসীম লুপ, off-by-one আর ঘোরার মাঝে তালিকা বদলানো

ফাঁদ ১ — যে লুপ কখনো থামে না

অসীম লুপ দুই রকম। ইচ্ছাকৃত — যেমন একটি সার্ভার যে সারাদিন অনুরোধের অপেক্ষায় থাকে: while (true) { … }, ভেতরে কোনো এক জায়গায় পরিষ্কার break বা return. আর অনিচ্ছাকৃত — যেখানে অংশ ১-এর তৃতীয় প্রশ্নের (“প্রতিবার কী বদলাবে?”) উত্তর ভুল। কয়েকটি চেনা উদাহরণ:

অসীম লুপে প্রোগ্রাম “ঝুলে” যায়, CPU-র একটি core পুরো ব্যস্ত থাকে। Terminal-এ Ctrl + C চেপে থামান; IDE-তে লাল Stop বোতাম। আর অভ্যাস করুন: প্রতিটি লুপ লেখার পর নিজেকে জিজ্ঞেস করুন — “কোন লাইনটি শর্তকে মিথ্যার দিকে এগিয়ে নিচ্ছে?”

ফাঁদ ২ — এক ঘর বেশি বা কম: off-by-one

প্রোগ্রামিংয়ের সবচেয়ে পুরোনো আর সবচেয়ে সাধারণ ভুলগুলোর একটি off-by-one error — লুপ এক বার বেশি বা এক বার কম চলা। মূল কারণ: Java-র array-র index শুরু হয় 0 থেকে, তাই ৩টি ঘরের index 0, 1, 2 — শেষ ঘরটি length - 1, length নয়। কেউ অভ্যাসবশে <= লিখলেই বিপদ:

1int[] marks = {72, 28, 20};2for (int i = 0; i <= marks.length; i++) {3    System.out.println(marks[i]);4}

off-by-one শুধু array-তে নয়। “১ থেকে ১০ পর্যন্ত” মানে ১০ সহ, তাই i <= 10. “১০ বার” মানে for (int i = 0; i < 10; i++) অথবা for (int i = 1; i <= 10; i++) — দুটোই ঠিক, শুধু মিশিয়ে ফেলবেন না। সন্দেহ হলে সবচেয়ে ছোট ক্ষেত্রটি হাতে চালিয়ে দেখুন: তালিকায় ১টি জিনিস থাকলে লুপ কতবার চলে? ০টি থাকলে?

ফাঁদ ৩ — for-each চলার সময় তালিকা থেকে মোছা

ধরুন একটি ArrayList-এ নম্বর আছে, আর ফেল করা (৩৩-এর কম) নম্বরগুলো মুছে দিতে চান। স্বাভাবিক চিন্তা — for-each দিয়ে ঘুরি, কম পেলে মুছি:

List<Integer> marks = new ArrayList<>(List.of(30, 25, 80, 20, 90));
for (Integer m : marks) {
    if (m < 33) marks.remove(m);      // ঘোরার মাঝে তালিকা বদলানো — ভুল
}

Exception in thread "main" java.util.ConcurrentModificationException
	at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:...)
	at java.base/java.util.ArrayList$Itr.next(ArrayList.java:...)
	at Main.main(Main.java:...)

অংশ ৪-এ দেখেছেন, for-each ভেতরে একটি Iterator ব্যবহার করে। Iterator মনে রাখে তালিকাটি কতবার বদলেছে। আপনি তাকে না জানিয়ে সরাসরি marks.remove ডাকলে পরের next()-এ সে টের পায় যে তালিকা তার অজান্তে বদলে গেছে, আর সাথে সাথে ConcurrentModificationException ছুড়ে দেয়। নামে “concurrent” থাকলেও এখানে কোনো thread নেই — একটিমাত্র লুপই যথেষ্ট। এই আচরণকে বলে fail-fast: ভুল ফল চুপচাপ দেওয়ার চেয়ে সাথে সাথে থেমে যাওয়া ভালো। (তবে এটি নিশ্চয়তা নয় — যেমন শেষের আগের জিনিসটি মুছলে লুপ কখনো কখনো কোনো exception ছাড়াই চুপচাপ শেষ হয়ে যায়, আর শেষ জিনিসটি দেখাই হয় না। তাই exception না এলেও কোডটি ভুল।)

সঠিক উপায় এক লাইনের: marks.removeIf(m -> m < 33); — ফল [80, 90]. এর ভেতরের m -> m < 33 অংশটি একটি lambda (পর্ব ৩৪)। আরেকটি উপায় হলো Iterator নিজের হাতে চালিয়ে it.remove() ডাকা। List-এর পুরো গল্প পর্ব ৩০-এ।

৮ · Accumulator প্যাটার্ন, আধুনিক বিকল্প আর লুপের গতি

অংশ ৩-এর দোকানের প্রোগ্রামে চারটি ভ্যারিয়েবল প্রতিটি ঘোরায় একটু একটু করে ফল জমাচ্ছিল। এই কাঠামো এত বেশি দেখা যায় যে একে আলাদা নামে চেনা ভালো — accumulator প্যাটার্ন। চারটি মূল রূপ মুখস্থ নয়, চিনে রাখুন:

Java 8 (২০১৪) থেকে এই কাজগুলো লুপ না লিখেও করা যায় Stream দিয়ে। নিচের কোডটি শুধু এক ঝলক — Stream পুরোপুরি শিখবেন পর্ব ৩৫-এ:

int[] sales = {250, 1200, 480};
int total  = Arrays.stream(sales).sum();                      // 1930
int max    = Arrays.stream(sales).max().getAsInt();           // 1200
long big   = Arrays.stream(sales).filter(s -> s >= 500).count();  // 1

Stream-এ আপনি বলেন কী চাই (“যোগফল”, “৫০০-র বেশিগুলো গোনো”); লুপে বলেন কীভাবে (“0 থেকে শুরু করো, প্রতিটি যোগ করো”)। শেখার শুরুতে লুপ দিয়েই লিখুন — ভেতরে কী হয় তা বোঝা জরুরি, আর পরীক্ষা-ইন্টারভিউতে প্রায়ই লুপই চাওয়া হয়। পরে দুটোই চিনে রাখলে অবস্থা বুঝে বেছে নিতে পারবেন (ভাবনার প্রশ্ন ৫ দেখুন)।

লুপ কি ধীর? — JIT-এর কথা

নতুনরা অনেক সময় ভয় পান, “এক কোটি বার লুপ চালালে প্রোগ্রাম আটকে যাবে”। Java-তে সাধারণত তা হয় না। পর্ব ০৫-এ দেখেছেন, JVM বারবার চলা কোড চিহ্নিত করে JIT compiler দিয়ে আসল machine code বানায়। লুপ ঠিক সেই “গরম” কোড। main-এর ভেতরের একটি লম্বা লুপও চলার মাঝখানেই compile হয়ে যেতে পারে — এই কৌশলের নাম on-stack replacement. compile হওয়ার পর একটি সরল সংখ্যা-যোগের লুপ সাধারণ কম্পিউটারে প্রতি সেকেন্ডে কোটি কোটি ঘোরা দিতে পারে।

তাই গতির জন্য লুপকে কুৎসিত করবেন না। আসল খরচ প্রায় সবসময় লুপের ভেতরের কাজে: প্রতিটি ঘোরায় ফাইল খোলা, ডেটাবেসে প্রশ্ন পাঠানো, বা String-এ += দিয়ে বিশাল লেখা জোড়া (পর্ব ০৮-এর StringBuilder মনে আছে?)। আর nested loop-এ গুণ করে ভাবুন — ১০,০০০ × ১০,০০০ মানে দশ কোটি ঘোরা। অ্যালগরিদমের এই হিসাব পর্ব ৫৪-এ।

৯ · AI-এর যুগে — AI-এর লেখা লুপ যাচাই

লুপ লেখা AI-এর কাছে সহজ কাজ, আর তার লেখা লুপ প্রথম দেখায় প্রায় সবসময় ঠিক মনে হয়। কিন্তু লুপের বাগ লুকিয়ে থাকে প্রান্তে — প্রথম ঘোরা, শেষ ঘোরা, খালি তালিকা। AI সাধারণ ক্ষেত্রটি ঠিক লেখে, প্রান্ত ভুলে যায়। কিছু চেনা ধরন:

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

• শর্তে < না <= — শুরুর মানের সাথে মিলিয়ে দেখেছি (0 থেকে হলে <)
• খালি তালিকা আর এক জিনিসের তালিকা দিয়ে লুপটি মনে মনে চালিয়েছি
• প্রতিটি while-এ খুঁজে পেয়েছি কোন লাইন শর্তকে মিথ্যার দিকে নেয়; while (true) থাকলে প্রতিটি বের হওয়ার পথ চিহ্নিত করেছি
• index শুধু পড়ার জন্য ব্যবহার হলে for-each দিয়ে বদলে দেখেছি — কোড ছোট আর পরিষ্কার হলো কি না
• for-each-এর ভেতরে add/remove নেই; থাকলে removeIf বা Iterator দিয়ে বদলেছি
• max/min-এর শুরুর মান আর বড় যোগফলের টাইপ (int না long) যাচাই করেছি