"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { code: "code", h3: "h3", li: "li", ol: "ol", p: "p", pre: "pre", strong: "strong", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {ComparisonTable, Definition, English, Explanation, Hinglish, HowItWorks, ImportantQA, MCQ, SubTopicHeader, Summary} = _components; if (!ComparisonTable) _missingMdxReference("ComparisonTable", true); if (!Definition) _missingMdxReference("Definition", true); if (!English) _missingMdxReference("English", true); if (!Explanation) _missingMdxReference("Explanation", true); if (!Hinglish) _missingMdxReference("Hinglish", true); if (!HowItWorks) _missingMdxReference("HowItWorks", true); if (!ImportantQA) _missingMdxReference("ImportantQA", true); if (!MCQ) _missingMdxReference("MCQ", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Summary) _missingMdxReference("Summary", true); return _jsxs(_Fragment, { children: [_jsx(SubTopicHeader, { id: "2.2", title: "Looping Control: for, while & do-while" }), "\n", _jsxs(Definition, { term: "Looping Control Statements", children: [_jsx(English, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Looping Control Statements" }), " are programming constructs that repeat a block of code multiple times as long as a specified conditional expression remains true."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Looping Control Statements" }), " program ke aise control blocks hote hain jo kisi statement block ko tab tak loop mein execute karte rehte hain jab tak conditional expression true rehti hai."] }) })] }), "\n", _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "Types of Loops in C" }), _jsx(_components.p, { children: "C supports three types of loop control structures:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "while loop:" }), " An entry-controlled loop. It tests the condition before executing the loop body. If the condition is false initially, the loop body never runs (minimum execution: 0)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "do-while loop:" }), " An exit-controlled loop. It executes the loop body first and then tests the condition. The loop body runs at least once (minimum execution: 1)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "for loop:" }), " A counter-controlled loop. It encapsulates loop initialization, condition testing, and iteration increment/decrement in a single line."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "C mein Loops ke Types" }), _jsx(_components.p, { children: "C language mein code repeat karne ke teen formats hain:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "while loop:" }), " Yeh ek entry-controlled loop hai. Yeh body run hone se pehle condition check karta hai. Agar starting condition false ho, toh code ek baar bhi nahi chalega (minimum execution: 0)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "do-while loop:" }), " Yeh exit-controlled loop hai. Isme loop block pehle chalta hai aur condition end mein check hoti hai. Yeh condition galat hone par bhi kam se kam ek baar zaroor chalta hai (minimum execution: 1)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "for loop:" }), " Yeh counter-controlled loop hai. Isme initialization, condition validation aur step updates ek hi statement line mein brackets ke andar clear code likhe jate hain."] }), "\n"] })] }), _jsx(ComparisonTable, { 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 loop" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "do-while loop" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "for loop" })] }) }), _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: "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: "Semicolon Ending" }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "while(cond) { }" }), " (No semicolon)"] }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "do { } while(cond);" }), " (Ends with ", _jsx(_components.code, { children: ";" }), ")"] }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "for(...) { }" }), " (No semicolon)"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Syntax Structure" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Condition checked at start." }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Condition checked at end." }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Condense header syntax." })] })] })] }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "Nested Loops" }), _jsx(_components.p, { children: "A nested loop is a loop inside another loop (e.g., a for loop inside a while loop).\nFor every single iteration of the outer loop, the inner loop executes its complete cycle (from start to finish).\nNested loops are commonly used for handling multi-dimensional structures like 2D arrays (matrices)." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "Nested Loops" }), _jsx(_components.p, { children: "Jab ek loop ke block body ke andar dusra loop use kiya jata hai, toh use nested loop kehte hain.\nOuter loop ke har ek single step/iteration ke liye inner loop apni cycle poori complete (start to end) chalata hai.\nNested loops ka use common space structures jaise 2D matrix coordinate management mein kiya jata hai." })] }), _jsxs(HowItWorks, { title: "Comparison code of loop structures", children: [_jsxs(English, { children: [_jsx(_components.p, { children: _jsx(_components.strong, { children: "while loop:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "int i = 1;\nwhile (i <= 3) {\n printf(\"%d \", i);\n i++;\n}\n" }) }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "do-while loop:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "int i = 1;\ndo {\n printf(\"%d \", i);\n i++;\n} while (i <= 3);\n" }) }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "for loop:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "for (int i = 1; i <= 3; i++) {\n printf(\"%d \", i);\n}\n" }) }), _jsxs(_components.p, { children: ["All three print ", _jsx(_components.code, { children: "1 2 3" }), "."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.p, { children: _jsx(_components.strong, { children: "while loop:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "int i = 1;\nwhile (i <= 3) {\n printf(\"%d \", i);\n i++;\n}\n" }) }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "do-while loop:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "int i = 1;\ndo {\n printf(\"%d \", i);\n i++;\n} while (i <= 3);\n" }) }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "for loop:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "for (int i = 1; i <= 3; i++) {\n printf(\"%d \", i);\n}\n" }) }), _jsxs(_components.p, { children: ["Teeno codes compile hokar output screen par ", _jsx(_components.code, { children: "1 2 3" }), " show karenge."] })] })] })] }), "\n", _jsxs(Summary, { children: [_jsx(English, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "while" }), " loops check conditional logic at block entry, which may result in zero executions."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "do-while" }), " loops verify logic at block exit, ensuring at least one run."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "for" }), " loops integrate initialization, check logic, and increment updates in a single line."] }), "\n"] }) }), _jsx(Hinglish, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "while" }), " loops conditional logic starting stage mein inspect karte hain, jisse block execution 0 bhi ho sakti hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "do-while" }), " loops logic condition exit points par examine karte hain, jisse code body 1 execution complete karti hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "for" }), " loops variables structure, logical check, aur updates dynamic setup ek header bracket code line mein bind karte hain."] }), "\n"] }) })] }), "\n", _jsx(ImportantQA, { questions: [{ "q": "Compare while loop and do-while loop in C. (4 Marks)", "marks": 4, "a": { "components": [{ "type": "Explanation", "content": "1. **Control Type:** `while` is entry-controlled (checks condition before entering loop body). `do-while` is exit-controlled (checks condition at the end of loop body).\n2. **Minimum Executions:** `while` runs 0 times if the condition is false. `do-while` runs at least 1 time even if the condition is false.\n3. **Syntax Semicolon:** `while` syntax does not require a semicolon. `do-while` requires a semicolon at the end of the while condition statement.\n4. **Variable Initialization:** In `while`, variable must be initialized before loop header. In `do-while`, it also initializes before but condition checks at the exit line.1. **Control Type:** `while` loop entry-controlled loop hai (body ke start mein condition check). `do-while` exit-controlled loop hai (body ke end mein condition check).\n2. **Minimum Executions:** Condition false hone par `while` loop 0 baar chalta hai. `do-while` loop kam se kam 1 baar chalta hai chahe condition shuru se hi galat ho.\n3. **Syntax Semicolon:** `while` block header par semicolon nahi use hota. `do-while` mein exit checking line `while(cond);` par semicolon lagana compulsory hota hai.\n4. **Initialization:** Dono loops mein check variable pehle set hota hai, par evaluate path entry/exit alag space par run karta hai." }] } }, { "q": "Write a C program to find the factorial of a number using a while loop. (4 Marks)", "marks": 4, "a": { "components": [{ "type": "Explanation", "content": "```c\n#include \n\nint main() {\n int num, i = 1;\n long factorial = 1;\n printf(\"Enter a positive integer: \");\n scanf(\"%d\", &num);\n\n while (i <= num) {\n factorial *= i;\n i++;\n }\n printf(\"Factorial of %d is %ld\\n\", num, factorial);\n return 0;\n}\n``````c\n#include \n\nint main() {\n int num, i = 1;\n long factorial = 1;\n printf(\"Enter a positive integer: \");\n scanf(\"%d\", &num);\n\n while (i <= num) {\n factorial *= i;\n i++;\n }\n printf(\"Factorial of %d is %ld\\n\", num, factorial);\n return 0;\n}\n```" }] } }] }), "\n", _jsx(MCQ, { questions: [{ "id": "1eac5aa6-0a3b-4a91-b4e0-67b18b0c49ed", "q": "Which loop structure checks the condition at the end of the loop body?", "options": ["for loop", "while loop", "do-while loop", "nested loop"], "answer": 2, "hint": "It is an exit-controlled loop.", "explanation": "do-while loop evaluates its test expression after running the block body." }, { "id": "565b90f3-47d9-4eb1-867a-f68bc77658f7", "q": "What is the minimum number of times a while loop can execute?", "options": ["0", "1", "Infinite", "Depends on RAM size"], "answer": 0, "hint": "If the condition is false from the start, does it execute?", "explanation": "A while loop is entry-controlled. If the condition evaluates to false at the start, it will execute 0 times." }, { "id": "525a9854-21f0-4349-9e00-248eaea252cd", "q": "What is the minimum number of times a do-while loop can execute?", "options": ["0", "1", "2", "Infinite"], "answer": 1, "hint": "It checks condition after the body executes.", "explanation": "Since do-while is exit-controlled, the loop body executes once before the condition is checked." }, { "id": "7ba29e8f-f7f9-4438-9d3e-7a48be33766e", "q": "Which loop is best suited when the exact number of iterations is known beforehand?", "options": ["while loop", "do-while loop", "for loop", "infinite loop"], "answer": 2, "hint": "It includes counter initialization, condition, and increment in one line.", "explanation": "The for loop is ideal for counter-based, fixed-count iterations." }, { "id": "dd3ba704-458e-4106-a374-f4238b22807f", "q": "What will be the output of the following code? for(int i=0; i<3; i++); { printf(\"Hi\"); }", "options": ["HiHiHi", "Hi", "Hi printed infinitely", "Compilation Error"], "answer": 1, "hint": "Observe the semicolon at the end of the for statement: 'for(int i=0; i<3; i++);'", "explanation": "The semicolon at the end of the for loop header creates an empty loop body. The loop runs 3 times doing nothing, then the following block executes once, printing 'Hi'." }, { "id": "dca0527c-ba68-43d2-a71f-021ee66dcf64", "q": "How are the three parts of a for loop header separated?", "options": ["Commas", "Colons", "Semicolons", "Periods"], "answer": 2, "hint": "Syntax: for(init ? cond ? update)", "explanation": "A for loop header uses semicolons to separate initialization, condition, and iteration statements." }, { "id": "228d8ff1-e159-4817-b62c-ceb373145132", "q": "What happens if the conditional expression in a for loop header is omitted (e.g. for(int i=0; ; i++))?", "options": ["The loop causes a syntax compilation error", "The loop assumes the condition is false and never executes", "The loop assumes the condition is true and runs infinitely", "The program crashes immediately"], "answer": 2, "hint": "An empty condition defaults to true in C loops.", "explanation": "Omitting the conditional expression in a for loop is interpreted by the compiler as a constant true condition, leading to an infinite loop." }, { "id": "81a554c6-caa8-4ca2-88ff-2af3cf2dcb37", "q": "How many times will the printf statement execute? for(int i=0; i<3; i++) { for(int j=0; j<2; j++) { printf(\"*\"); } }", "options": ["5", "6", "3", "2"], "answer": 1, "hint": "Multiply the number of outer loop iterations by the inner loop iterations.", "explanation": "The outer loop runs 3 times. For each run, the inner loop runs 2 times. Total iterations = 3 * 2 = 6." }, { "id": "2b9efb88-010e-47fe-aed3-a2b9bffdf331", "q": "Which loop structure syntax is correct?", "options": ["do { printf(\"A\"); } while (x < 5)", "do { printf(\"A\"); } while (x < 5);", "do; while(x<5) { printf(\"A\"); }", "while(x < 5) do { printf(\"A\"); }"], "answer": 1, "hint": "Exit controlled loop must end with a semicolon after the while statement.", "explanation": "A do-while loop requires a terminating semicolon after 'while(condition);'." }, { "id": "2252d49c-655d-4d47-8a05-8e78dacecb2b", "q": "What will be printed? int x=5; while(x-- > 0) { printf(\"%d \", x); }", "options": ["5 4 3 2 1", "4 3 2 1 0", "4 3 2 1", "5 4 3 2 1 0"], "answer": 1, "hint": "Post-decrement 'x--' evaluates first, then decrements x in memory before it is printed.", "explanation": "At x=5, condition 5 > 0 is true, x becomes 4, prints 4. Runs down to x=1, condition 1 > 0 is true, x becomes 0, prints 0. At x=0, 0 > 0 is false, loop terminates. Prints: '4 3 2 1 0'." }], topicId: "2.2" })] }); } 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."); }