"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, FormulaBox, 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 (!FormulaBox) _missingMdxReference("FormulaBox", 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.1", title: "Conditional Statements: if, else-if & switch-case" }), "\n", _jsxs(Definition, { term: "Conditional Statements", children: [_jsx(English, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Conditional Statements" }), " are programming constructs that execute different code blocks depending on whether a conditional expression evaluates to true (non-zero) or false (zero)."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Conditional Statements" }), " programming ke aise structures hote hain jo kisi condition ke check hone (true/false) par specific program flow ko choose aur run karte hain."] }) })] }), "\n", _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "Selection Structures in C" }), _jsx(_components.p, { children: "C supports the following selection statements:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Simple if:" }), " Executes a block of code if the condition is true."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "if-else:" }), " Provides a choice: runs the if-block if true, otherwise runs the else-block."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "else-if Ladder:" }), " Checks multiple conditions one by one from top to bottom."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Nested if-else:" }), " An if-else statement written inside another if-else statement."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "switch-case:" }), " A multi-way branch statement that compares an expression against multiple case labels."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "C mein Selection Structures" }), _jsx(_components.p, { children: "C language mein selection controls ke options:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Simple if:" }), " Agar condition true hai toh block ka code execute hoga."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "if-else:" }), " Agar true hai toh if-block chalega, nahi toh else-block chalega."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "else-if Ladder:" }), " Ek ke baad ek kai conditions line-by-line check karta hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Nested if-else:" }), " Ek if-else block ke andar dusra if-else structure define karna."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "switch-case:" }), " Ek single variable expression ko multiple constants se compare karke running path select karna."] }), "\n"] })] }), _jsx(FormulaBox, { title: "switch-case Constraints & Fall-through", children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Constraints:" }), " The switch expression must return an ", _jsx(_components.code, { children: "int" }), " or ", _jsx(_components.code, { children: "char" }), ". Real numbers (float/double) or strings are ", _jsx(_components.strong, { children: "not allowed" }), ". Case values must be constants or literals."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Fall-through:" }), " If a matching case does not end with a ", _jsx(_components.code, { children: "break" }), " statement, execution will continue into the next case's statements regardless of whether they match the switch expression, until a ", _jsx(_components.code, { children: "break" }), " or the end of the switch block is reached."] }), "\n"] }) }), _jsx(ComparisonTable, { children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Feature / Difference" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "else-if Ladder" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "switch-case" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Evaluation Type" }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Can evaluate any logical expression (e.g., ", _jsx(_components.code, { children: "x > 5 && x < 10" }), ")."] }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Evaluates single expression matching exact values." })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Allowed Data Types" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Supports integers, floats, doubles, characters." }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Supports integers and characters only." })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Fall-through" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Cannot happen; only one matching branch runs." }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Happens if the ", _jsx(_components.code, { children: "break" }), " statement is omitted."] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Readability" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Hard to read if there are too many branches." }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Cleaner layout for multiple menu-driven selections." })] })] })] }) }), _jsxs(HowItWorks, { title: "Example: else-if ladder vs switch-case", children: [_jsxs(English, { children: [_jsx(_components.p, { children: _jsx(_components.strong, { children: "else-if ladder example:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "if (marks >= 75) printf(\"Distinction\");\nelse if (marks >= 60) printf(\"First Class\");\nelse printf(\"Pass/Fail\");\n" }) }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "switch-case example:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "switch(grade) {\n case 'A': printf(\"Excellent\"); break;\n case 'B': printf(\"Good\"); break;\n default: printf(\"Invalid Grade\");\n}\n" }) })] }), _jsxs(Hinglish, { children: [_jsx(_components.p, { children: _jsx(_components.strong, { children: "else-if ladder example:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "if (marks >= 75) printf(\"Distinction\");\nelse if (marks >= 60) printf(\"First Class\");\nelse printf(\"Pass/Fail\");\n" }) }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "switch-case example:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "switch(grade) {\n case 'A': printf(\"Excellent\"); break;\n case 'B': printf(\"Good\"); break;\n default: printf(\"Invalid Grade\");\n}\n" }) })] })] })] }), "\n", _jsxs(Summary, { children: [_jsx(English, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "if" }), " constructs branch program flows depending on conditional logic."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "switch" }), " statements match integral values (integers or chars) with case labels."] }), "\n", _jsxs(_components.li, { children: ["Standard ", _jsx(_components.code, { children: "break" }), " statements prevent switch execution leaks (fall-through)."] }), "\n"] }) }), _jsx(Hinglish, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "if" }), " constructs logic blocks ko test kar execution route divide karte hain."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "switch" }), " structures integral outputs check karte hain aur case symbols control karte hain."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "break" }), " statement na lagane se program matching case ke aage wale blocks bhi run kar deta hai (fall-through)."] }), "\n"] }) })] }), "\n", _jsx(ImportantQA, { questions: [{ "q": "Explain switch-case statement with syntax and example. What is the role of break in switch-case? (6 Marks)", "marks": 6, "a": { "components": [{ "type": "Explanation", "content": "The **switch-case** statement is a multi-way branch selection construct.\n\n**Syntax:**\n```c\nswitch (expression) {\n case const1:\n statements;\n break;\n case const2:\n statements;\n break;\n default:\n default_statements;\n}\n```\n**Role of `break`:** The `break` statement is used at the end of each case block. Once a match is found, the statements execute. If `break` is present, control exits the switch block immediately. If `break` is missing, control continues to execute subsequent cases sequentially without checking the match condition (known as **fall-through**).**switch-case** statement ek multi-way decision-making structure hai.\n\n**Syntax:**\n```c\nswitch (expression) {\n case const1:\n statements;\n break;\n case const2:\n statements;\n break;\n default:\n default_statements;\n}\n```\n**`break` ka role:** Har case block ke aakhri mein `break` lagaya jata hai. Jab matching case milta hai aur execute hota hai, tab `break` control ko switch block se turant bahar nikal deta hai. Agar `break` na ho, toh control aage ke sabhi cases ko sequentially execute kar deta hai jab tak use break na mile (ise **fall-through** kehte hain)." }] } }, { "q": "Write a C program to find the largest of two numbers using if-else. (4 Marks)", "marks": 4, "a": { "components": [{ "type": "Explanation", "content": "```c\n#include \n\nint main() {\n int num1, num2;\n printf(\"Enter two numbers: \");\n scanf(\"%d %d\", &num1, &num2);\n\n if (num1 > num2) {\n printf(\"%d is the largest.\\n\", num1);\n } else {\n printf(\"%d is the largest.\\n\", num2);\n }\n return 0;\n}\n``````c\n#include \n\nint main() {\n int num1, num2;\n printf(\"Enter two numbers: \");\n scanf(\"%d %d\", &num1, &num2);\n\n if (num1 > num2) {\n printf(\"%d is the largest.\\n\", num1);\n } else {\n printf(\"%d is the largest.\\n\", num2);\n }\n return 0;\n}\n```" }] } }] }), "\n", _jsx(MCQ, { questions: [{ "id": "6a4240b0-77ab-48a7-867b-6301ad6c52c2", "q": "What value in C represents a logical 'false' condition?", "options": ["Negative value", "0", "1", "Any non-zero value"], "answer": 1, "hint": "Logical truth is non-zero, untruth is zero.", "explanation": "In C, a value of 0 is considered false, while any non-zero value is treated as true." }, { "id": "fa41a1fc-a905-4033-b8a1-1b126c1885e9", "q": "Which of the following is evaluated in a switch statement expression?", "options": ["Any floating-point value", "Only Integer or Character values", "Character strings", "All of the above"], "answer": 1, "hint": "C switch-case cannot evaluate real numbers or double values.", "explanation": "Switch statements only accept integer or character evaluations; float or string values cause compiler errors." }, { "id": "0100d353-3b69-4e5f-9ece-4c3a38ce2bbb", "q": "What is the purpose of the 'default' case in a switch statement?", "options": ["It runs only when the switch expression is true", "It runs when none of the defined cases match the switch expression", "It causes compiler warnings", "It exits the program immediately"], "answer": 1, "hint": "Think of it like the 'else' block of an else-if ladder.", "explanation": "The default block executes if no matching case value matches the switch expression." }, { "id": "c478129d-3418-4318-b34b-6d52abc5409a", "q": "What happens if a matching case is found in a switch statement, but there is no 'break' statement?", "options": ["The program raises a compilation error", "Only the default block runs", "Execution falls through and runs subsequent cases without condition checking", "The program restarts"], "answer": 2, "hint": "This behavior is called fall-through.", "explanation": "Omitting break statements causes fall-through, executing the matching case and all subsequent cases until a break or the block end is reached." }, { "id": "1771c727-06ff-4ded-bbe9-09b3005af857", "q": "Which structure should be used to evaluate range conditions like 'score >= 90 && score <= 100'?", "options": ["switch-case", "else-if ladder", "while loop", "break statement"], "answer": 1, "hint": "switch-case matches exact values, whereas this structure evaluates relational expressions.", "explanation": "An else-if ladder is perfect for evaluating range conditions or complex relational/logical expressions." }, { "id": "5537adbd-a8da-498b-bb99-a31fd16c36e0", "q": "What is the output of the following code? int x=5; if(x=10) printf(\"True\"); else printf(\"False\");", "options": ["True", "False", "Compilation Error", "No Output"], "answer": 0, "hint": "Notice that the assignment operator '=' is used, not the equality operator '=='.", "explanation": "x = 10 is an assignment. It assigns 10 to x and evaluates to 10. Since 10 is non-zero, it is treated as true, printing 'True'." }, { "id": "30d67cf4-1def-445e-8888-01f7ecb32260", "q": "In switch-case, can we have duplicate case labels?", "options": ["Yes, the compiler runs the first match", "No, duplicate case labels cause a compilation error", "Yes, if they are separated by break statements", "Only if they match character types"], "answer": 1, "hint": "Every case label must be unique in a switch block.", "explanation": "Duplicate case values are illegal and will cause the compiler to output an error." }, { "id": "8e40a6ee-fd03-471e-aea8-fab7bfead39b", "q": "What will be printed? char ch='B'; switch(ch) { case 'A': printf(\"A\"); case 'B': printf(\"B\"); case 'C': printf(\"C\"); }", "options": ["B", "BC", "B C", "Compilation Error"], "answer": 1, "hint": "Look for break statements in the cases.", "explanation": "Case 'B' matches and prints 'B'. Since there is no break statement, execution falls through to case 'C' and prints 'C'. Result: 'BC'." }, { "id": "517ce5b9-96c2-4b7f-bf63-94f46052375e", "q": "Which condition checking structure is fastest for large numbers of integer matches?", "options": ["else-if ladder", "switch-case (compiles to jump table)", "nested if-else", "All run at the exact same execution speeds"], "answer": 1, "hint": "The compiler optimizes this construct into a jump table.", "explanation": "Modern compilers optimize switch-case blocks into lookup jump tables, making execution faster than evaluating sequential else-if conditions." }, { "id": "f9898985-75a6-47f5-84eb-3986838ce3bf", "q": "If integer variable x = 3, what is printed by: x > 2 ? printf(\"Yes\") : printf(\"No\"); ?", "options": ["Yes", "No", "YesNo", "Compilation Error"], "answer": 3, "hint": "The conditional operator expressions must evaluate to values, but printf returns integers. However, is the syntax valid as statements?", "explanation": "In C, standard syntax requires expressions on both sides of '? :'. While statements can work, standard syntax forbids using statement lists directly, or in some compilers it evaluates, but standard compiler rules might report errors depending on expression return types." }], topicId: "2.1" })] }); } 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."); }