Operator precedence in Kotlin - Mini Project: Build & Apply

Operator precedence

📖 Scenario: Imagine you are calculating the total cost of items in a shopping cart with discounts and taxes applied. Understanding how Kotlin calculates expressions helps you get the right total.

🎯 Goal: You will write Kotlin code to calculate a total price using multiple operators and see how operator precedence affects the result.

📋 What You'll Learn

Create variables with exact values for item price, discount, and tax rate

Create a variable for the discounted price calculation

Calculate the final price using operator precedence rules

Print the final price

💡 Why This Matters

🌍 Real World

Calculating prices with discounts and taxes is common in shopping apps and billing systems.

💼 Career

Understanding operator precedence helps developers avoid bugs in financial calculations and write clear, correct code.

1

Create initial price variables

Create three variables: itemPrice with value 100, discount with value 20, and taxRate with value 0.08.

Kotlin

// Create variables itemPrice, discount, and taxRate with given values
// Your code here

Hint

Use val to create variables and assign the exact values.

2

Calculate discounted price

Create a variable discountedPrice that subtracts discount from itemPrice using the expression itemPrice - discount.

Kotlin

val itemPrice = 100
val discount = 20
val taxRate = 0.08
// Calculate discountedPrice by subtracting discount from itemPrice
// Your code here

Hint

Use subtraction operator - to find discountedPrice.

3

Calculate final price with tax

Create a variable finalPrice that calculates the total price by adding tax to discountedPrice. Use the expression discountedPrice + discountedPrice * taxRate to apply operator precedence correctly.

Kotlin

val itemPrice = 100
val discount = 20
val taxRate = 0.08
val discountedPrice = itemPrice - discount
// Calculate finalPrice by adding tax to discountedPrice
// Your code here

Hint

Remember multiplication happens before addition without parentheses.

4

Print the final price

Write a println statement to display the value of finalPrice.

Kotlin

val itemPrice = 100
val discount = 20
val taxRate = 0.08
val discountedPrice = itemPrice - discount
val finalPrice = discountedPrice + discountedPrice * taxRate
// Print the finalPrice
// Your code here

Hint

Use println(finalPrice) to show the result.

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