Preconditions (require, check, error) in Kotlin - Time & Space Complexity

Time Complexity: Preconditions (require, check, error)

O(n)

Understanding Time Complexity

We want to understand how the time cost changes when using precondition checks like require, check, and error in Kotlin.

How does adding these checks affect the program's running time as input grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fun processList(numbers: List<Int>) {
    require(numbers.isNotEmpty()) { "List cannot be empty" }
    for (number in numbers) {
        check(number > 0) { "Number must be positive" }
        println(number)
    }
    if (numbers.size > 1000) {
        error("List too large to process")
    }
}

This code checks conditions before and during processing a list of numbers, printing each number if all checks pass.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The for-loop that goes through each number in the list.
• How many times: Once for each item in the list (n times).

How Execution Grows With Input

The checks outside the loop run once, but the loop runs once per item, so the total work grows as the list gets bigger.

Input Size (n)	Approx. Operations
10	About 10 checks and prints
100	About 100 checks and prints
1000	About 1000 checks and prints

Pattern observation: The time grows directly with the number of items in the list.

Final Time Complexity

Time Complexity: O(n)

This means the time to run the code grows in a straight line with the size of the input list.

Common Mistake

[X] Wrong: "Precondition checks like require or check add a lot of extra time for every item."

[OK] Correct: These checks run once per item inside the loop, just like any other simple operation, so they add a small constant time per item, not extra loops or nested work.

Interview Connect

Understanding how precondition checks affect time helps you write safe code without worrying about slowing down your program too much as inputs grow.

Self-Check

"What if we moved the check(number > 0) outside the loop to run once for the whole list? How would the time complexity change?"

Practice

1. What is the primary purpose of the require function in Kotlin?

easy

A. To log warnings without stopping the program

B. To verify the internal state of the program

C. To stop the program immediately with an error message

D. To check if function arguments meet certain conditions

Solution

1. Step 1: Understand require usage

   require is used to check if the inputs to a function are valid before proceeding.

2. Step 2: Differentiate from other preconditions

   check is for program state, and error stops the program immediately. require is specifically for argument validation.

3. Final Answer:

   To check if function arguments meet certain conditions -> Option D

4. Quick Check:

   require = argument check [OK]

Hint: Require checks function inputs are valid before running [OK]

Common Mistakes:

• Confusing require with check for program state
• Thinking error is for argument validation
• Assuming require stops program immediately

2. Which of the following is the correct syntax to use check in Kotlin to verify a condition with a lazy message?

easy

A. check(value > 0, "Value must be positive")

B. check { value > 0, "Value must be positive" }

C. check(value > 0) { "Value must be positive" }

D. check(value > 0); "Value must be positive"

Solution

1. Step 1: Recall check function signature

   check takes a Boolean condition and a lambda returning a message string if false.

2. Step 2: Match syntax with options

   check(value > 0) { "Value must be positive" } uses check(condition) { "message" } which is correct Kotlin syntax.

3. Final Answer:

   check(value > 0) { "Value must be positive" } -> Option C

4. Quick Check:

   check syntax = condition + lambda message [OK]

Hint: Use check(condition) { "message" } syntax [OK]

Common Mistakes:

• Passing message as second argument instead of lambda
• Using comma inside lambda incorrectly
• Omitting braces for message lambda

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

fun test(x: Int) {
    require(x > 0) { "x must be positive" }
    check(x < 10) { "x must be less than 10" }
    println("x is valid: $x")
}

test(15)

medium

A. IllegalStateException: x must be less than 10

B. IllegalArgumentException: x must be positive

C. No output, program stops silently

D. x is valid: 15

Solution

1. Step 1: Evaluate require(x > 0)

   Since 15 > 0, require passes without exception.

2. Step 2: Evaluate check(x < 10)

   15 is not less than 10, so check throws IllegalStateException with message "x must be less than 10".

3. Final Answer:

   IllegalStateException: x must be less than 10 -> Option A

4. Quick Check:

   require passes, check fails with IllegalStateException [OK]

Hint: Require checks args, check checks state; exception shows which failed [OK]

Common Mistakes:

• Thinking require throws error for x=15
• Assuming println runs after failed check
• Confusing exception types thrown by require and check

4. Identify the error in this Kotlin code snippet:

fun validate(name: String) {
    require(name.isNotEmpty(), "Name cannot be empty")
    check(name.length > 3) { "Name too short" }
}

medium

A. check condition should be inside require

B. No error, code is correct

C. require should not have a message

D. Incorrect use of require with message as second argument

Solution

1. Step 1: Review require syntax

   Both require(condition, "message") (eager message) and require(condition) { "message" } (lazy message) are valid overloads.

2. Step 2: Review check syntax

   The lambda syntax for check is also valid. The code compiles and works as expected.

3. Final Answer:

   No error, code is correct -> Option B

4. Quick Check:

   Both eager and lazy messages valid [OK]

Hint: require/check support both eager message and lazy lambda [OK]

Common Mistakes:

• Thinking comma message is invalid for require
• Confusing require syntax with only lambda support
• Forgetting that multiple overloads exist

5. You want to stop your Kotlin program immediately with a custom error message if a critical condition fails.

fun criticalCheck(flag: Boolean) {
    // Your code here
}

hard

A. Use error("Critical failure") if flag is false

B. Use require(flag == false) { "Critical failure" }

C. Use check(flag == false) { "Critical failure" }

D. Use println("Critical failure") and continue

Solution

1. Step 1: Understand error function purpose

   error immediately throws an IllegalStateException with the given message and stops the program.

2. Step 2: Apply error for critical failure

   Use if (!flag) error("Critical failure") to stop execution immediately when condition fails.

3. Final Answer:

   Use error("Critical failure") if flag is false -> Option A

4. Quick Check:

   error stops program immediately with message [OK]

Hint: Use error() to stop program immediately with message [OK]

Common Mistakes:

• Using require or check which throw exceptions but may be caught
• Printing message without stopping program
• Not stopping program on critical failure