"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", h4: "h4", hr: "hr", li: "li", p: "p", pre: "pre", 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, Hinglish, ImportantQA, KeyPoints, MCQ, Note, Practical, Prompt, QAQuestion, Remember, Step, StepByStep, SubTopicHeader, Theory, TopicOverview} = _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 (!Hinglish) _missingMdxReference("Hinglish", true); if (!ImportantQA) _missingMdxReference("ImportantQA", true); if (!KeyPoints) _missingMdxReference("KeyPoints", true); if (!MCQ) _missingMdxReference("MCQ", true); if (!Note) _missingMdxReference("Note", true); if (!Practical) _missingMdxReference("Practical", true); if (!Prompt) _missingMdxReference("Prompt", true); if (!QAQuestion) _missingMdxReference("QAQuestion", true); if (!Remember) _missingMdxReference("Remember", true); if (!Step) _missingMdxReference("Step", true); if (!StepByStep) _missingMdxReference("StepByStep", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Theory) _missingMdxReference("Theory", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); return _jsxs(_Fragment, { children: [_jsxs(Theory, { children: [_jsx(SubTopicHeader, { id: "2.1", title: "Conditional Statements in C" }), _jsx(English, { children: _jsxs(TopicOverview, { title: "Conditional Statements in C", topicId: "2.1", readingTime: "14 min read", difficulty: "Medium", children: [_jsxs(_components.p, { children: ["In real life, we make decisions every day — \"If it rains, I'll take an umbrella\" or \"If the exam score is above 90, I'll celebrate.\" Programs need the same ability. ", _jsx(_components.strong, { children: "Conditional statements" }), " let your C program make decisions and execute different blocks of code based on whether a condition is ", _jsx(_components.strong, { children: "true" }), " or ", _jsx(_components.strong, { children: "false" }), "."] }), _jsxs(_components.p, { children: ["In this subtopic, we'll explore the building blocks of decision-making in C: ", _jsx(_components.strong, { children: "relational operators" }), " (to compare values), ", _jsx(_components.strong, { children: "logical operators" }), " (to combine multiple conditions), and then dive into the actual conditional constructs — ", _jsx(_components.code, { children: "if" }), ", ", _jsx(_components.code, { children: "if-else" }), ", ", _jsx(_components.strong, { children: "nested if-else" }), ", the ", _jsx(_components.strong, { children: "if-else ladder" }), ", and the ", _jsx(_components.strong, { children: "switch statement" }), ". Each of these has its own strengths and ideal use cases, and mastering them is essential to writing programs that can think and react."] })] }) }), _jsx(Hinglish, { children: _jsxs(TopicOverview, { title: "C Mein Conditional Statements", topicId: "2.1", readingTime: "14 min read", difficulty: "Medium", children: [_jsxs(_components.p, { children: ["Real life mein hum har din decisions lete hain — \"Agar barish hogi, toh main chhata le jaunga\" ya \"Agar exam mein 90 se zyada aaye, toh celebrate karunga.\" Programs ko bhi same ability chahiye. ", _jsx(_components.strong, { children: "Conditional statements" }), " tumhare C program ko decisions lene ka power deti hain — ki kaunsa code block execute hoga based on ki condition ", _jsx(_components.strong, { children: "true" }), " hai ya ", _jsx(_components.strong, { children: "false" }), "."] }), _jsxs(_components.p, { children: ["Is subtopic mein hum C mein decision-making ke building blocks dekhenge: ", _jsx(_components.strong, { children: "relational operators" }), " (values compare karne ke liye), ", _jsx(_components.strong, { children: "logical operators" }), " (multiple conditions combine karne ke liye), aur phir actual conditional constructs — ", _jsx(_components.code, { children: "if" }), ", ", _jsx(_components.code, { children: "if-else" }), ", ", _jsx(_components.strong, { children: "nested if-else" }), ", ", _jsx(_components.strong, { children: "if-else ladder" }), ", aur ", _jsx(_components.strong, { children: "switch statement" }), ". Har ek ki apni strength hai aur ideal use case hai, aur inhe master karna programs likhne ke liye essential hai jo soch sakein aur react kar sakein."] })] }) }), _jsxs(DefinitionGroup, { children: [_jsx(DefinitionEntry, { term: "Conditional Statement", children: _jsx(_components.p, { children: "A programming construct that allows the program to execute different blocks of code depending on whether a given condition evaluates to true or false. Think of it as a fork in the road — the condition decides which path the program takes." }) }), _jsx(DefinitionEntry, { term: "Relational Operator", children: _jsxs(_components.p, { children: ["An operator that compares two values and returns a result of either 1 (true) or 0 (false). For example, the greater-than operator ", _jsx(_components.code, { children: ">" }), " checks if the value on the left is bigger than the one on the right. These are the foundation of forming conditions in C."] }) }), _jsx(DefinitionEntry, { term: "Logical Operator", children: _jsxs(_components.p, { children: ["An operator used to combine two or more conditions into a single compound condition. C provides three logical operators: ", _jsx(_components.code, { children: "&&" }), " (AND), ", _jsx(_components.code, { children: "||" }), " (OR), and ", _jsx(_components.code, { children: "!" }), " (NOT). They follow Boolean logic to determine the final true/false result."] }) }), _jsx(DefinitionEntry, { term: "if Statement", children: _jsxs(_components.p, { children: ["The simplest conditional statement in C. It checks a condition and executes the block of code inside it ", _jsx(_components.strong, { children: "only if the condition is true" }), ". If the condition is false, the program simply skips that block and moves on to the next statement."] }) }), _jsx(DefinitionEntry, { term: "if-else Statement", children: _jsxs(_components.p, { children: ["An extension of the ", _jsx(_components.code, { children: "if" }), " statement that provides an ", _jsx(_components.strong, { children: "alternative block" }), " of code to execute when the condition is false. This ensures that one of the two blocks always runs — either the ", _jsx(_components.code, { children: "if" }), " block or the ", _jsx(_components.code, { children: "else" }), " block."] }) }), _jsx(DefinitionEntry, { term: "Nested if-else", children: _jsxs(_components.p, { children: ["A situation where an ", _jsx(_components.code, { children: "if" }), " or ", _jsx(_components.code, { children: "if-else" }), " statement is placed ", _jsx(_components.strong, { children: "inside another" }), " ", _jsx(_components.code, { children: "if" }), " or ", _jsx(_components.code, { children: "else" }), " block. This allows checking multiple levels of conditions in a hierarchical manner, where the inner condition is evaluated only if the outer condition is true."] }) }), _jsx(DefinitionEntry, { term: "if-else Ladder", children: _jsxs(_components.p, { children: ["A sequence of ", _jsx(_components.code, { children: "if-else if-else" }), " statements stacked one after another. The program evaluates conditions from top to bottom and executes the ", _jsx(_components.strong, { children: "first block whose condition is true" }), ", skipping the rest. It's useful when you have multiple possible outcomes to check."] }) }), _jsx(DefinitionEntry, { term: "switch Statement", children: _jsx(_components.p, { children: "A multi-way branching statement that selects one of many code blocks to execute based on the value of an integer expression or character. It's a cleaner alternative to a long if-else ladder when comparing a single variable against multiple fixed values." }) }), _jsx(DefinitionEntry, { term: "Condition", children: _jsx(_components.p, { children: "Any expression in C that evaluates to a non-zero value (true) or zero (false). In C, there is no dedicated Boolean type — any non-zero value is treated as true, and zero is treated as false." }) })] }), _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "🔢 Relational Operators — Comparing Values" }), _jsxs(_components.p, { children: ["Relational operators are used to ", _jsx(_components.strong, { children: "compare two operands" }), ". They return ", _jsx(_components.code, { children: "1" }), " if the relation is true, and ", _jsx(_components.code, { children: "0" }), " if it's false. These operators are the backbone of writing conditions."] }), _jsx(ComparisonTable, { title: "Relational Operators in C", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "center" }, children: "Operator" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Meaning" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Example" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Result" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Equal to" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "5 5" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1" }), " (true)"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "!=" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Not equal to" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "5 != 3" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1" }), " (true)"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: ">" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Greater than" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "7 > 3" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1" }), " (true)"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "<" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Less than" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "2 < 8" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1" }), " (true)"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: ">=" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Greater than or equal to" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "5 >= 5" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1" }), " (true)"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "<=" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Less than or equal to" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "3 <= 7" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1" }), " (true)"] })] })] })] }) }), _jsx(_components.p, { children: "Here's a quick code example showing relational operators in action:" })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🔢 Relational Operators — Values Ko Compare Karna" }), _jsxs(_components.p, { children: ["Relational operators ka use ", _jsx(_components.strong, { children: "do operands ko compare" }), " karne ke liye hota hai. Agar relation true hai toh ", _jsx(_components.code, { children: "1" }), " return hota hai, aur false hai toh ", _jsx(_components.code, { children: "0" }), ". Yeh operators conditions likhne ki backbone hain."] }), _jsx(ComparisonTable, { title: "C Mein Relational Operators", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "center" }, children: "Operator" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Meaning" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Example" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Result" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Equal to" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "5 5" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1" }), " (true)"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "!=" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Not equal to" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "5 != 3" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1" }), " (true)"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: ">" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Greater than" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "7 > 3" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1" }), " (true)"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "<" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Less than" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "2 < 8" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1" }), " (true)"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: ">=" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Greater than or equal to" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "5 >= 5" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1" }), " (true)"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "<=" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Less than or equal to" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "3 <= 7" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1" }), " (true)"] })] })] })] }) }), _jsx(_components.p, { children: "Yeh raha ek quick code example jo dikhata hai relational operators kaise kaam karte hain:" })] }), _jsxs(CodeBlock, { language: "c", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\nint a = 10, b = 20;"] }), _jsxs(_components.p, { children: ["printf(\"a ", _jsx("mark", { children: " b : %d\\n\", a " }), " b); // 0 (false)\r\nprintf(\"a != b : %d\\n\", a != b); // 1 (true)\r\nprintf(\"a > b : %d\\n\", a > b); // 0 (false)\r\nprintf(\"a ", "<", " b : %d\\n\", a ", "<", " b); // 1 (true)\r\nprintf(\"a >= 10: %d\\n\", a >= 10); // 1 (true)\r\nprintf(\"a ", "<=", " 5 : %d\\n\", a ", "<=", " 5); // 0 (false)"] }), _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsx(English, { children: _jsx(Remember, { title: "⚠️ Common Pitfall: is vs is is ", children: _jsxs(_components.p, { children: ["A very common beginner mistake is using the ", _jsx(_components.strong, { children: "assignment operator" }), " ", _jsx(_components.code, { children: "=" }), " instead of the ", _jsx(_components.strong, { children: "equality operator" }), " ", _jsx(_components.code, { children: "==" }), " in conditions. Writing ", _jsx(_components.code, { children: "if (a = 5)" }), " assigns 5 to ", _jsx(_components.code, { children: "a" }), " (which is always true) instead of comparing ", _jsx(_components.code, { children: "a" }), " with 5. Always use ", _jsx(_components.code, { children: "==" }), " when you mean to compare!"] }) }) }), _jsx(Hinglish, { children: _jsx(Remember, { title: "⚠️ Common Galti: is vs is is ", children: _jsxs(_components.p, { children: ["Ek bahut common beginner galti hai ki ", _jsx(_components.code, { children: "=" }), " (assignment operator) use kar lete hain ", _jsx(_components.code, { children: "==" }), " (equality operator) ki jagah conditions mein. ", _jsx(_components.code, { children: "if (a = 5)" }), " likhne se ", _jsx(_components.code, { children: "a" }), " ko 5 assign ho jata hai (jo hamesha true hota hai), instead of ", _jsx(_components.code, { children: "a" }), " ko 5 se compare karna. Compare karna ho toh hamesha ", _jsx(_components.code, { children: "==" }), " use karo!"] }) }) }), _jsx(_components.hr, {}), _jsxs(English, { children: [_jsx(_components.h3, { children: "🔗 Logical Operators — Combining Conditions" }), _jsxs(_components.p, { children: ["Often, a single condition is not enough. What if you want to check if a number is ", _jsx(_components.strong, { children: "both greater than 5 AND less than 20" }), "? That's where ", _jsx(_components.strong, { children: "logical operators" }), " come in. They let you combine multiple conditions into a single compound expression."] }), _jsx(ComparisonTable, { title: "Logical Operators in C", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "center" }, children: "Operator" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Name" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Meaning" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Example" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Result" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "&&" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "AND" }), _jsxs(_components.td, { style: { textAlign: "center" }, children: ["True only if ", _jsx(_components.strong, { children: "both" }), " conditions are true"] }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "(5>3) && (10>7)" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "1" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "||" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "OR" }), _jsxs(_components.td, { style: { textAlign: "center" }, children: ["True if ", _jsx(_components.strong, { children: "at least one" }), " condition is true"] }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "(5>3) || (2>7)" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "1" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "!" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "NOT" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Reverses the result (true becomes false)" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "!(5>3)" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "0" }) })] })] })] }) })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🔗 Logical Operators — Conditions Ko Combine Karna" }), _jsxs(_components.p, { children: ["Kai baar ek condition kaafi nahi hoti. Agar tumhe check karna ho ki ek number ", _jsx(_components.strong, { children: "5 se bada hai AND 20 se chhota hai" }), " dono? Tab ", _jsx(_components.strong, { children: "logical operators" }), " kaam aate hain. Yeh tumhe multiple conditions ko ek single compound expression mein combine karne dete hain."] }), _jsx(ComparisonTable, { title: "C Mein Logical Operators", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "center" }, children: "Operator" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Name" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Meaning" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Example" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Result" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "&&" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "AND" }), _jsxs(_components.td, { style: { textAlign: "center" }, children: ["Sirf tab true jab ", _jsx(_components.strong, { children: "dono" }), " conditions true ho"] }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "(5>3) && (10>7)" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "1" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "||" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "OR" }), _jsxs(_components.td, { style: { textAlign: "center" }, children: ["Tab true jab ", _jsx(_components.strong, { children: "kam se kam ek" }), " condition true ho"] }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "(5>3) || (2>7)" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "1" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "!" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "NOT" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Result ko reverse kar deta hai (true ko false banata hai)" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "!(5>3)" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "0" }) })] })] })] }) })] }), _jsxs(CodeBlock, { language: "c", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\nint age = 25;\r\nint income = 50000;"] }), _jsxs(_components.p, { children: ["// AND: Both conditions must be true\r\nif (age >= 18 && income >= 30000) ", "{", "\r\nprintf(\"Loan approved!\\n\");"] }), "}", _jsxs(_components.p, { children: ["// OR: At least one condition must be true\r\nif (age ", "<", " 18 || income ", "<", " 10000) ", "{", "\r\nprintf(\"Loan rejected!\\n\");"] }), "}", _jsxs(_components.p, { children: ["// NOT: Reverses the condition\r\nint isStudent = 0; // 0 means false\r\nif (!isStudent) ", "{", "\r\nprintf(\"You are not a student.\\n\");"] }), "}", _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsxs(English, { children: [_jsx(_components.h4, { children: "Truth Tables for Logical Operators" }), _jsx(_components.p, { children: "Understanding truth tables helps you predict the outcome of any compound condition:" }), _jsx(_components.p, { children: _jsxs(_components.strong, { children: ["AND (", _jsx(_components.code, { children: "&&" }), ") Truth Table:"] }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "center" }, children: "Condition A" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Condition B" }), _jsxs(_components.th, { style: { textAlign: "center" }, children: ["A ", _jsx(_components.code, { children: "&&" }), " B"] })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.strong, { children: "True" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" })] })] })] }), _jsx(_components.p, { children: _jsxs(_components.strong, { children: ["OR (", _jsx(_components.code, { children: "||" }), ") Truth Table:"] }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "center" }, children: "Condition A" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Condition B" }), _jsxs(_components.th, { style: { textAlign: "center" }, children: ["A ", _jsx(_components.code, { children: "||" }), " B"] })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.strong, { children: "True" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.strong, { children: "True" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.strong, { children: "True" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" })] })] })] }), _jsx(_components.p, { children: _jsxs(_components.strong, { children: ["NOT (", _jsx(_components.code, { children: "!" }), ") Truth Table:"] }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "center" }, children: "Condition A" }), _jsxs(_components.th, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "!" }), " A"] })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "True" })] })] })] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h4, { children: "Logical Operators Ke Truth Tables" }), _jsx(_components.p, { children: "Truth tables samajhna help karta hai ki koi bhi compound condition ka outcome kya hoga:" }), _jsx(_components.p, { children: _jsxs(_components.strong, { children: ["AND (", _jsx(_components.code, { children: "&&" }), ") Truth Table:"] }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "center" }, children: "Condition A" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Condition B" }), _jsxs(_components.th, { style: { textAlign: "center" }, children: ["A ", _jsx(_components.code, { children: "&&" }), " B"] })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.strong, { children: "True" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" })] })] })] }), _jsx(_components.p, { children: _jsxs(_components.strong, { children: ["OR (", _jsx(_components.code, { children: "||" }), ") Truth Table:"] }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "center" }, children: "Condition A" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Condition B" }), _jsxs(_components.th, { style: { textAlign: "center" }, children: ["A ", _jsx(_components.code, { children: "||" }), " B"] })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.strong, { children: "True" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.strong, { children: "True" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.strong, { children: "True" }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" })] })] })] }), _jsx(_components.p, { children: _jsxs(_components.strong, { children: ["NOT (", _jsx(_components.code, { children: "!" }), ") Truth Table:"] }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "center" }, children: "Condition A" }), _jsxs(_components.th, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "!" }), " A"] })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "True" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "False" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "False" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "True" })] })] })] })] }), _jsx(Note, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Short-circuit Evaluation:" }), " C uses short-circuit evaluation for ", _jsx(_components.code, { children: "&&" }), " and ", _jsx(_components.code, { children: "||" }), ". For ", _jsx(_components.code, { children: "&&" }), ", if the first condition is false, the second is ", _jsx(_components.strong, { children: "never evaluated" }), " (because the result is already false). For ", _jsx(_components.code, { children: "||" }), ", if the first condition is true, the second is ", _jsx(_components.strong, { children: "never evaluated" }), " (result is already true). This can be used strategically — for example, checking if a pointer is not NULL before dereferencing it: ", _jsx(_components.code, { children: "if (ptr != NULL && ptr->value > 0)" }), "."] }) }), _jsx(_components.hr, {}), _jsxs(English, { children: [_jsxs(_components.h3, { children: ["✅ The ", _jsx(_components.code, { children: "if" }), " Statement — Simple Decision Making"] }), _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "if" }), " statement is the most basic conditional. It evaluates a condition and executes the block inside ", _jsx(_components.strong, { children: "only if the condition is true" }), "."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Syntax:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "if (condition) {\r\n // statements to execute if condition is TRUE\r\n}\n" }) }), _jsx(_components.p, { children: "Let's see a real example:" })] }), _jsxs(Hinglish, { children: [_jsxs(_components.h3, { children: ["✅ ", _jsx(_components.code, { children: "if" }), " Statement — Simple Decision Making"] }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "if" }), " statement sabse basic conditional hai. Yeh ek condition evaluate karta hai aur sirf tab block ke andar ke statements execute karta hai ", _jsx(_components.strong, { children: "jab condition true ho" }), "."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Syntax:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "if (condition) {\r\n // statements jo execute honge agar condition TRUE ho\r\n}\n" }) }), _jsx(_components.p, { children: "Ek real example dekhte hain:" })] }), _jsxs(CodeBlock, { language: "c", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\nint marks;\r\nprintf(\"Enter your marks: \");\r\nscanf(\"%d\", &marks);"] }), _jsxs(_components.p, { children: ["if (marks >= 40) ", "{", "\r\nprintf(\"Congratulations! You passed!\\n\");"] }), "}", _jsxs(_components.p, { children: ["printf(\"Your marks: %d\\n\", marks);\r\nreturn 0;\r\n", "}", "`", "}"] })] }), _jsxs(English, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "How it works:" }), " If the user enters ", _jsx(_components.code, { children: "50" }), ", the condition ", _jsx(_components.code, { children: "50 >= 40" }), " is true, so \"Congratulations! You passed!\" is printed. If the user enters ", _jsx(_components.code, { children: "30" }), ", the condition is false, so that printf is ", _jsx(_components.strong, { children: "skipped entirely" }), ". Either way, the final printf runs because it's outside the ", _jsx(_components.code, { children: "if" }), " block."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Note:" }), " If there's only ", _jsx(_components.strong, { children: "one statement" }), " inside the ", _jsx(_components.code, { children: "if" }), " block, the curly braces ", _jsx(_components.code, { children: "{}" }), " are optional (but it's a good practice to always include them):"] })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Yeh kaise kaam karta hai:" }), " Agar user ", _jsx(_components.code, { children: "50" }), " enter karta hai, toh condition ", _jsx(_components.code, { children: "50 >= 40" }), " true hai, toh \"Congratulations! You passed!\" print hota hai. Agar user ", _jsx(_components.code, { children: "30" }), " enter karta hai, toh condition false hai, toh woh printf ", _jsx(_components.strong, { children: "poori tarah skip" }), " ho jata hai. Dono cases mein,最后 woh printf run hoga kyunki woh ", _jsx(_components.code, { children: "if" }), " block ke bahar hai."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Note:" }), " Agar ", _jsx(_components.code, { children: "if" }), " block mein sirf ", _jsx(_components.strong, { children: "ek statement" }), " ho, toh curly braces ", _jsx(_components.code, { children: "{}" }), " optional hain (lekin hamesha include karna achha practice hai):"] })] }), _jsxs(CodeBlock, { language: "c", children: [_jsxs(_components.p, { children: ["{", "`// Single statement — curly braces optional (but NOT recommended)\r\nif (marks >= 40)\r\nprintf(\"You passed!\\n\");"] }), _jsxs(_components.p, { children: ["// Best practice — always use curly braces\r\nif (marks >= 40) ", "{", "\r\nprintf(\"You passed!\\n\");\r\n", "}", "`", "}"] })] }), _jsx(_components.hr, {}), _jsxs(English, { children: [_jsxs(_components.h3, { children: ["🔀 The ", _jsx(_components.code, { children: "if-else" }), " Statement — Two Paths"] }), _jsxs(_components.p, { children: ["What if you want to do something when the condition is ", _jsx(_components.strong, { children: "false" }), " too? The ", _jsx(_components.code, { children: "if-else" }), " statement provides an ", _jsx(_components.strong, { children: "else block" }), " that runs when the condition fails."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Syntax:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "if (condition) {\r\n // runs when condition is TRUE\r\n} else {\r\n // runs when condition is FALSE\r\n}\n" }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.h3, { children: ["🔀 ", _jsx(_components.code, { children: "if-else" }), " Statement — Do Raastein"] }), _jsxs(_components.p, { children: ["Agar tumhe condition ", _jsx(_components.strong, { children: "false" }), " hone par bhi kuch karna ho? ", _jsx(_components.code, { children: "if-else" }), " statement ek ", _jsx(_components.strong, { children: "else block" }), " provide karta hai jo tab run hota hai jab condition fail ho jaaye."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Syntax:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "if (condition) {\r\n // tab run hoga jab condition TRUE ho\r\n} else {\r\n // tab run hoga jab condition FALSE ho\r\n}\n" }) })] }), _jsxs(CodeBlock, { language: "c", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\nint num;\r\nprintf(\"Enter a number: \");\r\nscanf(\"%d\", &num);"] }), _jsxs(_components.p, { children: ["if (num % 2 == 0) ", "{", "\r\nprintf(\"%d is Even\\n\", num);\r\n", "}", " else ", "{", "\r\nprintf(\"%d is Odd\\n\", num);"] }), "}", _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsx(English, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Key point:" }), " In an ", _jsx(_components.code, { children: "if-else" }), ", ", _jsx(_components.strong, { children: "exactly one" }), " block always executes — either the ", _jsx(_components.code, { children: "if" }), " block or the ", _jsx(_components.code, { children: "else" }), " block, never both, never none. This is what makes ", _jsx(_components.code, { children: "if-else" }), " more powerful than a plain ", _jsx(_components.code, { children: "if" }), "."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Key point:" }), " ", _jsx(_components.code, { children: "if-else" }), " mein ", _jsx(_components.strong, { children: "hamesha ek hi block" }), " execute hota hai — ya toh ", _jsx(_components.code, { children: "if" }), " block ya ", _jsx(_components.code, { children: "else" }), " block, dono nahi, koi bhi nahi. Yahi baat ", _jsx(_components.code, { children: "if-else" }), " ko plain ", _jsx(_components.code, { children: "if" }), " se zyada powerful banati hai."] }) }), _jsx(_components.hr, {}), _jsxs(English, { children: [_jsx(_components.h3, { children: "🪆 Nested if-else — Conditions Inside Conditions" }), _jsxs(_components.p, { children: ["When a condition leads to ", _jsx(_components.strong, { children: "another check" }), ", we place an ", _jsx(_components.code, { children: "if" }), " inside another ", _jsx(_components.code, { children: "if" }), " or ", _jsx(_components.code, { children: "else" }), " — this is called ", _jsx(_components.strong, { children: "nesting" }), "."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Syntax:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "if (condition1) {\r\n if (condition2) {\r\n // runs when both condition1 AND condition2 are true\r\n } else {\r\n // runs when condition1 is true but condition2 is false\r\n }\r\n} else {\r\n // runs when condition1 is false\r\n}\n" }) })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🪆 Nested if-else — Conditions Ke Andar Conditions" }), _jsxs(_components.p, { children: ["Jab ek condition ke baad ", _jsx(_components.strong, { children: "doosra check" }), " karna ho, toh hum ek ", _jsx(_components.code, { children: "if" }), " ko doosre ", _jsx(_components.code, { children: "if" }), " ya ", _jsx(_components.code, { children: "else" }), " ke andar rakhte hain — isko ", _jsx(_components.strong, { children: "nesting" }), " bolte hain."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Syntax:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "if (condition1) {\r\n if (condition2) {\r\n // tab run hoga jab condition1 AND condition2 dono true ho\r\n } else {\r\n // tab run hoga jab condition1 true ho lekin condition2 false ho\r\n }\r\n} else {\r\n // tab run hoga jab condition1 false ho\r\n}\n" }) })] }), _jsxs(CodeBlock, { language: "c", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\nint age;\r\nchar hasID;"] }), _jsx(_components.p, { children: "printf(\"Enter your age: \");\r\nscanf(\"%d\", &age);\r\nprintf(\"Do you have an ID card? (y/n): \");\r\nscanf(\" %c\", &hasID);" }), _jsxs(_components.p, { children: ["if (age >= 18) ", "{", "\r\nif (hasID ", _jsx("mark", { children: " 'y' || hasID " }), " 'Y') ", "{", "\r\nprintf(\"Entry allowed!\\n\");\r\n", "}", " else ", "{", "\r\nprintf(\"Sorry, you need an ID card.\\n\");"] }), "}", _jsxs(_components.p, { children: ["}", " else ", "{", "\r\nprintf(\"Sorry, you must be 18 or older.\\n\");"] }), "}", _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsxs(English, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "How the flow works:" }), " The program first checks the ", _jsx(_components.strong, { children: "outer condition" }), " (age >= 18). Only if that's true does it enter the inner block and check the ", _jsx(_components.strong, { children: "inner condition" }), " (hasID). This creates a hierarchical decision tree."] }), _jsx(Remember, { title: "⚠️ Avoid Deep Nesting", children: _jsxs(_components.p, { children: ["While nesting is useful, avoid going more than 3 levels deep — it makes code hard to read and debug. If you find yourself deeply nesting, consider using ", _jsx(_components.code, { children: "&&" }), " and ", _jsx(_components.code, { children: "||" }), " to combine conditions, or restructure your logic."] }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Flow kaise kaam karta hai:" }), " Program pehle ", _jsx(_components.strong, { children: "outer condition" }), " (age >= 18) check karta hai. Sirf jab woh true ho, tabhi woh inner block mein jaake ", _jsx(_components.strong, { children: "inner condition" }), " (hasID) check karta hai. Yeh ek hierarchical decision tree create karta hai."] }), _jsx(Remember, { title: "⚠️ Deep Nesting Se Bacho", children: _jsxs(_components.p, { children: ["Nesting useful hai, lekin 3 levels se zyada deep mat jaao — code padhna aur debug karna mushkil ho jata hai. Agar tumhe lagta hai ki bahut deep nesting ho rahi hai, toh ", _jsx(_components.code, { children: "&&" }), " aur ", _jsx(_components.code, { children: "||" }), " use karke conditions combine karo, ya logic ko restructure karo."] }) })] }), _jsx(_components.hr, {}), _jsxs(English, { children: [_jsx(_components.h3, { children: "🪜 The if-else Ladder — Multiple Choices" }), _jsxs(_components.p, { children: ["When you have ", _jsx(_components.strong, { children: "many possible outcomes" }), " to check one after another, the ", _jsx(_components.strong, { children: "if-else ladder" }), " is your tool. Conditions are evaluated from top to bottom, and the ", _jsx(_components.strong, { children: "first true condition's block executes" }), " — the rest are skipped."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Syntax:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "if (condition1) {\r\n // runs if condition1 is true\r\n} else if (condition2) {\r\n // runs if condition1 is false AND condition2 is true\r\n} else if (condition3) {\r\n // runs if condition1, condition2 both false AND condition3 is true\r\n} else {\r\n // runs if ALL conditions above are false (default case)\r\n}\n" }) })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🪜 if-else Ladder — Bahut Saare Choices" }), _jsxs(_components.p, { children: ["Jab ", _jsx(_components.strong, { children: "bahut saare possible outcomes" }), " ek ke baad ek check karne ho, toh ", _jsx(_components.strong, { children: "if-else ladder" }), " tumhara tool hai. Conditions upar se neeche evaluate hoti hain, aur ", _jsx(_components.strong, { children: "pehli true condition ka block execute" }), " hota hai — baaki sab skip ho jaate hain."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Syntax:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "if (condition1) {\r\n // tab run hoga jab condition1 true ho\r\n} else if (condition2) {\r\n // tab run hoga jab condition1 false AND condition2 true ho\r\n} else if (condition3) {\r\n // tab run hoga jab condition1, condition2 dono false AND condition3 true ho\r\n} else {\r\n // tab run hoga jab upar ki saari conditions false ho (default case)\r\n}\n" }) })] }), _jsxs(CodeBlock, { language: "c", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\nint marks;\r\nprintf(\"Enter your marks: \");\r\nscanf(\"%d\", &marks);"] }), _jsxs(_components.p, { children: ["if (marks >= 90) ", "{", "\r\nprintf(\"Grade: A+\\n\");\r\n", "}", " else if (marks >= 80) ", "{", "\r\nprintf(\"Grade: A\\n\");\r\n", "}", " else if (marks >= 70) ", "{", "\r\nprintf(\"Grade: B\\n\");\r\n", "}", " else if (marks >= 60) ", "{", "\r\nprintf(\"Grade: C\\n\");\r\n", "}", " else if (marks >= 40) ", "{", "\r\nprintf(\"Grade: D\\n\");\r\n", "}", " else ", "{", "\r\nprintf(\"Grade: F (Fail)\\n\");"] }), "}", _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsxs(English, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Why the order matters:" }), " If a student scores ", _jsx(_components.code, { children: "95" }), ", the first condition ", _jsx(_components.code, { children: "marks >= 90" }), " is true, so \"Grade: A+\" is printed and the ", _jsx(_components.strong, { children: "entire rest of the ladder is skipped" }), ". The program doesn't check ", _jsx(_components.code, { children: "marks >= 80" }), " even though 95 is also >= 80. This is because once a true condition is found, no further conditions are evaluated."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Practical example — Grading System:" }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Order kyun matter karta hai:" }), " Agar student ", _jsx(_components.code, { children: "95" }), " score karta hai, toh pehli condition ", _jsx(_components.code, { children: "marks >= 90" }), " true hai, toh \"Grade: A+\" print hota hai aur ", _jsx(_components.strong, { children: "poora baaki ladder skip" }), " ho jata hai. Program ", _jsx(_components.code, { children: "marks >= 80" }), " check nahi karta chahe 95 >= 80 bhi hai. Yeh isliye kyunki jab ek true condition mil jaati hai, toh aur koi condition evaluate nahi hoti."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Practical example — Grading System:" }) })] }), _jsxs(StepByStep, { title: "if-else Ladder: Marks is 75 Example", children: [_jsx(Step, { title: "Step 1: Check marks > is 90", children: _jsxs(_components.p, { children: ["75 >= 90? → ", _jsx(_components.strong, { children: "False" }), ". Skip this block, move to next."] }) }), _jsx(Step, { title: "Step 2: Check marks > is 80", children: _jsxs(_components.p, { children: ["75 >= 80? → ", _jsx(_components.strong, { children: "False" }), ". Skip this block, move to next."] }) }), _jsx(Step, { title: "Step 3: Check marks > is 70", children: _jsxs(_components.p, { children: ["75 >= 70? → ", _jsx(_components.strong, { children: "True!" }), " Execute this block. Print \"Grade: B\"."] }) }), _jsx(Step, { title: "Step 4: Remaining conditions skipped", children: _jsxs(_components.p, { children: ["Since Step 3 matched, ", _jsx(_components.code, { children: "marks >= 60" }), ", ", _jsx(_components.code, { children: "marks >= 40" }), ", and ", _jsx(_components.code, { children: "else" }), " are all ", _jsx(_components.strong, { children: "skipped" }), ". The ladder exits immediately."] }) })] }), _jsx(_components.hr, {}), _jsxs(English, { children: [_jsxs(_components.h3, { children: ["🔄 The ", _jsx(_components.code, { children: "switch" }), " Statement — Multi-way Branching"] }), _jsxs(_components.p, { children: ["When you need to compare a ", _jsx(_components.strong, { children: "single variable" }), " against many ", _jsx(_components.strong, { children: "fixed constant values" }), ", the ", _jsx(_components.code, { children: "switch" }), " statement provides a cleaner and more readable alternative to a long if-else ladder."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Syntax:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "switch (expression) {\r\n case value1:\r\n // runs when expression == value1\r\n break;\r\n case value2:\r\n // runs when expression == value2\r\n break;\r\n case value3:\r\n // runs when expression == value3\r\n break;\r\n default:\r\n // runs when no case matches (optional)\r\n break;\r\n}\n" }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.h3, { children: ["🔄 ", _jsx(_components.code, { children: "switch" }), " Statement — Multi-way Branching"] }), _jsxs(_components.p, { children: ["Jab tumhe ek ", _jsx(_components.strong, { children: "single variable" }), " ko bahut saare ", _jsx(_components.strong, { children: "fixed constant values" }), " se compare karna ho, toh ", _jsx(_components.code, { children: "switch" }), " statement long if-else ladder ki jagah ek cleaner aur more readable alternative提供 karta hai."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Syntax:" }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "switch (expression) {\r\n case value1:\r\n // tab run hoga jab expression == value1\r\n break;\r\n case value2:\r\n // tab run hoga jab expression == value2\r\n break;\r\n case value3:\r\n // tab run hoga jab expression == value3\r\n break;\r\n default:\r\n // tab run hoga jab koi case match na kare (optional)\r\n break;\r\n}\n" }) })] }), _jsxs(CodeBlock, { language: "c", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\nint day;\r\nprintf(\"Enter day number (1-7): \");\r\nscanf(\"%d\", &day);"] }), _jsxs(_components.p, { children: ["switch (day) ", "{", "\r\ncase 1:\r\nprintf(\"Monday\\n\");\r\nbreak;\r\ncase 2:\r\nprintf(\"Tuesday\\n\");\r\nbreak;\r\ncase 3:\r\nprintf(\"Wednesday\\n\");\r\nbreak;\r\ncase 4:\r\nprintf(\"Thursday\\n\");\r\nbreak;\r\ncase 5:\r\nprintf(\"Friday\\n\");\r\nbreak;\r\ncase 6:\r\nprintf(\"Saturday\\n\");\r\nbreak;\r\ncase 7:\r\nprintf(\"Sunday\\n\");\r\nbreak;\r\ndefault:\r\nprintf(\"Invalid day number!\\n\");\r\nbreak;"] }), "}", _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsxs(English, { children: [_jsxs(_components.h3, { children: ["⚠️ The Critical Role of ", _jsx(_components.code, { children: "break" })] }), _jsxs(_components.p, { children: ["Without ", _jsx(_components.code, { children: "break" }), ", the ", _jsx(_components.code, { children: "switch" }), " statement exhibits ", _jsx(_components.strong, { children: "fall-through" }), " behavior — once a matching case is found, execution continues through ", _jsx(_components.strong, { children: "all subsequent cases" }), " until a ", _jsx(_components.code, { children: "break" }), " is encountered or the switch ends."] })] }), _jsxs(Hinglish, { children: [_jsxs(_components.h3, { children: ["⚠️ ", _jsx(_components.code, { children: "break" }), " Ka Critical Role"] }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "break" }), " ke bina, ", _jsx(_components.code, { children: "switch" }), " statement ", _jsx(_components.strong, { children: "fall-through" }), " behavior dikhata hai — jab ek matching case mil jaata hai, toh execution ", _jsx(_components.strong, { children: "saare baaki cases" }), " mein chala jaata hai jab tak ", _jsx(_components.code, { children: "break" }), " na mile ya switch khatam na ho jaaye."] })] }), _jsxs(CodeBlock, { language: "c", children: [_jsxs(_components.p, { children: ["{", "`// WITHOUT break — fall-through example\r\n#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\nint num = 2;"] }), _jsxs(_components.p, { children: ["switch (num) ", "{", "\r\ncase 1:\r\nprintf(\"One\\n\");\r\n// no break — falls through!\r\ncase 2:\r\nprintf(\"Two\\n\");\r\n// no break — falls through!\r\ncase 3:\r\nprintf(\"Three\\n\");\r\n// no break — falls through!\r\ndefault:\r\nprintf(\"Default\\n\");\r\nbreak;"] }), "}", _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsxs(English, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Output:" }), " ", _jsx(_components.code, { children: "Two" }), ", ", _jsx(_components.code, { children: "Three" }), ", ", _jsx(_components.code, { children: "Default" }), " — all three are printed! Because ", _jsx(_components.code, { children: "num = 2" }), " matches ", _jsx(_components.code, { children: "case 2" }), ", but since there's no ", _jsx(_components.code, { children: "break" }), ", execution \"falls through\" to case 3, then to default. This is often a ", _jsx(_components.strong, { children: "bug" }), ", but sometimes it's used intentionally (e.g., grouping multiple cases to share the same code)."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Intentional fall-through example — grouping cases:" }) })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Output:" }), " ", _jsx(_components.code, { children: "Two" }), ", ", _jsx(_components.code, { children: "Three" }), ", ", _jsx(_components.code, { children: "Default" }), " — teeno print hote hain! Kyunki ", _jsx(_components.code, { children: "num = 2" }), " matches ", _jsx(_components.code, { children: "case 2" }), ", lekin ", _jsx(_components.code, { children: "break" }), " nahi hai, toh execution \"fall through\" ho ke case 3 mein chala jaata hai, phir default mein. Yeh aksar ek ", _jsx(_components.strong, { children: "bug" }), " hota hai, lekin kabhi kabhi yeh intentionally use hota hai (jaise, multiple cases ko group karke same code share karna)."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Intentional fall-through example — cases ko group karna:" }) })] }), _jsxs(CodeBlock, { language: "c", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\nint day;\r\nprintf(\"Enter day number (1-7): \");\r\nscanf(\"%d\", &day);"] }), _jsxs(_components.p, { children: ["switch (day) ", "{", "\r\ncase 1:\r\ncase 2:\r\ncase 3:\r\ncase 4:\r\ncase 5:\r\nprintf(\"Weekday\\n\");\r\nbreak;\r\ncase 6:\r\ncase 7:\r\nprintf(\"Weekend\\n\");\r\nbreak;\r\ndefault:\r\nprintf(\"Invalid!\\n\");\r\nbreak;"] }), "}", _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsxs(English, { children: [_jsxs(_components.p, { children: ["Here, cases 1 through 5 ", _jsx(_components.strong, { children: "fall through" }), " and all execute the same ", _jsx(_components.code, { children: "printf(\"Weekday\\\\n\")" }), ". This is a clean and intentional use of fall-through to group Monday–Friday as weekdays."] }), _jsxs(_components.h3, { children: ["📌 Important Rules of ", _jsx(_components.code, { children: "switch" })] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.code, { children: "expression" }), " must evaluate to an ", _jsx(_components.strong, { children: "integer type" }), " (", _jsx(_components.code, { children: "int" }), ", ", _jsx(_components.code, { children: "char" }), ", or ", _jsx(_components.code, { children: "enum" }), "). You ", _jsx(_components.strong, { children: "cannot" }), " use ", _jsx(_components.code, { children: "float" }), ", ", _jsx(_components.code, { children: "double" }), ", or ", _jsx(_components.code, { children: "string" }), " directly."] }), "\n", _jsxs(_components.li, { children: ["Each ", _jsx(_components.code, { children: "case" }), " value must be a ", _jsx(_components.strong, { children: "constant expression" }), " — no variables allowed (e.g., ", _jsx(_components.code, { children: "case x + 1:" }), " is invalid)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "case" }), " values must be ", _jsx(_components.strong, { children: "unique" }), " — no two cases can have the same value."] }), "\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.code, { children: "default" }), " case is ", _jsx(_components.strong, { children: "optional" }), " and can be placed anywhere in the switch, but conventionally goes at the end."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "break" }), " is what stops the fall-through. Forgetting ", _jsx(_components.code, { children: "break" }), " is one of the most common bugs in C programming."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsxs(_components.p, { children: ["Yahan, cases 1 se 5 tak ", _jsx(_components.strong, { children: "fall through" }), " hoke same ", _jsx(_components.code, { children: "printf(\"Weekday\\\\n\")" }), " execute karte hain. Yeh fall-through ka ek clean aur intentional use hai Monday–Friday ko weekdays mein group karne ke liye."] }), _jsxs(_components.h3, { children: ["📌 ", _jsx(_components.code, { children: "switch" }), " Ke Important Rules"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "expression" }), " ko ", _jsx(_components.strong, { children: "integer type" }), " mein evaluate hona chahiye (", _jsx(_components.code, { children: "int" }), ", ", _jsx(_components.code, { children: "char" }), ", ya ", _jsx(_components.code, { children: "enum" }), "). ", _jsx(_components.code, { children: "float" }), ", ", _jsx(_components.code, { children: "double" }), ", ya ", _jsx(_components.code, { children: "string" }), " directly use ", _jsx(_components.strong, { children: "nahi kar sakte" }), "."] }), "\n", _jsxs(_components.li, { children: ["Har ", _jsx(_components.code, { children: "case" }), " value ek ", _jsx(_components.strong, { children: "constant expression" }), " honi chahiye — variables allowed nahi hain (jaise ", _jsx(_components.code, { children: "case x + 1:" }), " invalid hai)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "case" }), " values ", _jsx(_components.strong, { children: "unique" }), " honi chahiye — do cases ki same value nahi ho sakti."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "default" }), " case ", _jsx(_components.strong, { children: "optional" }), " hai aur switch mein kahin bhi ho sakta hai, lekin generally end mein hota hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "break" }), " woh hai jo fall-through ko rokta hai. ", _jsx(_components.code, { children: "break" }), " bhool jaana C programming ki sabse common bugs mein se ek hai."] }), "\n"] })] }), _jsx(_components.hr, {}), _jsx(English, { children: _jsx(_components.h3, { children: "📊 if-else vs switch — When to Use What" }) }), _jsx(Hinglish, { children: _jsx(_components.h3, { children: "📊 if-else vs switch — Kab Kya Use Karein" }) }), _jsx(ComparisonTable, { title: "if-else vs switch — Detailed Comparison", 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: "if-else" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "switch" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Compares" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Any type of expression" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Single integer/char expression" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Conditions" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Can use ranges, complex logic" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Must match exact constant values" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Multiple conditions" }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Easy with ", _jsx(_components.code, { children: "&&" }), " and ", _jsx(_components.code, { children: "||" })] }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Not directly possible" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Readability" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Can get messy with many branches" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Cleaner for multiple fixed values" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Performance" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "May be slower for many equalities" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Compiler can optimize with jump table" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Fall-through" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Not applicable" }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Happens without ", _jsx(_components.code, { children: "break" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Best for" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Complex decisions, ranges" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Menu-driven programs, fixed value matching" })] })] })] }) }), _jsx(_components.hr, {}), _jsxs(English, { children: [_jsx(_components.h3, { children: "🎯 Complete Program — Putting It All Together" }), _jsx(_components.p, { children: "Let's write a program that uses multiple conditional constructs together — a simple calculator:" })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🎯 Complete Program — Sab Kuch Ek Saath" }), _jsx(_components.p, { children: "Ek program likhte hain jo multiple conditional constructs ko saath mein use kare — ek simple calculator:" })] }), _jsxs(CodeBlock, { language: "c", children: [_jsxs(_components.p, { children: ["{", "`#include ", "<", "stdio.h>"] }), _jsxs(_components.p, { children: ["int main() ", "{", "\r\nfloat num1, num2, result;\r\nchar operator;"] }), _jsx(_components.p, { children: "printf(\"Enter first number: \");\r\nscanf(\"%f\", &num1);\r\nprintf(\"Enter operator (+, -, *, /): \");\r\nscanf(\" %c\", &operator);\r\nprintf(\"Enter second number: \");\r\nscanf(\"%f\", &num2);" }), _jsxs(_components.p, { children: ["// if-else ladder for input validation\r\nif (operator != '+' && operator != '-'\r\n&& operator != '*' && operator != '/') ", "{", "\r\nprintf(\"Invalid operator!\\n\");\r\nreturn 1; // exit with error"] }), "}", _jsxs(_components.p, { children: ["// Nested if-else for division by zero check\r\nif (operator == '/') ", "{", "\r\nif (num2 == 0) ", "{", "\r\nprintf(\"Error: Division by zero!\\n\");\r\nreturn 1;"] }), "}", "}", _jsxs(_components.p, { children: ["// switch for performing the operation\r\nswitch (operator) ", "{", "\r\ncase '+':\r\nresult = num1 + num2;\r\nprintf(\"%.2f + %.2f = %.2f\\n\", num1, num2, result);\r\nbreak;\r\ncase '-':\r\nresult = num1 - num2;\r\nprintf(\"%.2f - %.2f = %.2f\\n\", num1, num2, result);\r\nbreak;\r\ncase '*':\r\nresult = num1 * num2;\r\nprintf(\"%.2f * %.2f = %.2f\\n\", num1, num2, result);\r\nbreak;\r\ncase '/':\r\nresult = num1 / num2;\r\nprintf(\"%.2f / %.2f = %.2f\\n\", num1, num2, result);\r\nbreak;"] }), "}", _jsxs(_components.p, { children: ["return 0;\r\n", "}", "`", "}"] })] }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Relational operators" }), " (", _jsx(_components.code, { children: "==" }), ", ", _jsx(_components.code, { children: "!=" }), ", ", _jsx(_components.code, { children: ">" }), ", ", _jsx(_components.code, { children: "<" }), ", ", _jsx(_components.code, { children: ">=" }), ", ", _jsx(_components.code, { children: "<=" }), ") compare two values and return 1 (true) or 0 (false). Never confuse ", _jsx(_components.code, { children: "==" }), " (comparison) with ", _jsx(_components.code, { children: "=" }), " (assignment)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Logical operators" }), " (", _jsx(_components.code, { children: "&&" }), ", ", _jsx(_components.code, { children: "||" }), ", ", _jsx(_components.code, { children: "!" }), ") combine multiple conditions. ", _jsx(_components.code, { children: "&&" }), " requires both true, ", _jsx(_components.code, { children: "||" }), " requires at least one true, ", _jsx(_components.code, { children: "!" }), " reverses the result."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.code, { children: "if" }) }), " executes code only when a condition is true. ", _jsx(_components.strong, { children: _jsx(_components.code, { children: "if-else" }) }), " guarantees one of two blocks always runs."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Nested if-else" }), " handles hierarchical decisions but avoid going deeper than 3 levels."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "if-else ladder" }), " evaluates conditions top-to-bottom and executes the ", _jsx(_components.strong, { children: "first matching block" }), ", skipping the rest."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.code, { children: "switch" }) }), " is ideal for comparing one variable against many fixed values. Always use ", _jsx(_components.code, { children: "break" }), " to prevent fall-through."] }), "\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.code, { children: "switch" }), " expression must be an ", _jsx(_components.strong, { children: "integer or character type" }), " — no floats, doubles, or strings."] }), "\n", _jsxs(_components.li, { children: ["In C, ", _jsx(_components.strong, { children: "any non-zero value is true" }), " and ", _jsx(_components.strong, { children: "zero is false" }), " — there's no separate Boolean type."] }), "\n"] }) })] })] }), "\n", _jsx(Practical, { children: _jsxs(ImportantQA, { children: [_jsxs(QAQuestion, { marks: 2, children: [_jsx(Prompt, { children: "Define relational operators in C and list all six relational operators with their meaning." }), _jsx(Answer, { children: _jsxs(_components.h3, { children: ["🎯 Definition ", _jsx(_components.strong, { children: "Relational operators" }), " are used to compare two values (operands). The result of a relational expression is always either ", _jsx(_components.strong, { children: "1 (true)" }), " or ", _jsx(_components.strong, { children: "0 (false)" }), ". These are mainly used in conditional statements like ", _jsx(_components.code, { children: "if" }), ", ", _jsx(_components.code, { children: "if-else" }), ", and loops. ### 📝 List of Relational Operators | Operator | Meaning | Example | |----------|---------|---------| | ", _jsx(_components.code, { children: "" }), " | Equal to | ", _jsx(_components.code, { children: "5 5" }), " → 1 | | ", _jsx(_components.code, { children: "!=" }), " | Not equal to | ", _jsx(_components.code, { children: "5 != 3" }), " → 1 | | ", _jsx(_components.code, { children: ">" }), " | Greater than | ", _jsx(_components.code, { children: "7 > 3" }), " → 1 | | ", _jsx(_components.code, { children: "<" }), " | Less than | ", _jsx(_components.code, { children: "2 < 8" }), " → 1 | | ", _jsx(_components.code, { children: ">=" }), " | Greater than or equal to | ", _jsx(_components.code, { children: "5 >= 5" }), " → 1 | | ", _jsx(_components.code, { children: "<=" }), " | Less than or equal to | ", _jsx(_components.code, { children: "3 <= 7" }), " → 1 | ", _jsx(_components.code, { children: "==" }), " (equality check) is different from ", _jsx(_components.code, { children: "=" }), " (assignment). Writing ", _jsx(_components.code, { children: "if(a = 5)" }), " assigns 5 to ", _jsx(_components.code, { children: "a" }), " and always evaluates as true. Always use ", _jsx(_components.code, { children: "==" }), " for comparison!"] }) })] }), _jsxs(QAQuestion, { marks: 4, children: [_jsx(Prompt, { children: "Explain the if-else ladder in C with its syntax and a suitable example. Also mention one advantage and one limitation." }), _jsx(Answer, { children: _jsxs(_components.h3, { children: ["🎯 What is an if-else Ladder? An ", _jsx(_components.strong, { children: "if-else ladder" }), " allows the programmer to check multiple conditions one by one, from top to bottom. As soon as a condition evaluates to true, its corresponding block executes, and the rest of the ladder is skipped. ### 📝 Syntax ", _jsx(_components.code, { children: "c if (condition1) { // block 1 } else if (condition2) { // block 2 } else if (condition3) { // block 3 } else { // default block (if none of the above conditions are true) } " }), " ### 💡 Example — Grading System ", _jsx(_components.code, { children: "c #include int main() { int marks; printf("Enter marks: "); scanf("%d", &marks); if (marks >= 90) { printf("Grade: A+\\n"); } else if (marks >= 80) { printf("Grade: A\\n"); } else if (marks >= 70) { printf("Grade: B\\n"); } else if (marks >= 60) { printf("Grade: C\\n"); } else { printf("Grade: F (Fail)\\n"); } return 0; } " }), " ", _jsx(_components.strong, { children: "How it works:" }), " - If ", _jsx(_components.code, { children: "marks" }), " is 95, the first condition is true → prints \"Grade: A+\" and the rest of the ladder is skipped. - If ", _jsx(_components.code, { children: "marks" }), " is 75, first two conditions are false → third condition (", _jsx(_components.code, { children: ">= 70" }), ") is true → prints \"Grade: B\". - If ", _jsx(_components.code, { children: "marks" }), " is 40, all conditions are false → the ", _jsx(_components.code, { children: "else" }), " block executes → prints \"Grade: F\". ### ✅ Advantage - The ladder evaluates conditions ", _jsx(_components.strong, { children: "in order" }), ", so once a match is found, the remaining conditions are not checked — this saves time. - It is more efficient than writing multiple independent ", _jsx(_components.code, { children: "if" }), " statements because only one block among all branches will execute. ### ⚠️ Limitation - If too many ", _jsx(_components.code, { children: "else if" }), " conditions are used, the code becomes difficult to read and maintain. - All conditions must be logically related and properly ordered (e.g., checking ", _jsx(_components.code, { children: ">= 90" }), " before ", _jsx(_components.code, { children: ">= 80" }), "), otherwise unexpected results may occur."] }) })] }), _jsxs(QAQuestion, { marks: 6, children: [_jsx(Prompt, { children: "Write a C program using switch statement to build a simple calculator that performs addition, subtraction, multiplication, and division based on user choice. Also explain the working of switch statement and its syntax." }), _jsx(Answer, { children: _jsxs(_components.h3, { children: ["🎯 Working of switch Statement The ", _jsx(_components.code, { children: "switch" }), " statement is a ", _jsx(_components.strong, { children: "multi-way branching" }), " construct. It evaluates an integer or character expression and compares its value with each ", _jsx(_components.code, { children: "case" }), " label. If a match is found, the corresponding block of statements executes. The ", _jsx(_components.code, { children: "break" }), " statement is used to exit the switch after a case is executed. If no case matches, the ", _jsx(_components.code, { children: "default" }), " block runs. ### 📝 Syntax ", _jsx(_components.code, { children: "c switch (expression) { case value1: // statements break; case value2: // statements break; ... default: // statements (optional) } " }), " ", _jsx(_components.strong, { children: "Key rules:" }), " - The ", _jsx(_components.code, { children: "expression" }), " must evaluate to an ", _jsx(_components.strong, { children: "integer" }), " or ", _jsx(_components.strong, { children: "character" }), " type. - Each ", _jsx(_components.code, { children: "case" }), " value must be a ", _jsx(_components.strong, { children: "constant" }), " (not a variable). - ", _jsx(_components.code, { children: "break" }), " is essential; without it, execution ", _jsx(_components.strong, { children: "falls through" }), " to the next case. - ", _jsx(_components.code, { children: "default" }), " is optional but recommended as a fallback. ### 💡 Calculator Program ", _jsx(_components.code, { children: "c #include int main() { float num1, num2, result; int choice; printf("= Simple Calculator =\\n"); printf("1. Addition\\n"); printf("2. Subtraction\\n"); printf("3. Multiplication\\n"); printf("4. Division\\n"); printf("Enter your choice (1-4): "); scanf("%d", &choice); printf("Enter two numbers: "); scanf("%f %f", &num1, &num2); switch (choice) { case 1: result = num1 + num2; printf("%.2f + %.2f = %.2f\\n", num1, num2, result); break; case 2: result = num1 - num2; printf("%.2f - %.2f = %.2f\\n", num1, num2, result); break; case 3: result = num1 * num2; printf("%.2f * %.2f = %.2f\\n", num1, num2, result); break; case 4: if (num2 != 0) { result = num1 / num2; printf("%.2f / %.2f = %.2f\\n", num1, num2, result); } else { printf("Error: Division by zero is not allowed!\\n"); } break; default: printf("Invalid choice! Please enter a number between 1 and 4.\\n"); } return 0; } " }), " ### ▶️ Sample Output ", _jsx(_components.code, { children: "= Simple Calculator = 1. Addition 2. Subtraction 3. Multiplication 4. Division Enter your choice (1-4): 1 Enter two numbers: 10.5 3.2 10.50 + 3.20 = 13.70" }), " ### 🔍 How the Program Works 1. The user enters a ", _jsx(_components.strong, { children: "choice" }), " (1 to 4) and two numbers. 2. The ", _jsx(_components.code, { children: "switch(choice)" }), " compares the value of ", _jsx(_components.code, { children: "choice" }), " with each ", _jsx(_components.code, { children: "case" }), ". 3. If ", _jsx(_components.code, { children: "choice" }), " is ", _jsx(_components.code, { children: "3" }), ", it matches ", _jsx(_components.code, { children: "case 3" }), ", executes the multiplication block, then ", _jsx(_components.code, { children: "break" }), " takes the control out of the switch. 4. If the user enters an invalid number (e.g., 7), no case matches → the ", _jsx(_components.code, { children: "default" }), " block executes and shows an error message. Always handle the ", _jsx(_components.strong, { children: "division by zero" }), " case separately (using ", _jsx(_components.code, { children: "if" }), " inside ", _jsx(_components.code, { children: "case 4" }), ") because the ", _jsx(_components.code, { children: "switch" }), " itself cannot check such conditions at runtime."] }) })] })] }) }), "\n", _jsxs(Assessment, { topicId: "2.1", children: [_jsx(MCQ, { questions: [{ "id": "7ec8964b-072f-47b7-9ed9-6170d50d34ef", "q": "What is the value of the expression 5 > 3?", "options": ["0", "1", "True", "false"], "answer": 1, "hint": "Relational operators compare values and produce a boolean result.", "explanation": "The relational operator '>\n\n' returns true (1) if the left operand is greater than the right, otherwise false (0)." }, { "id": "331eded9-a197-4c08-acb1-2376999555a0", "q": "What is the result of (5 > 3) && (2 < 1)?", "options": ["0", "1", "True", "Compile error"], "answer": 0, "hint": "The && operator requires both conditions to be true for the entire expression to be true.", "explanation": "Logical AND (&&) returns true only when both operands are true. Since (5>\n\n3) is true and (2<1) is false, the entire expression is false (0)." }, { "id": "0ca304fb-ad2f-4ab6-9620-f9ae471d86a5", "q": "What is the output of: if(5) printf("Yes");?", "options": ["No output", "No", "Yes", "Compile error"], "answer": 2, "hint": "The if statement executes the following block only if the condition is non-zero.", "explanation": "In an if statement, if the condition is true (non-zero), the next single statement or block is executed. Here, the condition 5 is non-zero, so 'Yes' is printed." }, { "id": "dd35d53c-767c-49dd-af36-ea74f06c618f", "q": "What is the output of: if(10=\""=5)"\" printf("Yes"); else printf("No");?", "options": ["Yes", "Yes and No", "No output", "No"], "answer": 3, "hint": "In an if-else statement, the else block executes when the if condition is false (zero).", "explanation": "The condition (10 is is 5) is false (0), so the program jumps to the else block and executes printf("No")." }, { "id": "ccbc2768-0560-4976-865b-88d57ece5fc7", "q": "What is the output of: if(10>5) {\"{\"}"{\"{\"}"{\"}\"} if(10=\""=5)"\" printf("Yes"); else printf("Inner Else"); {\"{\"}"{\"}\"}"{\"}\"}?", "options": ["Yes", "Inner Else", "No output", "Compile error"], "answer": 1, "hint": "Nested if-else statements are evaluated in order of nesting.", "explanation": "The outer if condition (10 >\n\n5) is true, so the inner if is checked. The inner if condition (10 is is 5) is false, so its else block executes, printing 'Inner Else'." }, { "id": "2208086a-171b-458f-b582-c876265f85d2", "q": "What is the output for x=\""2"\" in: if(x=\""=1)"\" printf("One"); else if(x=\""=2)"\" printf("Two"); else if(x=\""=3)"\" printf("Three");?", "options": ["One", "Three", "Two", "No output"], "answer": 2, "hint": "In an if-else ladder, conditions are checked from top to bottom, and the first true condition's block executes.", "explanation": "The first condition (x is is 1) is false, the second (x is is 2) is true, so its block executes and prints 'Two'. The remaining conditions are not checked." }, { "id": "35cac1cb-5bde-401c-8c57-825acd031acf", "q": "What is the output of: switch(2) {\"{\"}"{\"{\"}"{\"}\"} case 1: printf("One"); break; case 2: printf("Case Two"); break; {\"{\"}"{\"}\"}"{\"}\"}?", "options": ["One", "OneCase Two", "Compile error", "Case Two"], "answer": 3, "hint": "In a switch statement, the expression is evaluated and matched with case constants.", "explanation": "The value of expression (2) matches case 2, so the code after 'case 2:' is executed, printing 'Case Two'. Without a break, it would fall through to the next case." }, { "id": "93385e32-4215-45e6-9050-c7795bf312c5", "q": "In a switch statement, what does the 'break' keyword do when used inside a case?", "options": ["Exits the switch block", "Continues to the next case", "Skips the current iteration", "Terminates the program"], "answer": 0, "hint": "The break statement in a switch case is used to exit the switch block.", "explanation": "After executing the code for case 3, the break statement terminates the switch. Without break, it would fall through and execute subsequent case blocks." }, { "id": "437b31eb-2c76-4e9c-a139-f00b9be18a34", "q": "What is the purpose of the 'default' case in a switch statement?", "options": ["It is mandatory", "Executes if no case matches", "Handles errors only", "Always executes first"], "answer": 1, "hint": "The default case in a switch executes when no other case matches the expression.", "explanation": "The default case is optional and is executed if the expression does not match any of the case constants. It is typically placed at the end." }, { "id": "0c508d7d-ec24-492f-a391-128d3ce109ea", "q": "What is the output for x=\""10"\" in: if(x > 10) printf("Greater"); else if(x == 10) printf("Equal to 10"); else printf("Less");?", "options": ["Greater", "Less", "Equal to 10", "GreaterEqual to 10"], "answer": 2, "hint": "In an if-else ladder, the conditions are evaluated sequentially until one is true.", "explanation": "The first condition (x >\n\n10) is false (x is 10, not greater), the second (x is is 10) is true, so 'Equal to 10' is printed. The remaining conditions are not evaluated." }], topicId: "2.1" }), _jsx(ContentAttribution, { sourceTitle: "Curriculum Reference", sourceUrl: "https://learningway.in", professor: "Faculty Review Team", model: "Curriculum AI", seoTitle: "Conditional statements", seoDesc: "Master Conditional statements with comprehensive notes, real-world examples, and practice quiz on LearningWay.", seoKeywords: "conditional statements, conditional statements notes, conditional 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."); }