"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", p: "p", pre: "pre", span: "span", strong: "strong", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {Analogy, Answer, Assessment, CodeBlock, ComparisonTable, ContentAttribution, DefinitionEntry, DefinitionGroup, English, Explanation, FormulaBox, Hinglish, ImportantQA, KeyPoints, MCQ, Practical, Prompt, QAQuestion, Remember, SubTopicHeader, Theory, TopicOverview} = _components; if (!Analogy) _missingMdxReference("Analogy", true); if (!Answer) _missingMdxReference("Answer", true); if (!Assessment) _missingMdxReference("Assessment", true); if (!CodeBlock) _missingMdxReference("CodeBlock", true); if (!ComparisonTable) _missingMdxReference("ComparisonTable", true); if (!ContentAttribution) _missingMdxReference("ContentAttribution", true); if (!DefinitionEntry) _missingMdxReference("DefinitionEntry", true); if (!DefinitionGroup) _missingMdxReference("DefinitionGroup", true); if (!English) _missingMdxReference("English", true); if (!Explanation) _missingMdxReference("Explanation", true); if (!FormulaBox) _missingMdxReference("FormulaBox", true); if (!Hinglish) _missingMdxReference("Hinglish", true); if (!ImportantQA) _missingMdxReference("ImportantQA", true); if (!KeyPoints) _missingMdxReference("KeyPoints", true); if (!MCQ) _missingMdxReference("MCQ", true); if (!Practical) _missingMdxReference("Practical", true); if (!Prompt) _missingMdxReference("Prompt", true); if (!QAQuestion) _missingMdxReference("QAQuestion", true); if (!Remember) _missingMdxReference("Remember", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Theory) _missingMdxReference("Theory", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); return _jsxs(_Fragment, { children: [_jsxs(Theory, { children: [_jsx(SubTopicHeader, { id: "1.5", title: "Assignments and Expressions" }), _jsx(English, { children: _jsx(TopicOverview, { title: "Assignments and Expressions in C", topicId: "1.5", readingTime: "9 min read", difficulty: "Medium", children: _jsxs(_components.p, { children: ["In any programming language, the most fundamental action is assigning values to variables and performing computations on them. In C, ", _jsx(_components.strong, { children: "expressions" }), " are combinations of variables, constants, and operators that produce a result, while ", _jsx(_components.strong, { children: "assignment statements" }), " store that result into a variable. This subtopic covers the essential building blocks of C expressions — simple and compound assignment statements, arithmetic operators for mathematical calculations, shift operators for binary-level manipulation, bitwise operators for working with individual bits, and the ", _jsx(_components.code, { children: "sizeof" }), " operator for finding the size of data types at runtime. Mastering these operators is crucial because they form the backbone of every computation you'll write in C."] }) }) }), _jsx(Hinglish, { children: _jsx(TopicOverview, { title: "C Mein Assignments and Expressions", topicId: "1.5", readingTime: "9 min read", difficulty: "Medium", children: _jsxs(_components.p, { children: ["Kisi bhi programming language mein sabse basic kaam hota hai values ko variables mein dena aur unpar calculations karna. C mein ", _jsx(_components.strong, { children: "expressions" }), " variables, constants, aur operators ka combination hoti hai jo ek result produce karti hai, aur ", _jsx(_components.strong, { children: "assignment statements" }), " us result ko variable mein store kar deti hain. Is subtopic mein hum C expressions ke core building blocks cover karenge — simple aur compound assignment statements, arithmetic calculations ke liye arithmetic operators, binary level par kaam karne ke liye shift operators, individual bits ke saath kaam karne ke liye bitwise operators, aur data type ka size pata lagane ke liye ", _jsx(_components.code, { children: "sizeof" }), " operator. In operators ko samajhna bahut zaroori hai kyunki yeh har C computation ki foundation hain."] }) }) }), _jsxs(DefinitionGroup, { children: [_jsx(DefinitionEntry, { term: "Expression", children: _jsxs(_components.p, { children: ["An expression is any valid combination of variables, constants, and operators that the C compiler evaluates to produce a single result value. Think of it as a mathematical phrase — for example, ", _jsx(_components.code, { children: "a + b * 2" }), " — that simplifies down to one value. Every expression has both a value and a data type."] }) }), _jsx(DefinitionEntry, { term: "Assignment Statement", children: _jsxs(_components.p, { children: ["An assignment statement is a command that evaluates the expression on its right-hand side and stores the resulting value into the variable on its left-hand side. The simplest form uses the ", _jsx(_components.code, { children: "=" }), " operator, like ", _jsx(_components.code, { children: "x = 10;" }), ", which puts the value ", _jsx(_components.code, { children: "10" }), " into the variable ", _jsx(_components.code, { children: "x" }), "."] }) }), _jsx(DefinitionEntry, { term: "Arithmetic Operators", children: _jsxs(_components.p, { children: ["Arithmetic operators are the basic mathematical operators used for performing calculations in C programs. They include addition (", _jsx(_components.code, { children: "+" }), "), subtraction (", _jsx(_components.code, { children: "-" }), "), multiplication (", _jsx(_components.code, { children: "*" }), "), division (", _jsx(_components.code, { children: "/" }), "), and modulus (", _jsx(_components.code, { children: "%" }), "), and they work on numeric values to produce arithmetic results."] }) }), _jsx(DefinitionEntry, { term: "Shift Operators", children: _jsxs(_components.p, { children: ["Shift operators are bitwise operators that shift the binary representation of a number to the left or right by a specified number of bit positions. The left shift (", _jsx(_components.code, { children: "<<" }), ") moves bits toward higher significance (effectively multiplying by powers of 2), and the right shift (", _jsx(_components.code, { children: ">>" }), ") moves bits toward lower significance (effectively dividing by powers of 2)."] }) }), _jsx(DefinitionEntry, { term: "Bitwise Operators", children: _jsxs(_components.p, { children: ["Bitwise operators work directly on the individual bits (binary digits) of integer values. Unlike logical operators that work on true/false conditions, bitwise operators such as AND (", _jsx(_components.code, { children: "&" }), "), OR (", _jsx(_components.code, { children: "|" }), "), XOR (", _jsx(_components.code, { children: "^" }), "), and NOT (", _jsx(_components.code, { children: "~" }), ") manipulate each bit position separately."] }) }), _jsx(DefinitionEntry, { term: "sizeof Operator", children: _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "sizeof" }), " is a unary compile-time operator that returns the size, in bytes, of a variable or a data type. For example, ", _jsx(_components.code, { children: "sizeof(int)" }), " typically returns ", _jsx(_components.code, { children: "4" }), " on modern systems, telling you that an ", _jsx(_components.code, { children: "int" }), " occupies 4 bytes of memory."] }) }), _jsx(DefinitionEntry, { term: "Operator Precedence", children: _jsxs(_components.p, { children: ["Operator precedence defines the order in which different operators are evaluated in an expression containing multiple operators. For instance, in ", _jsx(_components.code, { children: "a + b * c" }), ", multiplication (", _jsx(_components.code, { children: "*" }), ") has higher precedence than addition (", _jsx(_components.code, { children: "+" }), "), so ", _jsx(_components.code, { children: "b * c" }), " is evaluated first — just like in standard mathematics."] }) })] }), _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "📝 Simple Assignment Statements" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.strong, { children: "assignment statement" }), " is the most fundamental statement in C. Its purpose is to store a value into a variable. The syntax is straightforward:"] }), _jsx(_components.pre, { children: _jsx(_components.code, { children: "variable = expression;\n" }) }), _jsxs(_components.p, { children: ["Here, the ", _jsx(_components.strong, { children: "expression" }), " on the right-hand side (RHS) is evaluated first, and the resulting value is then stored into the ", _jsx(_components.strong, { children: "variable" }), " on the left-hand side (LHS). The ", _jsx(_components.code, { children: "=" }), " sign here is the ", _jsx(_components.strong, { children: "assignment operator" }), ", not the \"equals\" sign from mathematics."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Key rules for assignment statements:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["The left-hand side must be a ", _jsx(_components.strong, { children: "modifiable l-value" }), " (usually a variable)."] }), "\n", _jsx(_components.li, { children: "The right-hand side can be any valid expression — a constant, a variable, or a complex computation." }), "\n", _jsxs(_components.li, { children: ["The assignment itself produces a value (the value that was assigned), so you can chain assignments: ", _jsx(_components.code, { children: "a = b = c = 10;" }), " assigns ", _jsx(_components.code, { children: "10" }), " to all three variables."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📝 Simple Assignment Statements" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Assignment statement" }), " C ki sabse basic statement hai. Iska kaam hota hai ek value ko variable mein store karna. Syntax bahut simple hai:"] }), _jsx(_components.pre, { children: _jsx(_components.code, { children: "variable = expression;\n" }) }), _jsxs(_components.p, { children: ["Yahan ", _jsx(_components.strong, { children: "expression" }), " jo right-hand side (RHS) par hoti hai, pehle evaluate hoti hai, aur uska result left-hand side (LHS) ke variable mein store hota hai. Yahan ka ", _jsx(_components.code, { children: "=" }), " sign mathematical \"equals\" nahi hai — yeh ", _jsx(_components.strong, { children: "assignment operator" }), " hai."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Assignment statements ke important rules:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Left-hand side mein hamesha ek ", _jsx(_components.strong, { children: "modifiable l-value" }), " hona chahiye (usually ek variable)."] }), "\n", _jsx(_components.li, { children: "Right-hand side par koi bhi valid expression ho sakta hai — constant, variable, ya koi complex calculation." }), "\n", _jsxs(_components.li, { children: ["Assignment ka apna bhi ek value hota hai (jo value assign hui), isliye assignments ko chain bhi kar sakte ho: ", _jsx(_components.code, { children: "a = b = c = 10;" }), " teeno variables mein ", _jsx(_components.code, { children: "10" }), " assign kar deta hai."] }), "\n"] })] }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int a, b, c; // Simple assignment a = 10; printf("a = %d\\n", a); // Output: a = 10 // Assignment with expression b = a + 5; printf("b = %d\\n", b); // Output: b = 15 // Chained assignment a = b = c = 50; printf("a = %d, b = %d, c = %d\\n", a, b, c); // Output: a = 50, b = 50, c = 50 return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📝 Compound Assignment Operators" }), _jsxs(_components.p, { children: ["C provides ", _jsx(_components.strong, { children: "shorthand assignment operators" }), " (also called compound assignment operators) that combine an arithmetic or bitwise operation with assignment in a single step. Instead of writing ", _jsx(_components.code, { children: "a = a + 5" }), ", you can simply write ", _jsx(_components.code, { children: "a += 5" }), "."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📝 Compound Assignment Operators" }), _jsxs(_components.p, { children: ["C mein ", _jsx(_components.strong, { children: "shorthand assignment operators" }), " (compound assignment operators bhi kehte hain) hain jo ek arithmetic ya bitwise operation ko assignment ke saath combine karte hain. Instead of ", _jsx(_components.code, { children: "a = a + 5" }), " likhne ka, tum simply ", _jsx(_components.code, { children: "a += 5" }), " likh sakte ho."] })] }), _jsx(ComparisonTable, { title: "Compound Assignment 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: "Equivalent To" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Description" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "a += b" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "a = a + b" }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Add ", _jsx(_components.code, { children: "b" }), " to ", _jsx(_components.code, { children: "a" }), " and store in ", _jsx(_components.code, { children: "a" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "a -= b" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "a = a - b" }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Subtract ", _jsx(_components.code, { children: "b" }), " from ", _jsx(_components.code, { children: "a" }), " and store in ", _jsx(_components.code, { children: "a" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "a *= b" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "a = a * b" }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Multiply ", _jsx(_components.code, { children: "a" }), " by ", _jsx(_components.code, { children: "b" }), " and store in ", _jsx(_components.code, { children: "a" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "a /= b" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "a = a / b" }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Divide ", _jsx(_components.code, { children: "a" }), " by ", _jsx(_components.code, { children: "b" }), " and store in ", _jsx(_components.code, { children: "a" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "a %= b" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "a = a % b" }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Remainder of ", _jsx(_components.code, { children: "a / b" }), ", store in ", _jsx(_components.code, { children: "a" })] })] })] })] }) }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int x = 20; x += 5; // x = x + 5 → x = 25 printf("After x += 5 : x = %d\\n", x); x -= 3; // x = x - 3 → x = 22 printf("After x -= 3 : x = %d\\n", x); x *= 2; // x = x * 2 → x = 44 printf("After x *= 2 : x = %d\\n", x); x /= 4; // x = x / 4 → x = 11 printf("After x /= 4 : x = %d\\n", x); x %= 3; // x = x % 3 → x = 2 printf("After x %%= 3 : x = %d\\n", x); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "➕ Arithmetic Operators" }), _jsx(_components.p, { children: "Arithmetic operators are the mathematical workhorses of C. They perform basic calculations on numeric values. C provides five arithmetic operators:" })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "➕ Arithmetic Operators" }), _jsx(_components.p, { children: "Arithmetic operators C ke mathematical workhains hain. Yeh numeric values par basic calculations perform karte hain. C mein paanch arithmetic operators hain:" })] }), _jsx(ComparisonTable, { title: "Arithmetic 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: "Example" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Result" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Notes" })] }) }), _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: "Addition" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "17 + 5" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "22" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Adds two values" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "-" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Subtraction" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "17 - 5" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "12" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Subtracts RHS from LHS" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "*" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Multiplication" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "17 * 5" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "85" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Multiplies two values" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "/" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Division" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "17 / 5" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "3" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Integer division truncates decimal" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "%" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Modulus" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "17 % 5" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "2" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Returns remainder of division" })] })] })] }) }), _jsx(Remember, { title: "⚠️ Integer Division Trap", children: _jsxs(_components.p, { children: ["In C, when you divide two integers, the result is always an integer — the decimal part is ", _jsx(_components.strong, { children: "truncated" }), " (not rounded). For example, ", _jsx(_components.code, { children: "17 / 5" }), " gives ", _jsx(_components.code, { children: "3" }), ", not ", _jsx(_components.code, { children: "3.4" }), ". To get the decimal result, at least one operand must be a floating-point number: ", _jsx(_components.code, { children: "17.0 / 5" }), " gives ", _jsx(_components.code, { children: "3.4" }), "."] }) }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int a = 17, b = 5; printf("a + b = %d\\n", a + b); // 22 printf("a - b = %d\\n", a - b); // 12 printf("a * b = %d\\n", a * b); // 85 printf("a / b = %d\\n", a / b); // 3 (NOT 3.4) printf("a %% b = %d\\n", a % b); // 2 (remainder) // To get floating-point division float result = (float)a / b; printf("(float)a / b = %.1f\\n", result); // 3.4 // Modulus with negative numbers (C99+) printf("-17 %% 5 = %d\\n", -17 % 5); // -2 printf("17 %% -5 = %d\\n", 17 % -5); // 2 return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "↔️ Shift Operators" }), _jsxs(_components.p, { children: ["Shift operators work at the ", _jsx(_components.strong, { children: "binary level" }), ". They take the binary representation of a number and shift all bits to the left or right by a specified number of positions."] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Left Shift (", _jsx(_components.code, { children: "<<" }), ")"] }), ": Shifts bits to the left. Vacant positions on the right are filled with zeros. Each left shift effectively ", _jsx(_components.strong, { children: "multiplies" }), " the number by 2."] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Right Shift (", _jsx(_components.code, { children: ">>" }), ")"] }), ": Shifts bits to the right. The behavior for negative numbers depends on the system (arithmetic or logical shift). Each right shift effectively ", _jsx(_components.strong, { children: "divides" }), " the number by 2."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "↔️ Shift Operators" }), _jsxs(_components.p, { children: ["Shift operators ", _jsx(_components.strong, { children: "binary level" }), " par kaam karte hain. Yeh kisi number ki binary representation ko leti hain aur saare bits ko specified positions tak left ya right mein shift karti hain."] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Left Shift (", _jsx(_components.code, { children: "<<" }), ")"] }), ": Bits ko left mein shift karta hai. Right mein jo empty positions hoti hain unhe zero se fill kiya jaata hai. Har left shift effectively number ko ", _jsx(_components.strong, { children: "2 se multiply" }), " kar deta hai."] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Right Shift (", _jsx(_components.code, { children: ">>" }), ")"] }), ": Bits ko right mein shift karta hai. Negative numbers ke liye behaviour system pe depend karta hai (arithmetic ya logical shift). Har right shift effectively number ko ", _jsx(_components.strong, { children: "2 se divide" }), " kar deta hai."] }), "\n"] })] }), _jsxs(FormulaBox, { title: "Shift Operator Formulas", children: [_jsx(_components.span, { className: "katex-display", children: _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.5782em", verticalAlign: "-0.0391em" } }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "≪" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.4306em" } }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6667em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } }), _jsx(_components.span, { className: "mbin", children: "×" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7144em" } }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord", children: "2" }), _jsx(_components.span, { className: "msupsub", children: _jsx(_components.span, { className: "vlist-t", children: _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.7144em" }, children: _jsxs(_components.span, { style: { top: "-3.113em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mathnormal mtight", children: "n" }) })] }) }) }) }) })] })] })] }) }) }), _jsx(_components.span, { className: "katex-display", children: _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.5782em", verticalAlign: "-0.0391em" } }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "≫" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.4306em" } }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "1em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mopen", children: "⌊" }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } }), _jsx(_components.span, { className: "mbin", children: "÷" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "1em", verticalAlign: "-0.25em" } }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord", children: "2" }), _jsx(_components.span, { className: "msupsub", children: _jsx(_components.span, { className: "vlist-t", children: _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.7144em" }, children: _jsxs(_components.span, { style: { top: "-3.113em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mathnormal mtight", children: "n" }) })] }) }) }) }) })] }), _jsx(_components.span, { className: "mclose", children: "⌋" })] })] }) }) })] }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int a = 5; // Binary: 00000101 // Left Shift examples printf("5 << 1 = %d\\n", 5 << 1); // 10 (5 * 2^1) printf("5 << 2 = %d\\n", 5 << 2); // 20 (5 * 2^2) printf("5 << 3 = %d\\n", 5 << 3); // 40 (5 * 2^3) // Right Shift examples printf("20 >> 1 = %d\\n", 20 >> 1); // 10 (20 / 2^1) printf("20 >> 2 = %d\\n", 20 >> 2); // 5 (20 / 2^2) printf("20 >> 3 = %d\\n", 20 >> 3); // 2 (20 / 2^3, truncated) // Binary visualization for 5 << 1 // 5 = 00000101 // << 1 shifts left by 1 position // 10 = 00001010 return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "🔢 Bitwise Operators" }), _jsxs(_components.p, { children: ["Bitwise operators manipulate the ", _jsx(_components.strong, { children: "individual bits" }), " of integer values. They are extremely useful in low-level programming, hardware interfacing, and optimization. Understanding these operators requires familiarity with binary (base-2) number representation."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🔢 Bitwise Operators" }), _jsxs(_components.p, { children: ["Bitwise operators integer values ke ", _jsx(_components.strong, { children: "individual bits" }), " ke saath manipulation karte hain. Yeh low-level programming, hardware interfacing, aur optimization mein bahut useful hain. In operators ko samajhne ke liye binary (base-2) number representation ka knowledge hona zaroori hai."] })] }), _jsx(ComparisonTable, { title: "Bitwise 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: "left" }, children: "Description" }), _jsxs(_components.th, { style: { textAlign: "center" }, children: ["Example (", _jsx(_components.code, { children: "a=12" }), ", ", _jsx(_components.code, { children: "b=10" }), ")"] }), _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" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Both bits must be 1" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "1100 & 1010" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1000" }), " = ", _jsx(_components.code, { children: "8" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "|" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "OR" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "At least one bit must be 1" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "1100 | 1010" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "1110" }), " = ", _jsx(_components.code, { children: "14" })] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "^" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: "XOR" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Bits must be different" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "1100 ^ 1010" }) }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "0110" }), " = ", _jsx(_components.code, { children: "6" })] })] }), _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: "left" }, children: "Flips every bit" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "~12" }) }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "-13" }) })] })] })] }) }), _jsx(Remember, { title: "⚠️ Bitwise vs Logical Operators", children: _jsxs(_components.p, { children: ["Don't confuse ", _jsx(_components.code, { children: "&" }), " (bitwise AND) with ", _jsx(_components.code, { children: "&&" }), " (logical AND), and ", _jsx(_components.code, { children: "|" }), " (bitwise OR) with ", _jsx(_components.code, { children: "||" }), " (logical OR). Bitwise operators work on individual bits of integer values, while logical operators work on true/false (non-zero/zero) conditions and use ", _jsx(_components.strong, { children: "short-circuit evaluation" }), "."] }) }), _jsx(CodeBlock, { language: "c", children: `#include int main() { unsigned int a = 12; // Binary: 1100 unsigned int b = 10; // Binary: 1010 // Bitwise AND printf("a & b = %u\\n", a & b); // 8 (1000) // Bitwise OR printf("a | b = %u\\n", a | b); // 14 (1110) // Bitwise XOR printf("a ^ b = %u\\n", a ^ b); // 6 (0110) // Bitwise NOT printf("~a = %d\\n", ~a); // -13 (flips all bits) // Practical use: Check if a number is odd or even int num = 7; if (num & 1) { printf("%d is odd\\n", num); } else { printf("%d is even\\n", num); } // Practical use: Swap two numbers without temp variable int x = 5, y = 9; x = x ^ y; y = x ^ y; x = x ^ y; printf("x = %d, y = %d\\n", x, y); // x = 9, y = 5 return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📏 sizeof Operator" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.code, { children: "sizeof" }), " operator is a ", _jsx(_components.strong, { children: "unary operator" }), " that returns the size, in bytes, of its operand. It works on both data types and variables. This is particularly useful for:"] }), _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Checking how much memory a data type occupies." }), "\n", _jsxs(_components.li, { children: ["Writing portable code that adapts to different systems (since ", _jsx(_components.code, { children: "int" }), " might be 2 bytes on one system and 4 on another)."] }), "\n", _jsx(_components.li, { children: "Ensuring correct memory allocation." }), "\n"] }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "sizeof" }), " is evaluated at ", _jsx(_components.strong, { children: "compile time" }), " (not runtime), so it has zero performance cost."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📏 sizeof Operator" }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "sizeof" }), " operator ek ", _jsx(_components.strong, { children: "unary operator" }), " hai jo apne operand ka size ", _jsx(_components.strong, { children: "bytes" }), " mein return karta hai. Yeh data types dono par kaam karta hai aur variables par bhi. Yeh khaas taur par useful hai:"] }), _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Check karne ke liye ki koi data type kitne bytes ka memory occupy karta hai." }), "\n", _jsxs(_components.li, { children: ["Aisi ", _jsx(_components.strong, { children: "portable code" }), " likhne ke liye jo different systems par adapt ho sake (kyunki ", _jsx(_components.code, { children: "int" }), " ek system par 2 bytes ho sakta hai aur doosre par 4)."] }), "\n", _jsx(_components.li, { children: "Sahi memory allocation ensure karne ke liye." }), "\n"] }), _jsxs(_components.p, { children: [_jsx(_components.code, { children: "sizeof" }), " ", _jsx(_components.strong, { children: "compile time" }), " par evaluate hota hai (runtime par nahi), isliye iska performance cost zero hota hai."] })] }), _jsx(CodeBlock, { language: "c", children: `#include int main() { // sizeof with data types printf("Size of char = %lu byte\\n", sizeof(char)); printf("Size of int = %lu bytes\\n", sizeof(int)); printf("Size of float = %lu bytes\\n", sizeof(float)); printf("Size of double = %lu bytes\\n", sizeof(double)); // sizeof with variables int x = 42; printf("Size of x = %lu bytes\\n", sizeof(x)); // sizeof with expressions (evaluates type of result) double d = 3.14; printf("Size of d + 1 = %lu bytes\\n", sizeof(d + 1)); // Result type is double, so 8 bytes // Common use: finding number of elements in an array int arr[] = {10, 20, 30, 40, 50}; int length = sizeof(arr) / sizeof(arr[0]); printf("Array length = %d\\n", length); // 5 return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📊 Operator Precedence Overview" }), _jsxs(_components.p, { children: ["When an expression contains multiple operators, C follows a specific ", _jsx(_components.strong, { children: "precedence order" }), " to determine which operation is performed first. Operators with higher precedence are evaluated before operators with lower precedence. When two operators have the same precedence, ", _jsx(_components.strong, { children: "associativity" }), " (left-to-right or right-to-left) determines the evaluation order."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📊 Operator Precedence Overview" }), _jsxs(_components.p, { children: ["Jab ek expression mein multiple operators hote hain, C ek specific ", _jsx(_components.strong, { children: "precedence order" }), " follow karta hai taaki determine ho sake ki pehle kaunsa operation perform hoga. Higher precedence wale operators pehle evaluate hote hain. Jab dono operators ki same precedence hoti hai, toh ", _jsx(_components.strong, { children: "associativity" }), " (left-to-right ya right-to-left) evaluation order decide karti hai."] })] }), _jsx(ComparisonTable, { title: "Operator Precedence (High to Low)", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "center" }, children: "Precedence" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Operator(s)" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Description" }), _jsx(_components.th, { style: { textAlign: "center" }, children: "Associativity" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "1 (Highest)" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "sizeof" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Size of type/variable" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Right to Left" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "2" }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "~" }), ", ", _jsx(_components.code, { children: "!" }), ", ", _jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" })] }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Unary operators" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Right to Left" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "3" }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "<<" }), ", ", _jsx(_components.code, { children: ">>" })] }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Shift operators" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Left to Right" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "4" }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "*" }), ", ", _jsx(_components.code, { children: "/" }), ", ", _jsx(_components.code, { children: "%" })] }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Multiplicative (Arithmetic)" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Left to Right" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "5" }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" })] }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Additive (Arithmetic)" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Left to Right" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "6" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "&" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Bitwise AND" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Left to Right" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "7" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "^" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Bitwise XOR" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Left to Right" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "8" }), _jsx(_components.td, { style: { textAlign: "center" }, children: _jsx(_components.code, { children: "|" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Bitwise OR" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Left to Right" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "center" }, children: "9" }), _jsxs(_components.td, { style: { textAlign: "center" }, children: [_jsx(_components.code, { children: "=" }), ", ", _jsx(_components.code, { children: "+=" }), ", ", _jsx(_components.code, { children: "-=" }), ", etc."] }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Assignment operators" }), _jsx(_components.td, { style: { textAlign: "center" }, children: "Right to Left" })] })] })] }) }), _jsx(Analogy, { children: _jsxs(_components.p, { children: ["Think of operator precedence like a ", _jsx(_components.strong, { children: "chain of command" }), " in a company. The CEO (", _jsx(_components.code, { children: "sizeof" }), ") has the highest authority and gives instructions first, then the VP (", _jsx(_components.code, { children: "*" }), ", ", _jsx(_components.code, { children: "/" }), "), then the manager (", _jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" }), "), and so on. The CEO's decision is always implemented before the VP's, and the VP's before the manager's — that's precedence. When two managers have equal rank, the one on the left acts first — that's left-to-right associativity."] }) }), _jsx(CodeBlock, { language: "c", children: `#include int main() { // Precedence example: * higher than + int result1 = 2 + 3 * 4; printf("2 + 3 * 4 = %d\\n", result1); // 14, not 20 // Parentheses override precedence int result2 = (2 + 3) * 4; printf("(2 + 3) * 4 = %d\\n", result2); // 20 // Shift vs Arithmetic int result3 = 5 << 1 + 2; // + has higher precedence than << printf("5 << 1 + 2 = %d\\n", result3); // 40 (= 5 << 3) // Bitwise vs Arithmetic int result4 = 12 & 10 + 5; // + higher than & printf("12 & 10 + 5 = %d\\n", result4); // 8 (= 12 & 15) // With parentheses to clarify intent int result5 = (12 & 10) + 5; printf("(12 & 10) + 5 = %d\\n", result5); // 13 (= 8 + 5) return 0; }` }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["An ", _jsx(_components.strong, { children: "assignment statement" }), " stores the evaluated RHS value into the LHS variable. The ", _jsx(_components.code, { children: "=" }), " operator means \"assign,\" not \"equals.\""] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Compound assignment operators" }), " (", _jsx(_components.code, { children: "+=" }), ", ", _jsx(_components.code, { children: "-=" }), ", ", _jsx(_components.code, { children: "*=" }), ", ", _jsx(_components.code, { children: "/=" }), ", ", _jsx(_components.code, { children: "%=" }), ") provide shorthand for common operations like ", _jsx(_components.code, { children: "a = a + b" }), " → ", _jsx(_components.code, { children: "a += b" }), "."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Arithmetic operators" }), " (", _jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" }), ", ", _jsx(_components.code, { children: "*" }), ", ", _jsx(_components.code, { children: "/" }), ", ", _jsx(_components.code, { children: "%" }), ") perform basic math. Integer division (", _jsx(_components.code, { children: "/" }), ") ", _jsx(_components.strong, { children: "truncates" }), " the decimal part, and modulus (", _jsx(_components.code, { children: "%" }), ") returns the remainder."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Shift operators" }), " (", _jsx(_components.code, { children: "<<" }), ", ", _jsx(_components.code, { children: ">>" }), ") work on binary representation. Left shift by ", _jsx(_components.code, { children: "n" }), " multiplies by ", _jsx(_components.code, { children: "2^n" }), "; right shift by ", _jsx(_components.code, { children: "n" }), " divides by ", _jsx(_components.code, { children: "2^n" }), " (truncated)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Bitwise operators" }), " (", _jsx(_components.code, { children: "&" }), ", ", _jsx(_components.code, { children: "|" }), ", ", _jsx(_components.code, { children: "^" }), ", ", _jsx(_components.code, { children: "~" }), ") manipulate individual bits. They are NOT the same as logical operators (", _jsx(_components.code, { children: "&&" }), ", ", _jsx(_components.code, { children: "||" }), ")."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.code, { children: "sizeof" }) }), " returns the size in bytes of a type or variable at compile time. It's essential for writing portable code."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operator precedence" }), " determines evaluation order — always use parentheses ", _jsx(_components.code, { children: "()" }), " when you're unsure about the intended grouping."] }), "\n"] }) })] })] }), "\n", _jsx(Practical, { children: _jsxs(ImportantQA, { children: [_jsxs(QAQuestion, { marks: 2, children: [_jsx(Prompt, { children: "What is the purpose of the assignment operator in C? Give a simple example." }), _jsx(Answer, { children: _jsxs(_components.p, { children: ["The ", _jsxs(_components.strong, { children: ["assignment operator (", _jsx(_components.code, { children: "=" }), ")"] }), " in C is used to store or assign a value to a variable. It takes the value on its right and puts it into the variable on its left. ", _jsx(_components.strong, { children: "Example:" }), " ", _jsx(_components.code, { children: "c int age; // Declaration age = 25; // Assignment: stores 25 in the variable 'age' " }), " The assignment operator is not the same as the equality relational operator (", _jsx(_components.code, { children: "==" }), "). The single ", _jsx(_components.code, { children: "=" }), " is for assigning, while ", _jsx(_components.code, { children: "==" }), " is used in conditions to check equality."] }) })] }), _jsxs(QAQuestion, { marks: 4, children: [_jsx(Prompt, { children: "Explain the arithmetic operators in C with the help of a sample program and its output." }), _jsx(Answer, { children: _jsxs(_components.p, { children: ["C provides several ", _jsx(_components.strong, { children: "arithmetic operators" }), " for mathematical calculations. The primary ones are: - ", _jsxs(_components.strong, { children: ["Addition (", _jsx(_components.code, { children: "+" }), ")"] }), ": Adds two operands. - ", _jsxs(_components.strong, { children: ["Subtraction (", _jsx(_components.code, { children: "-" }), ")"] }), ": Subtracts the second operand from the first. - ", _jsxs(_components.strong, { children: ["Multiplication (", _jsx(_components.code, { children: "*" }), ")"] }), ": Multiplies two operands. - ", _jsxs(_components.strong, { children: ["Division (", _jsx(_components.code, { children: "/" }), ")"] }), ": Divides the first operand by the second. The result is an integer if both operands are integers. - ", _jsxs(_components.strong, { children: ["Modulus (", _jsx(_components.code, { children: "%" }), ")"] }), ": Returns the remainder of an integer division. ", _jsx(_components.strong, { children: "Sample Program:" }), " ", _jsx(_components.code, { children: "c #include int main() { int a = 10, b = 3; printf("Addition: %d\\n", a + b); printf("Subtraction: %d\\n", a - b); printf("Multiplication: %d\\n", a * b); printf("Integer Division: %d\\n", a / b); printf("Modulus (Remainder): %d\\n", a % b); return 0; } " }), " ", _jsx(_components.strong, { children: "Expected Output:" }), " ", _jsx(_components.code, { children: " Addition: 13 Subtraction: 7 Multiplication: 30 Integer Division: 3 Modulus (Remainder): 1 " }), " When using integer division (", _jsx(_components.code, { children: "/" }), "), the fractional part is discarded. The modulus operator (", _jsx(_components.code, { children: "%" }), ") works only with integer operands."] }) })] }), _jsxs(QAQuestion, { marks: 6, children: [_jsx(Prompt, { children: "Write a C program to demonstrate the bitwise operators and shift operators, and also use the sizeof operator. Explain each part of the output." }), _jsx(Answer, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Bitwise operators" }), " work on the binary representation of numbers. ", _jsx(_components.strong, { children: "Shift operators" }), " move bits left or right. The ", _jsx(_components.strong, { children: "sizeof operator" }), " returns the size (in bytes) of a data type or variable. ", _jsx(_components.strong, { children: "Program:" }), " ", `#include int main() { unsigned int a = 12; // Binary: 0000 1100 unsigned int b = 10; // Binary: 0000 1010 int x = 5; // Bitwise operators printf("Bitwise AND (a & b): %u\\n", a & b); printf("Bitwise OR (a | b): %u\\n", a | b); printf("Bitwise XOR (a ^ b): %u\\n", a ^ b); printf("Bitwise NOT (~a): %u\\n", ~a); // Shift operators printf("Left Shift (a << 1): %u\\n", a << 1); printf("Right Shift (a >> 1): %u\\n", a >> 1); // sizeof operator printf("Size of int: %zu bytes\\n", sizeof(int)); printf("Size of variable x: %zu bytes\\n", sizeof(x)); return 0; }`, " ", _jsx(_components.strong, { children: "Output Explanation:" }), " - ", _jsxs(_components.strong, { children: ["Bitwise AND (", _jsx(_components.code, { children: "&" }), ")"] }), ": Compares each bit; result is 1 only if both bits are 1. ", _jsx(_components.code, { children: "(12 & 10)" }), " → ", _jsx(_components.code, { children: "1000" }), " (binary) → ", _jsx(_components.code, { children: "8" }), " (decimal). - ", _jsxs(_components.strong, { children: ["Bitwise OR (", _jsx(_components.code, { children: "|" }), ")"] }), ": Result is 1 if at least one bit is 1. ", _jsx(_components.code, { children: "(12 | 10)" }), " → ", _jsx(_components.code, { children: "1110" }), " → ", _jsx(_components.code, { children: "14" }), ". - ", _jsxs(_components.strong, { children: ["Bitwise XOR (", _jsx(_components.code, { children: "^" }), ")"] }), ": Result is 1 if bits are different. ", _jsx(_components.code, { children: "(12 ^ 10)" }), " → ", _jsx(_components.code, { children: "0110" }), " → ", _jsx(_components.code, { children: "6" }), ". - ", _jsxs(_components.strong, { children: ["Bitwise NOT (", _jsx(_components.code, { children: "~" }), ")"] }), ": Flips all bits. ", _jsx(_components.code, { children: "~12" }), " → Invert of ", _jsx(_components.code, { children: "0000 1100" }), " → ", _jsx(_components.code, { children: "1111 0011" }), " (in 32-bit unsigned) → ", _jsx(_components.code, { children: "4294967283" }), ". - ", _jsxs(_components.strong, { children: ["Left Shift (", _jsx(_components.code, { children: "<<" }), ")"] }), ": Shifts bits left by specified positions, filling with 0s. ", _jsx(_components.code, { children: "12 << 1" }), " → ", _jsx(_components.code, { children: "0001 1000" }), " → ", _jsx(_components.code, { children: "24" }), ". - ", _jsxs(_components.strong, { children: ["Right Shift (", _jsx(_components.code, { children: ">>" }), ")"] }), ": Shifts bits right, discarding shifted-out bits. ", _jsx(_components.code, { children: "12 >> 1" }), " → ", _jsx(_components.code, { children: "0000 0110" }), " → ", _jsx(_components.code, { children: "6" }), ". - ", _jsxs(_components.strong, { children: [_jsx(_components.code, { children: "sizeof" }), " operator"] }), ": Returns the size in bytes. On a typical 32/64-bit system, ", _jsx(_components.code, { children: "sizeof(int)" }), " is ", _jsx(_components.code, { children: "4" }), " bytes. ", _jsx(_components.code, { children: "sizeof(x)" }), " also returns ", _jsx(_components.code, { children: "4" }), " bytes. - Bitwise operators are useful for low-level programming like hardware control or optimizing performance. - Left shifting by ", _jsx(_components.code, { children: "n" }), " is equivalent to multiplying by 2ⁿ, and right shifting is equivalent to dividing by 2ⁿ (for positive integers). - ", _jsx(_components.code, { children: "sizeof" }), " is evaluated at compile time, not runtime."] }) })] })] }) }), "\n", _jsxs(Assessment, { topicId: "1.5", children: [_jsx(MCQ, { questions: [{ "id": "eeeb60a0-3732-4e82-bc9c-8141451f774b", "q": "Which operator is used to find the remainder in C?", "options": ["%", "/", "^", "*"], "answer": 0, "hint": "Consider the basic arithmetic operation for finding a remainder.", "explanation": "The modulus operator (%) returns the remainder of the division of the first operand by the second." }, { "id": "613f36ae-2ade-4b72-b33c-bf012d40b331", "q": "Which operator performs a right shift on an integer value?", "options": ["<<", ">>", ">>>", "<<<"], "answer": 1, "hint": "Think about shifting bits to the right by a specified number of positions.", "explanation": "The right shift operator (>>) shifts the bits of the left operand to the right by the number of positions specified by the right operand." }, { "id": "ec27e7c6-2409-484a-a73e-452594f0f5c3", "q": "What is the result of the expression 5 & 3 in C?", "options": ["6", "1", "1", "0"], "answer": 2, "hint": "This operator compares each bit of the first operand to the corresponding bit of the second operand. If both bits are 1, the corresponding result bit is set to 1.", "explanation": "The bitwise AND operator (&) performs a logical AND on each pair of bits." }, { "id": "816c847b-b5f5-450a-b1fb-0a14a9c14870", "q": "Which is a compound assignment operator in C?", "options": ["==", "!=", ">=", "+="], "answer": 3, "hint": "Consider the assignment operator that also performs addition.", "explanation": "The += operator adds the right operand to the left operand and assigns the result to the left operand. It is a compound assignment operator." }, { "id": "9b18aee5-e715-46f2-b049-48c20ab4f8d2", "q": "What does the sizeof operator return?", "options": ["The memory size of the operand in bytes", "The address of the operand", "The value of the operand", "The data type of the operand"], "answer": 0, "hint": "The sizeof operator returns the size, in bytes, of its operand. The result is of type size_t.", "explanation": "sizeof is a unary operator that yields the size, in bytes, of its operand (a variable or a type)." }, { "id": "e7ee5ba2-7643-41eb-9371-f4bbb4f27d0c", "q": "Which operator performs a bitwise exclusive OR?", "options": ["&", "^", "|", "~"], "answer": 1, "hint": "This operator compares the bits of two operands and sets the result bit to 1 if exactly one of the two corresponding bits is 1.", "explanation": "The bitwise XOR operator (^) performs a logical exclusive OR on each pair of bits." }, { "id": "2c89139e-e59d-4f03-9901-789c8ab927af", "q": "In the expression x = a + b * c, which operation is performed first?", "options": ["Assignment", "Addition", "Multiplication", "None, all are performed left to right"], "answer": 2, "hint": "Consider the order of operations (precedence). The assignment operator has low precedence.", "explanation": "In C, the assignment operator has lower precedence than most other operators, including arithmetic and bitwise operators, so the expression on the right is evaluated first." }, { "id": "b458176f-6ee5-4a5f-8ff7-984e87a9cd32", "q": "Which operator is the bitwise complement (NOT) operator?", "options": ["!", "^", "~", "&"], "answer": 3, "hint": "This operator is used to flip all bits (0 to 1 and 1 to 0).", "explanation": "The bitwise NOT operator (~) inverts each bit of its operand." }, { "id": "80dc46a2-6d05-45f3-ab17-be557ae7bfe0", "q": "What is the effect of left-shifting an integer by 1 bit?", "options": ["Multiplies the integer by 2", "Divides the integer by 2", "Multiplies the integer by 10", "No change"], "answer": 0, "hint": "Shifting an integer left by n bits is equivalent to multiplying by 2^n.", "explanation": "The left shift operator (<<) shifts bits to the left, filling the rightmost bits with 0. It effectively multiplies the number by 2^n." }, { "id": "4c8fba7e-c8bc-4322-859b-61fe5a6476b7", "q": "Which of the following is equivalent to x = x - y?", "options": ["x += y", "x -= y", "x *= y", "x /= y"], "answer": 1, "hint": "Consider the compound assignment operator that combines subtraction and assignment.", "explanation": "The -= operator subtracts the right operand from the left operand and assigns the result to the left operand." }], topicId: "1.5" }), _jsx(ContentAttribution, { sourceTitle: "Curriculum Reference", sourceUrl: "https://learningway.in", professor: "Faculty Review Team", model: "Curriculum AI", seoTitle: "Assignments and expressions", seoDesc: "Master Assignments and expressions with comprehensive notes, real-world examples, and practice quiz on LearningWay.", seoKeywords: "assignments and expressions, assignments and expressions notes, assignments and expressions 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."); }