Operator overloading concept in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin operator overloading code?

Consider this Kotlin class that overloads the plus operator. What will be printed when the code runs?

Kotlin

data class Point(val x: Int, val y: Int) {
    operator fun plus(other: Point) = Point(x + other.x, y + other.y)
}

fun main() {
    val p1 = Point(2, 3)
    val p2 = Point(4, 5)
    val p3 = p1 + p2
    println(p3)
}

A Point(x=6, y=8)

B Point(x=8, y=10)

C Point(x=2, y=3) + Point(x=4, y=5)

D Compilation error: operator plus not defined

💡 Hint

Remember that plus adds the x and y values separately.

The plus operator adds the x and y values of two Point objects. So (2+4, 3+5) = (6, 8).

❓ Predict Output

intermediate

What does this Kotlin code print when overloading the unary minus operator?

Look at this Kotlin class that overloads the unary minus operator. What is the output?

Kotlin

data class Vector(val x: Int, val y: Int) {
    operator fun unaryMinus() = Vector(-x, -y)
}

fun main() {
    val v = Vector(7, -3)
    println(-v)
}

A Vector(x=-7, y=3)

B Vector(x=7, y=-3)

C Vector(x=-7, y=-3)

D Runtime error: operator unaryMinus not found

💡 Hint

The unary minus operator negates each coordinate.

The unary minus operator returns a new Vector with both x and y negated. So (7, -3) becomes (-7, 3).

❓ Predict Output

advanced

What is the output of this Kotlin code with operator overloading and custom class?

This Kotlin class overloads the times operator. What will be printed?

Kotlin

class Matrix(val value: Int) {
    operator fun times(other: Matrix) = Matrix(this.value * other.value)
    override fun toString() = "Matrix(value=$value)"
}

fun main() {
    val m1 = Matrix(3)
    val m2 = Matrix(4)
    val m3 = m1 * m2
    println(m3)
}

A Matrix(value=7)

B Matrix(value=12)

C Matrix(value=34)

D Compilation error: operator times not defined

💡 Hint

The times operator multiplies the values inside the matrices.

The times operator returns a new Matrix with the product of the two values: 3 * 4 = 12.

❓ Predict Output

advanced

What error does this Kotlin code raise when overloading the increment operator?

Examine this Kotlin class that tries to overload the increment operator ++. What error occurs when compiling?

Kotlin

class Counter(var count: Int) {
    operator fun inc() {
        count += 1
    }
}

fun main() {
    val c = Counter(5)
    c++
    println(c.count)
}

A Runtime error: inc operator not supported

B 6

C 5

D Compilation error: inc operator must return a value

💡 Hint

The inc operator must return the updated object.

The inc operator function must return the incremented object. Here it returns Unit (nothing), causing a compilation error.

🧠 Conceptual

expert

Which Kotlin operator overloading function signature is correct for the 'contains' operator?

In Kotlin, to overload the in operator (used like item in collection), which function signature is correct?

A operator fun in(item: T): Boolean

B operator fun has(item: T): Boolean

C operator fun contains(item: T): Boolean

D operator fun contains(): Boolean

💡 Hint

The function name must be contains and take one parameter.

The in operator calls the contains function with the item as parameter, returning a Boolean.

Practice

1. What does operator overloading in Kotlin allow you to do?

easy

A. Disable operators for certain classes

B. Change the meaning of built-in types like Int or String

C. Create new operators not available in Kotlin

D. Use standard operators like + or * with your own classes

Solution

1. Step 1: Understand operator overloading purpose

   Operator overloading lets you define how operators like + work with your own classes.

2. Step 2: Check options meaning

   Only Use standard operators like + or * with your own classes correctly states this ability. Options A, B, and C are incorrect because Kotlin does not let you change built-in types, create new operators, or disable operators this way.

3. Final Answer:

   Use standard operators like + or * with your own classes -> Option D

4. Quick Check:

   Operator overloading = Use operators with custom classes [OK]

Hint: Operator overloading means using +, * with your own classes [OK]

Common Mistakes:

• Thinking you can create new operators
• Believing it changes built-in types
• Confusing disabling operators with overloading

2. Which of the following is the correct syntax to overload the plus operator in a Kotlin class?

easy

A. operator fun plus(other: MyClass): MyClass { ... }

B. fun plus(other: MyClass): MyClass { ... }

