Operator precedence in Kotlin - Time & Space Complexity

Time Complexity: Operator precedence

O(n)

Understanding Time Complexity

We want to see how the order of operations affects how many steps a program takes.

How does the way Kotlin decides which operation to do first change the work done?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fun calculate(values: List): Int {
    var result = 0
    for (v in values) {
        result += v * 2 + 3
    }
    return result
}

This code multiplies each number by 2, adds 3, and sums all results.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each item in the list once.
• How many times: Exactly once for each item in the input list.

How Execution Grows With Input

Each new number adds a fixed amount of work: multiply, add, then add to total.

Input Size (n)	Approx. Operations
10	About 10 times the fixed steps
100	About 100 times the fixed steps
1000	About 1000 times the fixed steps

Pattern observation: The work grows directly with the number of items.

Final Time Complexity

Time Complexity: O(n)

This means the time to finish grows in a straight line as the input list gets bigger.

Common Mistake

[X] Wrong: "Changing the order of operations inside the loop changes how many times the loop runs."

[OK] Correct: The loop runs once per item no matter the order; operator precedence only changes how each item's calculation happens, not the number of times the loop runs.

Interview Connect

Understanding how operator precedence affects calculations helps you explain how code runs step-by-step, a skill useful in many coding discussions.

Self-Check

"What if we added another loop inside the existing loop? How would the time complexity change?"

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