Questions: Operators and Expressions

Question 1

What does the expression `7 / 2` evaluate to in a language that uses integer division when both operands are integers?

• A. 3.5
• B. 3
• C. 4
• D. 1

Answer: (B)

When both operands are integers, integer division truncates (rounds toward zero), so `7 / 2` gives `3`, not `3.5`. The remainder is discarded, not rounded up. To get `3.5`, at least one operand must be a float: `7.0 / 2` or `7 / 2.0`. This surprises many beginners who expect division to behave like a calculator. Option C (4) represents rounding up, which is not how truncation works.

Question 2

Consider the condition: `if (x != 0 and 10 / x > 2)`. If x equals 0, what happens?

• A. A division-by-zero error occurs because both sides of `and` are always evaluated
• B. The condition evaluates safely to false because short-circuit evaluation skips the division
• C. The condition evaluates to true because 0 satisfies the `!=` check
• D. The program crashes because `and` requires both operands to be computed before combining them

Answer: (B)

This is short-circuit evaluation in action. In `A and B`, if A is false, B is never evaluated — the result must be false regardless. When x is 0, `x != 0` is false, so the `and` short-circuits and `10 / x` is never computed. This makes the pattern a standard safe-division idiom. Options A and D reflect the misconception that logical operators always evaluate both sides.

Question 3

Writing `if (x = 5)` instead of `if (x == 5)` in most C-style languages will cause an immediate syntax error that stops the program from running.

• T. True
• F. False

Answer: False

This is one of the most insidious bugs precisely because it often does NOT cause an error. In many languages, `x = 5` is a valid assignment expression that evaluates to 5 (truthy), so the condition always passes — the program runs without complaint but with wrong behavior. This makes the = vs == confusion especially dangerous. Some modern linters warn about this pattern, but the language itself may not reject it.

Question 4

The modulo operator `%` is primarily useful for checking whether a number is even or odd.

• T. True
• F. False

Answer: False

While `n % 2 == 0` is a classic even-check, calling that its primary use understates modulo's range. Modulo is also the standard tool for cycling through a fixed range (index wrapping in circular buffers), implementing clock arithmetic, determining the day of the week from a day count, and many other cyclic computations. Even/odd checking is simply the most elementary example of a broadly useful operator.

Question 5

Why does operator precedence matter in programming, and how does it relate to order of operations from math?

Model answer: Operator precedence determines which sub-expression is evaluated first when multiple operators appear in a single expression. Programming languages inherit the mathematical convention (multiplication before addition) and extend it: comparison operators bind less tightly than arithmetic, and logical operators bind least. Without precedence rules, `3 + 4 * 2` would be ambiguous. In programming, `x + 1 > 3 and y < 5` first computes `x + 1`, then compares with `>`, then applies `and`.

Precedence is not arbitrary — it follows conventions inherited from mathematics and extended consistently to new operator types. Knowing the order prevents bugs where expressions evaluate in an unexpected sequence. When in doubt, parentheses make the intended order explicit and the code more readable, which is why experienced programmers use them liberally even when not strictly required.