C. override fun plus(other: MyClass): MyClass { ... }

D. fun operator plus(other: MyClass): MyClass { ... }

Solution

1. Step 1: Recall operator function syntax

   In Kotlin, to overload an operator, the function must be marked with the keyword operator before the function declaration.

2. Step 2: Analyze options

   operator fun plus(other: MyClass): MyClass { ... } correctly uses operator fun plus(...). fun plus(other: MyClass): MyClass { ... } misses the operator keyword, C wrongly uses override, and D has incorrect keyword order.

3. Final Answer:

   operator fun plus(other: MyClass): MyClass { ... } -> Option A

4. Quick Check:

   Operator keyword before function = Correct syntax [OK]

Hint: Always put 'operator' before function to overload operators [OK]

Common Mistakes:

• Omitting the 'operator' keyword
• Using 'override' instead of 'operator'
• Placing 'operator' after 'fun'

3. What will be the output of this Kotlin code?

data class Point(val x: Int, val y: Int) {
    operator fun plus(other: Point) = Point(x + other.x, y + other.y)
}

fun main() {
    val p1 = Point(1, 2)
    val p2 = Point(3, 4)
    val p3 = p1 + p2
    println(p3)
}

medium

A. Point(x=4, y=6)

B. p1 + p2

C. Compilation error

D. Point(4, 6)

Solution

1. Step 1: Understand operator plus function

   The plus operator adds the x and y values of two Point objects and returns a new Point with summed coordinates.

2. Step 2: Calculate the result of p1 + p2

   p1 has (1, 2), p2 has (3, 4). Adding gives (4, 6). Printing p3 calls data class's toString(), which outputs 'Point(x=4, y=6)'.

3. Final Answer:

   Point(x=4, y=6) -> Option A

4. Quick Check:

   p1 + p2 = Point(x=4, y=6) [OK]

Hint: Data class toString shows property names; sum coordinates [OK]

Common Mistakes:

• Expecting just coordinates without property names
• Thinking '+' prints expression instead of result
• Assuming compilation error without operator keyword

4. Identify the error in this Kotlin code that tries to overload the minus operator:

class Counter(var count: Int) {
    fun minus(other: Counter): Counter {
        return Counter(count - other.count)
    }
}

medium

A. Wrong return type; should be Int instead of Counter

B. Missing 'operator' keyword before the minus function

C. Function name should be 'operatorMinus' instead of 'minus'

D. Cannot overload minus operator for classes

Solution

1. Step 1: Check operator overloading syntax

   To overload an operator in Kotlin, the function must have the 'operator' keyword before its declaration.

2. Step 2: Analyze the code

   The minus function lacks the 'operator' keyword, so Kotlin won't treat it as operator overloading, causing errors when using '-'.

3. Final Answer:

   Missing 'operator' keyword before the minus function -> Option B

4. Quick Check:

   Operator functions need 'operator' keyword [OK]

Hint: Operator functions must start with 'operator' keyword [OK]

Common Mistakes:

• Forgetting the 'operator' keyword
• Changing function name incorrectly
• Assuming operator overloading is not allowed

5. Given this Kotlin class:

class Vector(val x: Int, val y: Int) {
    operator fun plus(other: Vector) = Vector(x + other.x, y + other.y)
    operator fun times(scalar: Int) = Vector(x * scalar, y * scalar)
}

What is the result of this expression?

val v1 = Vector(2, 3)
val v2 = Vector(1, 1)
val result = (v1 + v2) * 2
println("(${result.x}, ${result.y})")

hard

A. (3, 4)

B. (4, 6)

C. (6, 8)

D. Compilation error due to operator precedence

Solution

1. Step 1: Evaluate v1 + v2

   v1 is (2,3), v2 is (1,1). Adding gives Vector(3,4).

2. Step 2: Multiply the result by 2

   Vector(3,4) times 2 gives Vector(6,8).

3. Step 3: Print the result

   Printing prints (6, 8) as expected.

4. Final Answer:

   (6, 8) -> Option C

5. Quick Check:

   (v1 + v2) * 2 = (6, 8) [OK]

Hint: Evaluate plus first, then times; operator overloading respects precedence [OK]

Common Mistakes:

• Multiplying v2 by 2 instead of the sum
• Ignoring operator precedence
• Expecting compilation error