"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { blockquote: "blockquote", code: "code", h3: "h3", h4: "h4", hr: "hr", li: "li", ol: "ol", p: "p", pre: "pre", span: "span", strong: "strong", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {Answer, Assessment, CodeBlock, ComparisonTable, ContentAttribution, DefinitionEntry, DefinitionGroup, English, Explanation, FormulaBox, Hinglish, ImportantQA, KeyPoints, MCQ, Practical, Prompt, QAQuestion, Remember, SubTopicHeader, Theory, TopicOverview, Warning} = _components; if (!Answer) _missingMdxReference("Answer", true); if (!Assessment) _missingMdxReference("Assessment", true); if (!CodeBlock) _missingMdxReference("CodeBlock", true); if (!ComparisonTable) _missingMdxReference("ComparisonTable", true); if (!ContentAttribution) _missingMdxReference("ContentAttribution", true); if (!DefinitionEntry) _missingMdxReference("DefinitionEntry", true); if (!DefinitionGroup) _missingMdxReference("DefinitionGroup", true); if (!English) _missingMdxReference("English", true); if (!Explanation) _missingMdxReference("Explanation", true); if (!FormulaBox) _missingMdxReference("FormulaBox", true); if (!Hinglish) _missingMdxReference("Hinglish", true); if (!ImportantQA) _missingMdxReference("ImportantQA", true); if (!KeyPoints) _missingMdxReference("KeyPoints", true); if (!MCQ) _missingMdxReference("MCQ", true); if (!Practical) _missingMdxReference("Practical", true); if (!Prompt) _missingMdxReference("Prompt", true); if (!QAQuestion) _missingMdxReference("QAQuestion", true); if (!Remember) _missingMdxReference("Remember", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Theory) _missingMdxReference("Theory", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); if (!Warning) _missingMdxReference("Warning", true); return _jsxs(_Fragment, { children: [_jsxs(Theory, { children: [_jsx(SubTopicHeader, { id: "2.2", title: "Looping Statements: while, do…while, and for Loop" }), _jsxs(TopicOverview, { title: "Looping Statements in C", topicId: "2.2", readingTime: "8 min read", difficulty: "Medium", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["In programming, there are many situations where we need to execute a block of code repeatedly — like printing numbers from 1 to 100, reading data until the user says \"stop\", or processing each element of an array. Writing the same statement 100 times is neither practical nor elegant. This is where ", _jsx(_components.strong, { children: "looping statements" }), " come to the rescue. A loop allows us to execute a set of statements multiple times based on a condition. C language provides three fundamental looping constructs: the ", _jsx(_components.strong, { children: "while" }), " loop, the ", _jsx(_components.strong, { children: "do…while" }), " loop, and the ", _jsx(_components.strong, { children: "for" }), " loop. Each has its own syntax, behavior, and ideal use case. Understanding how these loops work — and how they differ — is essential for writing efficient and bug-free C programs."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Programming mein kaafi situations hoti hain jahan hume ek block of code ko baar baar execute karna hota hai — jaise numbers 1 se 100 tak print karna, user ke \"stop\" bolne tak data padhte rehna, ya array ke har element ko process karna. Same statement 100 baar likhna na practical hai na elegant. Yahi par ", _jsx(_components.strong, { children: "looping statements" }), " kaam aati hain. Loop hume ek set of statements ko condition ke basis par multiple times execute karne deta hai. C language mein teen fundamental looping constructs hain: ", _jsx(_components.strong, { children: "while" }), " loop, ", _jsx(_components.strong, { children: "do…while" }), " loop, aur ", _jsx(_components.strong, { children: "for" }), " loop. Har loop ka apna syntax, behavior, aur ideal use case hai. In loops ko samajhna — aur kaise different hain ye jaanna — efficient aur bug-free C programs likhne ke liye zaroori hai."] }) })] }), _jsxs(DefinitionGroup, { children: [_jsxs(DefinitionEntry, { term: "Loop", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "loop" }), " is a control structure that repeatedly executes a block of code as long as a specified condition remains true. Think of it like a conveyor belt in a factory — items keep moving through until someone turns off the machine."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Loop" }), " ek control structure hai jo ek block of code ko tab tak repeatedly execute karta hai jab tak ek specified condition true rahe. Isko aise samjho jaise factory mein ek conveyor belt — items tab tak move karte rehte hain jab tak koi machine band na kar de."] }) })] }), _jsxs(DefinitionEntry, { term: "Iteration", children: [_jsx(English, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Iteration" }), " refers to a single pass through the loop body — one complete execution of all statements inside the loop. If a loop runs 5 times, we say it has completed 5 iterations."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Iteration" }), " ka matlab hai loop body se ek baar guzarna — loop ke andar ke saare statements ka ek baar complete execution. Agar loop 5 baar chala, toh hum kehte hain ki 5 iterations complete hue."] }) })] }), _jsxs(DefinitionEntry, { term: "While Loop", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["The ", _jsx(_components.strong, { children: "while loop" }), " is an entry-controlled loop — it checks the condition ", _jsx(_components.strong, { children: "before" }), " executing the loop body. If the condition is true, the body executes; if false, the loop is skipped entirely. It is ideal when you don't know in advance how many times the loop should run."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "While loop" }), " ek entry-controlled loop hai — ye condition ko loop body execute karne ", _jsx(_components.strong, { children: "se pehle" }), " check karta hai. Agar condition true hai, toh body execute hoti hai; agar false hai, toh loop bilkul skip ho jaata hai. Ye tab useful hai jab aapko pehle se pata na ho ki loop kitni baar chalega."] }) })] }), _jsxs(DefinitionEntry, { term: "Do…While Loop", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["The ", _jsx(_components.strong, { children: "do…while loop" }), " is an exit-controlled loop — it executes the loop body ", _jsx(_components.strong, { children: "first" }), ", and then checks the condition. This guarantees the loop body runs ", _jsx(_components.strong, { children: "at least once" }), ", even if the condition is false from the start. It's useful when you need to perform an action before validating a condition (like showing a menu before asking the user to continue)."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Do…while loop" }), " ek exit-controlled loop hai — ye pehle loop body execute karta hai, ", _jsx(_components.strong, { children: "phir" }), " condition check karta hai. Iska matlab hai ki loop body ", _jsx(_components.strong, { children: "kam se kam ek baar" }), " zaroor execute hoti hai, chahe condition pehle se hi false ho. Ye tab useful hai jab aapko condition validate karne se pehle koi action karna ho (jaise menu dikhana user se continue puchne se pehle)."] }) })] }), _jsxs(DefinitionEntry, { term: "For Loop", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["The ", _jsx(_components.strong, { children: "for loop" }), " is a compact, entry-controlled loop that combines initialization, condition checking, and increment/decrement — all in a single line. It is the most commonly used loop when the number of iterations is known beforehand, such as iterating over array elements or running a counter."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "For loop" }), " ek compact, entry-controlled loop hai jo initialization, condition checking, aur increment/decrement — sab ek hi line mein combine karta hai. Ye sabse zyada use hone wala loop hai jab iteration ki sankhya pehle se pata ho, jaise array elements par iterate karna ya counter chalana."] }) })] }), _jsxs(DefinitionEntry, { term: "Infinite Loop", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["An ", _jsx(_components.strong, { children: "infinite loop" }), " is a loop whose condition never becomes false, causing it to run forever (or until the program is forcefully terminated). This is usually a bug caused by forgetting to update the loop variable, but sometimes it's intentional (like in server programs that run continuously)."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Infinite loop" }), " ek aisa loop hai jiski condition kabhi false nahi hoti, jisse ye hamesha chalta rehta hai (ya program forcefully band hone tak). Ye aamtaur par ek bug hota hai jo loop variable update karna bhoolne se hota hai, lekin kabhi-kabhi ye intentional bhi hota hai (jaise server programs jo continuously chalte hain)."] }) })] })] }), _jsxs(Explanation, { children: [_jsx(_components.h3, { children: "🔄 General Flow of a Loop" }), _jsxs(_components.p, { children: ["All three loops in C follow a similar underlying logic — they all involve a ", _jsx(_components.strong, { children: "condition check" }), ", ", _jsx(_components.strong, { children: "body execution" }), ", and some form of ", _jsx(_components.strong, { children: "update" }), ". Here's the big picture:"] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart TD\r\n A[\"Start\"] --> B[\"Initialize Variables\"]\r\n B --> C{\"Condition True?\"}\r\n C -- Yes --> D[\"Execute Loop Body\"]\r\n D --> E[\"Update Loop Variable\"]\r\n E --> C\r\n C -- No --> F[\"Exit Loop\"]\r\n F --> G[\"Continue after loop\"]\n" }) }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "🔁 The while Loop" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.strong, { children: "while" }), " loop is the simplest looping construct in C. It evaluates the condition first, and only if it's true, does it execute the body. This makes it an ", _jsx(_components.strong, { children: "entry-controlled" }), " loop."] }), _jsx(_components.h4, { children: "📐 Syntax" }), _jsx(CodeBlock, { language: "c", children: `while (condition) { // loop body — statements to repeat // update variable to eventually make condition false }` }), _jsx(_components.h4, { children: "🔧 How It Works" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.code, { children: "condition" }), " is evaluated. If it's ", _jsx(_components.strong, { children: "true" }), ", proceed to step 2. If ", _jsx(_components.strong, { children: "false" }), ", skip to step 4."] }), "\n", _jsx(_components.li, { children: "All statements inside the loop body are executed." }), "\n", _jsx(_components.li, { children: "Control goes back to step 1 (re-check the condition)." }), "\n", _jsx(_components.li, { children: "Loop ends — control moves to the statement after the loop." }), "\n"] }), _jsx(_components.h4, { children: "📌 Example: Print numbers 1 to 5" }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int i = 1; // initialization (before the loop) while (i <= 5) { // condition check printf("%d ", i); i++; // update — increment i by 1 } printf("\\nLoop finished!\\n"); return 0; }` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Output:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { children: "1 2 3 4 5\r\nLoop finished!\n" }) }), _jsx(_components.h4, { children: "⚠️ What happens without the update?" }), _jsxs(_components.p, { children: ["If you forget ", _jsx(_components.code, { children: "i++" }), ", the condition ", _jsx(_components.code, { children: "i <= 5" }), " will ", _jsx(_components.strong, { children: "always remain true" }), ", creating an ", _jsx(_components.strong, { children: "infinite loop" }), ". The program will keep printing ", _jsx(_components.code, { children: "1" }), " forever!"] }), _jsx(CodeBlock, { language: "c", children: `// ⚠️ DANGEROUS — Infinite loop! while (i <= 5) { printf("%d ", i); // i++ is missing → condition never becomes false }` }), _jsx(_components.h4, { children: "📌 Example: Sum of natural numbers until user enters 0" }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int num, sum = 0; printf("Enter numbers (0 to stop): "); scanf("%d", &num); while (num != 0) { sum += num; scanf("%d", &num); } printf("Sum = %d\\n", sum); return 0; }` }), _jsxs(_components.p, { children: ["In this example, we ", _jsx(_components.strong, { children: "don't know in advance" }), " how many numbers the user will enter — which is exactly why the ", _jsx(_components.code, { children: "while" }), " loop is the right choice here."] }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "🔃 The do…while Loop" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.strong, { children: "do…while" }), " loop is almost like the while loop, with one key difference: it executes the body ", _jsx(_components.strong, { children: "first" }), " and checks the condition ", _jsx(_components.strong, { children: "afterward" }), ". This makes it an ", _jsx(_components.strong, { children: "exit-controlled" }), " loop."] }), _jsx(_components.h4, { children: "📐 Syntax" }), _jsx(CodeBlock, { language: "c", children: `do { // loop body — statements to repeat // update variable } while (condition); // ⚠️ note the semicolon here!` }), _jsxs(_components.blockquote, { children: ["\n", _jsxs(_components.p, { children: ["⚠️ ", _jsx(_components.strong, { children: "Common Mistake:" }), " Many students forget the semicolon ", _jsx(_components.code, { children: ";" }), " after ", _jsx(_components.code, { children: "while(condition)" }), ". This is ", _jsx(_components.strong, { children: "mandatory" }), " in ", _jsx(_components.code, { children: "do…while" }), " — don't forget it!"] }), "\n"] }), _jsx(_components.h4, { children: "🔧 How It Works" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: ["The loop body is executed ", _jsx(_components.strong, { children: "unconditionally" }), " (at least once)."] }), "\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.code, { children: "condition" }), " is evaluated. If ", _jsx(_components.strong, { children: "true" }), ", go back to step 1. If ", _jsx(_components.strong, { children: "false" }), ", proceed to step 3."] }), "\n", _jsx(_components.li, { children: "Loop ends — control moves to the statement after the loop." }), "\n"] }), _jsx(_components.h4, { children: "📌 Example: Print numbers 1 to 5 using do…while" }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int i = 1; do { printf("%d ", i); i++; } while (i <= 5); printf("\\nLoop finished!\\n"); return 0; }` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Output:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { children: "1 2 3 4 5\r\nLoop finished!\n" }) }), _jsx(_components.h4, { children: "🔍 The Key Difference — At Least One Execution" }), _jsxs(_components.p, { children: ["Let's see what happens when the condition is ", _jsx(_components.strong, { children: "false from the very beginning" }), ":"] }), _jsx(CodeBlock, { language: "c", children: `int i = 10; // while loop — body NEVER executes while (i <= 5) { printf("while: %d\\n", i); i++; } // do…while loop — body executes ONCE do { printf("do-while: %d\\n", i); i++; } while (i <= 5);` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Output:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { children: "do-while: 10\n" }) }), _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "while" }), " loop printed ", _jsx(_components.strong, { children: "nothing" }), " because the condition was false from the start. But the ", _jsx(_components.code, { children: "do…while" }), " loop printed ", _jsx(_components.code, { children: "10" }), " because it executed the body ", _jsx(_components.strong, { children: "before" }), " checking the condition."] }), _jsx(_components.h4, { children: "📌 Example: Menu-driven program (classic use case for do…while)" }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int choice; do { printf("\\n--- Menu ---\\n"); printf("1. Addition\\n"); printf("2. Subtraction\\n"); printf("3. Exit\\n"); printf("Enter your choice: "); scanf("%d", &choice); if (choice == 1) printf("You chose Addition\\n"); else if (choice == 2) printf("You chose Subtraction\\n"); else if (choice == 3) printf("Goodbye!\\n"); else printf("Invalid choice!\\n"); } while (choice != 3); return 0; }` }), _jsxs(_components.p, { children: ["Here, we ", _jsx(_components.strong, { children: "need" }), " to show the menu at least once — which is exactly why ", _jsx(_components.code, { children: "do…while" }), " is the perfect fit."] }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "🔢 The for Loop" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.strong, { children: "for" }), " loop is the most versatile and commonly used loop in C. It bundles three critical parts — ", _jsx(_components.strong, { children: "initialization" }), ", ", _jsx(_components.strong, { children: "condition" }), ", and ", _jsx(_components.strong, { children: "update" }), " — into one clean line."] }), _jsx(_components.h4, { children: "📐 Syntax" }), _jsx(CodeBlock, { language: "c", children: `for (initialization; condition; update) { // loop body }` }), _jsx(_components.h4, { children: "🔧 How It Works (Step by Step)" }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Step" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Action" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "1" }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "initialization" }), " runs ", _jsx(_components.strong, { children: "once" }), " (e.g., ", _jsx(_components.code, { children: "int i = 0" }), ")"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "2" }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "condition" }), " is evaluated. If ", _jsx(_components.strong, { children: "false" }), ", skip to step 5"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "3" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Loop body executes" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "4" }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "update" }), " runs (e.g., ", _jsx(_components.code, { children: "i++" }), "), then go back to step 2"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "5" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Loop ends — control moves after the for loop" })] })] })] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart TD\r\n A[\"int i = 0 (init — runs once)\"] --> B{\"i < 5 ?\"}\r\n B -- Yes --> C[\"Execute body\"]\r\n C --> D[\"i++ (update)\"]\r\n D --> B\r\n B -- No --> E[\"Loop ends\"]\n" }) }), _jsx(_components.h4, { children: "📌 Example: Print numbers 1 to 5" }), _jsx(CodeBlock, { language: "c", children: `#include int main() { for (int i = 1; i <= 5; i++) { printf("%d ", i); } printf("\\n"); return 0; }` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Output:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { children: "1 2 3 4 5\n" }) }), _jsx(_components.h4, { children: "📌 Example: Sum of first 10 natural numbers" }), _jsx(FormulaBox, { title: "Formula Used", children: _jsx(_components.span, { className: "katex-display", children: _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6833em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "Sum" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "2.9291em", verticalAlign: "-1.2777em" } }), _jsx(_components.span, { className: "mop op-limits", children: _jsxs(_components.span, { className: "vlist-t vlist-t2", children: [_jsxs(_components.span, { className: "vlist-r", children: [_jsxs(_components.span, { className: "vlist", style: { height: "1.6514em" }, children: [_jsxs(_components.span, { style: { top: "-1.8723em", marginLeft: "0em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "3.05em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsxs(_components.span, { className: "mord mtight", children: [_jsx(_components.span, { className: "mord mathnormal mtight", children: "i" }), _jsx(_components.span, { className: "mrel mtight", children: "=" }), _jsx(_components.span, { className: "mord mtight", children: "1" })] }) })] }), _jsxs(_components.span, { style: { top: "-3.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "3.05em" } }), _jsx(_components.span, { children: _jsx(_components.span, { className: "mop op-symbol large-op", children: "∑" }) })] }), _jsxs(_components.span, { style: { top: "-4.3em", marginLeft: "0em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "3.05em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mtight", children: _jsx(_components.span, { className: "mord mathnormal mtight", children: "n" }) }) })] })] }), _jsx(_components.span, { className: "vlist-s", children: "" })] }), _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "1.2777em" }, children: _jsx(_components.span, {}) }) })] }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.1667em" } }), _jsx(_components.span, { className: "mord mathnormal", children: "i" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "2.113em", verticalAlign: "-0.686em" } }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mopen nulldelimiter" }), _jsx(_components.span, { className: "mfrac", children: _jsxs(_components.span, { className: "vlist-t vlist-t2", children: [_jsxs(_components.span, { className: "vlist-r", children: [_jsxs(_components.span, { className: "vlist", style: { height: "1.427em" }, children: [_jsxs(_components.span, { style: { top: "-2.314em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "3em" } }), _jsx(_components.span, { className: "mord", children: _jsx(_components.span, { className: "mord", children: "2" }) })] }), _jsxs(_components.span, { style: { top: "-3.23em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "3em" } }), _jsx(_components.span, { className: "frac-line", style: { borderBottomWidth: "0.04em" } })] }), _jsxs(_components.span, { style: { top: "-3.677em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "3em" } }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } }), _jsx(_components.span, { className: "mbin", children: "+" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } }), _jsx(_components.span, { className: "mord", children: "1" }), _jsx(_components.span, { className: "mclose", children: ")" })] })] })] }), _jsx(_components.span, { className: "vlist-s", children: "" })] }), _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.686em" }, children: _jsx(_components.span, {}) }) })] }) }), _jsx(_components.span, { className: "mclose nulldelimiter" })] })] })] }) }) }) }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int n = 10, sum = 0; for (int i = 1; i <= n; i++) { sum += i; } printf("Sum of first %d numbers = %d\\n", n, sum); return 0; }` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Output:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { children: "Sum of first 10 numbers = 55\n" }) }), _jsx(_components.h4, { children: "💡 Flexible Variations of the for Loop" }), _jsx(_components.p, { children: "The for loop is incredibly flexible. Here are some valid variations:" }), _jsx(CodeBlock, { language: "c", children: `// Variation 1: Multiple initializations and updates for (int i = 0, j = 10; i < j; i++, j--) { printf("i=%d, j=%d\\n", i, j); } // Variation 2: Infinite loop (no condition) for (;;) { // runs forever — use break to exit } // Variation 3: Decrementing loop for (int i = 5; i >= 1; i--) { printf("%d ", i); // prints: 5 4 3 2 1 }` }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "🆚 Comparison of All Three Loops" }), _jsx(ComparisonTable, { title: "While vs Do…While vs For Loop", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Feature" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "while" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "do…while" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "for" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Control Type" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Entry-controlled" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Exit-controlled" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Entry-controlled" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Condition Check" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Before body" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "After body" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Before body" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Minimum Executions" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "0" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "1" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "0" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Best Used When" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Iterations unknown" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Must run at least once" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Iterations known" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Syntax" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "while(cond)" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "do {} while(cond);" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "for(init; cond; incr)" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Initialization" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Before the loop" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Before the loop" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Inside the for statement" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Update" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Inside body (manual)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Inside body (manual)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Part of for statement" })] })] })] }) }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "🧠 When to Use Which Loop?" }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart TD\r\n Q1{\"Do you know the\\nnumber of iterations?\"}\r\n Q1 -- Yes --> Q2{\"Need to execute\\nat least once?\"}\r\n Q1 -- No --> Q3{\"Should the body\\nexecute at least once?\"}\r\n Q2 -- No --> FOR[\"✅ Use for loop\"]\r\n Q2 -- Yes --> DOWHILE1[\"✅ Use do…while loop\"]\r\n Q3 -- No --> WHILE[\"✅ Use while loop\"]\r\n Q3 -- Yes --> DOWHILE2[\"✅ Use do…while loop\"]\n" }) }), _jsx(_components.hr, {}), _jsx(_components.h3, { children: "📌 Key Takeaways" }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.strong, { children: "while" }), " loop checks the condition ", _jsx(_components.strong, { children: "before" }), " each iteration — the body may execute ", _jsx(_components.strong, { children: "zero times" }), "."] }), "\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.strong, { children: "do…while" }), " loop checks the condition ", _jsx(_components.strong, { children: "after" }), " each iteration — the body ", _jsx(_components.strong, { children: "always executes at least once" }), "."] }), "\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.strong, { children: "for" }), " loop bundles initialization, condition, and update in one line — ideal when the number of iterations is ", _jsx(_components.strong, { children: "known" }), "."] }), "\n", _jsxs(_components.li, { children: ["Always ensure the loop variable is ", _jsx(_components.strong, { children: "updated" }), " inside the body; otherwise, an ", _jsx(_components.strong, { children: "infinite loop" }), " will occur."] }), "\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.code, { children: "do…while" }), " loop requires a ", _jsx(_components.strong, { children: "semicolon" }), " after ", _jsx(_components.code, { children: "while(condition)" }), " — a very common exam mistake."] }), "\n", _jsxs(_components.li, { children: ["For menu-driven programs, ", _jsx(_components.code, { children: "do…while" }), " is the most natural choice since the menu should be shown at least once."] }), "\n"] }) }), _jsx(_components.h3, { children: "⚠️ Common Mistakes to Avoid" }), _jsx(Warning, { title: "Common Loop Mistakes in C", children: _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Forgetting the semicolon" }), " in ", _jsx(_components.code, { children: "do…while" }), ": Writing ", _jsx(_components.code, { children: "while(i <= 5)" }), " instead of ", _jsx(_components.code, { children: "while(i <= 5);" }), " will cause a compilation error."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Infinite loops" }), ": Not updating the loop variable (e.g., forgetting ", _jsx(_components.code, { children: "i++" }), ") makes the condition永远 true."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Off-by-one errors" }), ": Using ", _jsx(_components.code, { children: "<" }), " instead of ", _jsx(_components.code, { children: "<=" }), " (or vice versa) leads to one extra or one fewer iteration than intended."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Using the wrong loop type" }), ": Using ", _jsx(_components.code, { children: "while" }), " when ", _jsx(_components.code, { children: "for" }), " would be cleaner, or using ", _jsx(_components.code, { children: "for" }), " when the number of iterations is truly unknown."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Modifying the loop variable inside the body" }), ": Accidentally changing ", _jsx(_components.code, { children: "i" }), " inside a ", _jsx(_components.code, { children: "for" }), " loop body can produce unexpected behavior."] }), "\n"] }) })] })] }), "\n", _jsx(Practical, { children: _jsxs(ImportantQA, { children: [_jsxs(QAQuestion, { marks: 2, children: [_jsx(Prompt, { children: "What is a looping statement? List the three types of loops available in C." }), _jsxs(Answer, { children: [_jsx(_components.h3, { children: "🎯 Definition" }), _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "looping statement" }), " (also called an iteration construct) is a control structure that ", _jsx(_components.strong, { children: "repeatedly executes" }), " a block of code as long as a specified condition remains true. It eliminates the need to write the same statements multiple times manually."] }), _jsx(_components.h3, { children: "📝 Three Types of Loops in C" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: [_jsx(_components.code, { children: "while" }), " loop"] }), " — Entry-controlled loop; the condition is checked ", _jsx(_components.strong, { children: "before" }), " the loop body executes."] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: [_jsx(_components.code, { children: "do...while" }), " loop"] }), " — Exit-controlled loop; the condition is checked ", _jsx(_components.strong, { children: "after" }), " the loop body executes."] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: [_jsx(_components.code, { children: "for" }), " loop"] }), " — A compact loop that combines initialization, condition check, and update in a single statement."] }), "\n"] }), _jsx(Remember, { children: _jsx(_components.p, { children: "Without loops, programmers would need to copy-paste the same statements repeatedly, making the code long, repetitive, and error-prone." }) })] })] }), _jsxs(QAQuestion, { marks: 4, children: [_jsx(Prompt, { children: "Compare while loop and do...while loop with their syntax and explain one key difference in their execution." }), _jsxs(Answer, { children: [_jsxs(_components.p, { children: ["Both ", _jsx(_components.strong, { children: "while" }), " and ", _jsx(_components.strong, { children: "do...while" }), " loops provide repetition, but they differ in ", _jsx(_components.strong, { children: "when" }), " the condition is evaluated."] }), _jsx(_components.h3, { children: "🔹 While Loop Syntax" }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "while (condition) {\r\n // body of loop\r\n}\n" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["The condition is checked ", _jsx(_components.strong, { children: "before" }), " executing the loop body."] }), "\n", _jsxs(_components.li, { children: ["If the condition is false from the beginning, the body ", _jsx(_components.strong, { children: "never executes" }), " (zero iterations possible)."] }), "\n"] }), _jsx(_components.h3, { children: "🔹 Do...While Loop Syntax" }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "do {\r\n // body of loop\r\n} while (condition);\n" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["The loop body executes ", _jsx(_components.strong, { children: "first" }), ", and then the condition is checked."] }), "\n", _jsxs(_components.li, { children: ["The body ", _jsx(_components.strong, { children: "always executes at least once" }), ", even if the condition is false."] }), "\n", _jsxs(_components.li, { children: ["Note the ", _jsx(_components.strong, { children: "semicolon" }), " ", _jsx(_components.code, { children: ";" }), " after the ", _jsx(_components.code, { children: "while" }), " condition — this is mandatory."] }), "\n"] }), _jsx(_components.h3, { children: "📊 Key Differences" }), _jsx(ComparisonTable, { title: "While Loop vs Do...While Loop", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Aspect" }), _jsx(_components.th, { children: "while Loop" }), _jsx(_components.th, { children: "do...while Loop" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Control Type" }) }), _jsx(_components.td, { children: "Entry-controlled" }), _jsx(_components.td, { children: "Exit-controlled" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Condition Check" }) }), _jsx(_components.td, { children: "Before loop body" }), _jsx(_components.td, { children: "After loop body" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Minimum Iterations" }) }), _jsx(_components.td, { children: "0 (may skip entirely)" }), _jsx(_components.td, { children: "1 (always runs at least once)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Semicolon after condition" }) }), _jsx(_components.td, { children: "Not required" }), _jsx(_components.td, { children: "Required" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Typical Use Case" }) }), _jsx(_components.td, { children: "General iteration where body may not need to run" }), _jsx(_components.td, { children: "Menu-driven programs, input validation" })] })] })] }) }), _jsx(_components.h3, { children: "💡 Example Demonstrating the Difference" }), _jsx(CodeBlock, { language: "c", children: `int a = 10; while (a < 5) { printf("%d ", a); // This will NOT execute at all a++; } int b = 10; do { printf("%d ", b); // This WILL execute once, printing 10 b++; } while (b < 5);` }), _jsxs(_components.p, { children: ["In the above example, the ", _jsx(_components.strong, { children: "while loop" }), " prints nothing because the condition ", _jsx(_components.code, { children: "10 < 5" }), " is false from the start. The ", _jsx(_components.strong, { children: "do...while loop" }), " prints ", _jsx(_components.code, { children: "10" }), " once before checking the condition."] })] })] }), _jsxs(QAQuestion, { marks: 6, children: [_jsx(Prompt, { children: "Explain the working of a for loop with its syntax. Write a C program using a for loop to calculate the sum of all even numbers from 1 to 100." }), _jsxs(Answer, { children: [_jsx(_components.h3, { children: "🎯 For Loop – Syntax and Working" }), _jsxs(_components.p, { children: ["The ", _jsxs(_components.strong, { children: [_jsx(_components.code, { children: "for" }), " loop"] }), " is the most compact and widely used looping construct in C. It combines three expressions in a single line:"] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "for (initialization; condition; update) {\r\n // body of loop\r\n}\n" }) }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Step-by-step execution flow:" }) }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Initialization" }), " — Executed only ", _jsx(_components.strong, { children: "once" }), " before the loop begins (e.g., ", _jsx(_components.code, { children: "int i = 1" }), ")."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Condition" }), " — Evaluated before each iteration. If ", _jsx(_components.strong, { children: "true" }), ", the body executes; if ", _jsx(_components.strong, { children: "false" }), ", the loop terminates."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Body" }), " — The set of statements inside the loop braces."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Update" }), " — Executed after each iteration (e.g., ", _jsx(_components.code, { children: "i++" }), " or ", _jsx(_components.code, { children: "i = i + 2" }), ")."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Repeat" }), " from step 2."] }), "\n"] }), _jsx(_components.h3, { children: "🔄 Execution Flowchart" }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart TD\r\n A[Start] --> B[\"i = 2\"]\r\n B --> C{\"i <= 100 ?\"}\r\n C -->|Yes| D[\"sum = sum + i\"]\r\n D --> E[\"i = i + 2\"]\r\n E --> C\r\n C -->|No| F[\"Print sum\"]\r\n F --> G[End]\n" }) }), _jsx(_components.h3, { children: "💻 C Program: Sum of Even Numbers from 1 to 100" }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int i, sum = 0; for (i = 2; i <= 100; i = i + 2) { sum = sum + i; } printf("Sum of even numbers from 1 to 100 = %d\\n", sum); return 0; }` }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Output:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { children: "Sum of even numbers from 1 to 100 = 2550\n" }) }), _jsx(_components.h3, { children: "📝 Program Explanation" }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Loop Part" }), _jsx(_components.th, { children: "Value" }), _jsx(_components.th, { children: "Purpose" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Initialization" }) }), _jsx(_components.td, { children: _jsx(_components.code, { children: "i = 2" }) }), _jsx(_components.td, { children: "Start from the first even number" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Condition" }) }), _jsx(_components.td, { children: _jsx(_components.code, { children: "i <= 100" }) }), _jsxs(_components.td, { children: ["Continue as long as ", _jsx(_components.code, { children: "i" }), " does not exceed 100"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Update" }) }), _jsx(_components.td, { children: _jsx(_components.code, { children: "i = i + 2" }) }), _jsx(_components.td, { children: "Jump to the next even number (skip odd)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Body" }) }), _jsx(_components.td, { children: _jsx(_components.code, { children: "sum = sum + i" }) }), _jsx(_components.td, { children: "Accumulate the running total" })] })] })] }), _jsxs(_components.p, { children: ["After all 50 iterations, the result is: ", _jsx(_components.code, { children: "sum = 2 + 4 + 6 + ... + 100 = 2550" }), "."] }), _jsx(_components.h3, { children: "🔁 Same Logic Using a While Loop" }), _jsx(CodeBlock, { language: "c", children: `int i = 2, sum = 0; while (i <= 100) { sum = sum + i; i = i + 2; }` }), _jsx(_components.h3, { children: "🎯 When to Use Which Loop" }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Loop" }), _jsx(_components.th, { children: "Best Used When" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: _jsx(_components.code, { children: "for" }) }) }), _jsxs(_components.td, { children: ["Number of iterations is ", _jsx(_components.strong, { children: "known beforehand" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: _jsx(_components.code, { children: "while" }) }) }), _jsxs(_components.td, { children: ["Condition depends on ", _jsx(_components.strong, { children: "runtime input" }), " or is ", _jsx(_components.strong, { children: "uncertain" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: _jsx(_components.code, { children: "do...while" }) }) }), _jsxs(_components.td, { children: ["Body must execute ", _jsx(_components.strong, { children: "at least once" }), " (e.g., menus, retry logic)"] })] })] })] }), _jsx(Remember, { children: _jsxs(_components.p, { children: ["All three loops are interchangeable in terms of logic — the choice depends on readability and the problem context. The ", _jsx(_components.code, { children: "for" }), " loop is preferred when the loop counter is clearly defined."] }) })] })] })] }) }), "\n", _jsxs(Assessment, { topicId: "2.2", children: [_jsx(MCQ, { questions: [{ "id": "b52d0a50-72e6-424b-a837-87e5b0a250bf", "q": "What is the minimum number of times a do-while loop body will execute?", "options": ["0", "1", "2", "It depends on the condition"], "answer": 1, "hint": "Remember that do-while checks the condition after executing the body.", "explanation": "In a do-while loop, the body executes at least once before the condition is evaluated, so the minimum number of iterations is 1." }, { "id": "bd84fbca-5b38-45b4-a2fc-78557e263d3c", "q": "Which is the correct syntax of a for loop in C?", "options": ["for(init : condition : update)", "for(init, condition, update)", "for(init; condition; update)", "for(init; condition; update;)"], "answer": 2, "hint": "The for loop in C has three parts separated by two semicolons.", "explanation": "The correct syntax of a for loop is for(init; condition; update), where all three parts are separated by semicolons. Option 'A' uses a colon which is wrong." }, { "id": "4690427c-50d4-45ac-b073-e3546be86083", "q": "What is the minimum number of times a while loop body can execute?", "options": ["0", "1", "2", "None of these"], "answer": 0, "hint": "Think about how many times the body executes when the condition is false from the start.", "explanation": "A while loop checks the condition before executing the body. If the condition is false initially, the body never executes, so the minimum iteration count is 0." }, { "id": "d9785c0a-6b32-476a-8c6b-053c9171919a", "q": "How many times will the following loop print? for(i=1; i<5; i++) printf('%d', i);", "options": ["3", "5", "1", "4"], "answer": 3, "hint": "The loop body will execute for values i equals 1, 2, 3, 4 which is 4 times. Then i becomes 5 and the condition fails.", "explanation": "The loop runs when i is 1, 2, 3, and 4. When i becomes 5, the condition 5 less than 5 is false and the loop terminates. So it prints from 1 to 4, meaning 4 iterations." }, { "id": "193b2a23-7a8d-49eb-a69c-32088fd093db", "q": "What happens if the condition part is left empty in a for loop like for(;;)?", "options": ["Compilation error", "It becomes an infinite loop", "The loop never executes", "Runtime error occurs"], "answer": 1, "hint": "Remember that in a for loop, if a part is left empty, it is treated as having no operation.", "explanation": "In C, if the condition part of a for loop is omitted, it is treated as always true, resulting in an infinite loop. The compiler assumes the condition to be true." }, { "id": "a4c2d534-a6a4-4721-a06a-0541c3a396c0", "q": "What will be the output of this code? int x = 10; do {\"{\"} printf('%d', x); x--; {\"}\"} while(x > 10);", "options": ["No output", "10 9 8 7 6 5 4 3 2 1", "10", "Compilation error"], "answer": 2, "hint": "In a do-while loop, the body executes first, then the condition is checked.", "explanation": "The body of the do-while loop executes first and then the condition is evaluated. So the output will be the number 10 printed once, since after execution the condition becomes false." }, { "id": "ec20984e-ad77-4804-98bb-cf31de4cb572", "q": "Which of the following is a valid way to write a for loop that runs from 0 to 9?", "options": ["for(i=0; i<10; i=i+1)", "for(i=0; i++ < 10; )", "for(i=0; i<10; i--)", "for(i=10; i>0; i++)"], "answer": 1, "hint": "The increment and decrement can be placed anywhere in the for loop syntax. Putting it in the condition is valid but unusual.", "explanation": "In C, all three parts of a for loop are optional and can be placed in different positions. Writing for(i=0; i<10; i++) is perfectly valid and equivalent to the given code." }, { "id": "35592d6c-f470-4619-8484-75c350a1681d", "q": "What is the main difference between a while loop and a do-while loop?", "options": ["do-while uses a semicolon after the condition", "while uses a semicolon after the condition", "Both are always equivalent", "do-while executes body at least once, while may not execute at all"], "answer": 3, "hint": "Recall that while checks the condition before execution, while do-while checks after execution.", "explanation": "The key difference is that a do-while loop always executes the body at least once because the condition is checked after the body runs. A while loop may execute zero times if the condition is false initially." }, { "id": "441d4a34-4dae-4c97-8ec3-a614e60d2261", "q": "In a for loop, how many times is the initialization expression executed?", "options": ["Only once at the beginning", "Before every iteration", "After every iteration", "It depends on the condition"], "answer": 0, "hint": "The initialization happens once, the condition is checked each iteration, and the update happens after each iteration.", "explanation": "In a for loop, the initialization expression is executed only once at the beginning. The condition is checked before each iteration, and the update expression is executed after each iteration of the loop body." }, { "id": "3e8bc4d1-7b0b-4672-97e2-3a18b47ad4fe", "q": "What will be the value of i after this loop finishes? for(i=1; i<5; i++);", "options": ["4", "6", "5", "1"], "answer": 2, "hint": "Trace the loop step by step and check the final value of i when the condition becomes false.", "explanation": "The loop increments i each time. When i reaches 5, the condition 5 less than 5 is false and the loop stops. So the final value of i will be 5 after the loop terminates." }], topicId: "2.2" }), _jsx(ContentAttribution, { sourceTitle: "Curriculum Reference", sourceUrl: "https://learningway.in", professor: "Faculty Review Team", model: "Curriculum AI", seoTitle: "Looping statements", seoDesc: "Master Looping statements with comprehensive notes, real-world examples, and practice quiz on LearningWay.", seoKeywords: "looping statements, looping statements notes, looping statements examples, diploma engineering notes, practice quiz, learningway" })] })] }); } function MDXContent(props = {}) { const {wrapper: MDXLayout} = { ..._provideComponents(), ...props.components }; return MDXLayout ? _jsx(MDXLayout, { ...props, children: _jsx(_createMdxContent, { ...props }) }) : _createMdxContent(props); } return { default: MDXContent }; function _missingMdxReference(id, component) { throw new Error("Expected " + (component ? "component" : "object") + " `" + id + "` to be defined: you likely forgot to import, pass, or provide it."); }