Operator precedence in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to calculate the correct result using operator precedence.

Kotlin

val result = 3 + 4 * [1]

Drag options to blanks, or click blank then click option'

A1

B2

C5

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Adding 3 + 4 first, then multiplying by the number.

Ignoring operator precedence and calculating left to right.

The multiplication happens before addition, so 4 * 5 = 20, then 3 + 20 = 23.

2fill in blank

medium

Complete the code to get the correct boolean result using operator precedence.

Kotlin

val isTrue = true || false && [1]

Drag options to blanks, or click blank then click option'

Afalse

Btrue

Cnull

Dtrue && false

Attempts:

3 left

💡 Hint

Common Mistakes

Evaluating || before &&.

Using an expression instead of a boolean value.

Logical AND (&&) has higher precedence than OR (||). So false && false = false, then true || false = true.

3fill in blank

hard

Fix the error in the expression by completing the code with the correct operator.

Kotlin

val value = 10 + 5 [1] 3

Drag options to blanks, or click blank then click option'

A/

B%

C-

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction (-) or division (/) which changes the result.

Using modulo (%) which is not intended here.

Multiplication (*) has higher precedence than addition (+), so 5 * 3 is calculated first, then added to 10.

4fill in blank

hard

Fill both blanks to create a map of words to their lengths only if length is greater than 3.

Kotlin

val lengths = mapOf([1] to [2]).filter { it.value > 3 }

Drag options to blanks, or click blank then click option'

A"apple"

B"banana"

C"apple".length

D"banana".length

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same word for key and length causing confusion.

Not using quotes for string keys.

The map pairs the word "apple" with the length of "apple". Then filter keeps entries with length > 3.

5fill in blank

hard

Fill all three blanks to create a filtered map with uppercase keys and values greater than 4.

Kotlin

val filtered = mapOf([1] to [2]).filter { it.value [3] 4 }

Drag options to blanks, or click blank then click option'

A"pear".uppercase()

B5

C>

D"plum".uppercase()

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase strings instead of uppercase.

Using wrong comparison operators like < or ==.

The map has key "PLUM" (uppercase) with value 5. The filter keeps entries where value > 4.

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