Operator precedence in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is operator precedence in Kotlin?

Operator precedence determines the order in which parts of an expression are calculated. Operators with higher precedence run before those with lower precedence.

beginner

Which operator has higher precedence: * (multiplication) or + (addition)?

The multiplication operator * has higher precedence than the addition operator +. So multiplication happens before addition.

beginner

How does Kotlin evaluate the expression 3 + 4 * 2?

Kotlin first multiplies 4 by 2 (because * has higher precedence), then adds 3. So the result is 3 + 8 = 11.

beginner

What role do parentheses ( ) play in operator precedence?

Parentheses change the order of operations by forcing the expression inside them to be calculated first, regardless of operator precedence.

intermediate

In Kotlin, which has higher precedence: == (equality) or + (addition)?

The addition operator + has higher precedence than the equality operator ==. So addition happens before checking equality.

In Kotlin, which operator is evaluated first in the expression 5 + 3 * 2?

A Both at the same time

B Multiplication (*)

C Addition (+)

D Depends on variable types

Multiplication (*) has higher precedence than addition (+), so it is evaluated first.

What does parentheses do in the expression (5 + 3) * 2?

A They change the operators

B They make multiplication happen before addition

C They have no effect

D They make addition happen before multiplication

Parentheses force the addition inside them to happen first, before multiplication.

Which operator has the lowest precedence in Kotlin?

A Multiplication (*)

B Addition (+)

C Assignment (=)

D Equality (==)

Assignment (=) has the lowest precedence among these operators.

In the expression 4 + 5 == 9, what happens first?

A Addition (4 + 5)

B Equality check (== 9)

C Both at the same time

D Depends on compiler

Addition has higher precedence than equality, so 4 + 5 is calculated first.

Which of these operators has higher precedence in Kotlin?

A Equality (==)

B Logical AND (&&)

C Logical OR (||)

D Assignment (=)

Equality (==) has higher precedence than Logical AND (&&), Logical OR (||), and Assignment (=).

Explain operator precedence and how it affects the calculation of expressions in Kotlin.

Think about which parts of an expression Kotlin calculates first and why.

Describe how parentheses can change the result of an expression with mixed operators in Kotlin.

Consider the expression 3 + 4 * 2 versus (3 + 4) * 2.

Practice

1. In Kotlin, which operator has the highest precedence in the expression 3 + 4 * 2?

easy

A. Multiplication (*)

B. Addition (+)

C. Subtraction (-)

D. Division (/)

Solution

1. Step 1: Identify operators in the expression

   The expression has addition (+) and multiplication (*).

2. Step 2: Recall operator precedence rules

   Multiplication (*) has higher precedence than addition (+), so it runs first.

3. Final Answer:

   Multiplication (*) -> Option A

4. Quick Check:

   Multiplication before addition = Multiplication (*) [OK]

Hint: Multiply and divide before adding or subtracting [OK]

Common Mistakes:

• Thinking addition runs before multiplication
• Ignoring operator precedence
• Assuming left to right always applies

2. Which of the following Kotlin expressions correctly uses parentheses to change the order of operations in 3 + 4 * 2 so that addition happens first?

easy

A. 3 + (4 * 2)

B. (3 + 4) * 2

C. 3 + 4 * 2

D. 3 * (4 + 2)

Solution

1. Step 1: Understand default precedence

   Without parentheses, multiplication runs before addition.

2. Step 2: Check which option forces addition first

   (3 + 4) * 2 uses parentheses around (3 + 4), so addition happens before multiplication.

3. Final Answer:

   (3 + 4) * 2 -> Option B

4. Quick Check:

   Parentheses change order = (3 + 4) * 2 [OK]

Hint: Use parentheses to force addition before multiplication [OK]

Common Mistakes:

• Ignoring parentheses effect
• Choosing expression without parentheses
• Assuming left to right overrides precedence

3. What is the output of this Kotlin code?

val result = 10 - 4 + 2 * 3
println(result)

medium

A. 12

B. 18

C. 14

D. 4

Solution

1. Step 1: Apply operator precedence

   Multiplication (*) runs first: 2 * 3 = 6.

2. Step 2: Evaluate remaining expression left to right

   10 - 4 + 6 = 6 + 6 = 12.

3. Final Answer:

   12 -> Option A

4. Quick Check:

   Multiplication before addition/subtraction = 12 [OK]

Hint: Multiply before adding or subtracting [OK]

Common Mistakes:

• Adding before multiplying
• Calculating left to right ignoring precedence
• Miscomputing subtraction and addition order

4. Find the error in this Kotlin expression:

val x = 5 + 3 * 2 && true

What is the problem?

medium

A. Logical AND (&&) has higher precedence than multiplication

B. Missing semicolon at the end

C. Multiplication operator is invalid here

D. Cannot mix arithmetic and boolean operators without parentheses

Solution

1. Step 1: Identify mixed types in expression

   The expression mixes arithmetic (5 + 3 * 2) and boolean (&& true) without separation.

2. Step 2: Understand Kotlin type rules

   You cannot combine Int and Boolean directly without explicit logic or parentheses.

3. Final Answer:

   Cannot mix arithmetic and boolean operators without parentheses -> Option D

4. Quick Check:

   Mixing Int and Boolean needs care [OK]

Hint: Don't mix numbers and booleans without clear separation [OK]

Common Mistakes:

• Thinking semicolon is missing
• Assuming && works with numbers
• Ignoring type mismatch errors

5. Given the Kotlin expression:

val result = true || false && false || true && false

What is the value of result considering operator precedence?

hard

A. false

B. Syntax error

C. true

D. null

Solution

1. Step 1: Recall logical operator precedence

   Logical AND (&&) has higher precedence than OR (||), so evaluate && first.

2. Step 2: Evaluate all AND operations

   false && false = false, true && false = false.

3. Step 3: Replace and evaluate OR operations left to right

   true || false || false = true || false = true.

4. Final Answer:

   true -> Option C

5. Quick Check:

   AND before OR, final result true [OK]

Hint: Evaluate && before || in logical expressions [OK]

Common Mistakes:

• Evaluating OR before AND
• Confusing operator precedence
• Assuming expression returns null or error