Comparison operators in Kotlin - Time & Space Complexity

Time Complexity: Comparison operators

O(n)

Understanding Time Complexity

We want to understand how fast comparison operators run in Kotlin.

How does the time to compare values change as the input size grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fun isGreater(a: Int, b: Int): Boolean {
    return a > b
}

fun compareArrays(arr1: IntArray, arr2: IntArray): Boolean {
    for (i in arr1.indices) {
        if (arr1[i] != arr2[i]) return false
    }
    return true
}
    

This code compares two integers and also compares two arrays element by element.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Comparing two integers or array elements.
• How many times: For arrays, the comparison happens once per element, so as many times as the array length.

How Execution Grows With Input

Comparing two single numbers takes the same time no matter what.

Comparing two arrays takes longer as the arrays get bigger, because each element is checked.

Input Size (n)	Approx. Operations
10	10 comparisons
100	100 comparisons
1000	1000 comparisons

Pattern observation: The number of comparisons grows directly with the size of the arrays.

Final Time Complexity

Time Complexity: O(n)

This means the time to compare two arrays grows in a straight line with the number of elements.

Common Mistake

[X] Wrong: "Comparing two arrays always takes the same time regardless of size."

[OK] Correct: Actually, the program checks each element one by one, so bigger arrays take more time.

Interview Connect

Understanding how comparison scales helps you explain efficiency clearly and shows you know what happens behind simple operations.

Self-Check

"What if we compare arrays but stop after finding the first difference? How would the time complexity change?"