Preconditions (require, check, error) in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check that the age is positive using require.

Kotlin

fun setAge(age: Int) {
    [1](age > 0) { "Age must be positive" }
    println("Age set to $age")
}

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

Aassert

Bcheck

Cerror

Drequire

Attempts:

3 left

💡 Hint

Common Mistakes

Using check instead of require, which is meant for state checks.

Using error which always throws an exception without condition.

The require function is used to check preconditions on function arguments. Here, it ensures age is positive.

2fill in blank

medium

Complete the code to verify that the user is logged in using check.

Kotlin

fun accessDashboard(loggedIn: Boolean) {
    [1](loggedIn) { "User must be logged in" }
    println("Access granted")
}

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

Arequire

Bcheck

Cerror

Dassert

Attempts:

3 left

💡 Hint

Common Mistakes

Using require which is for argument checks, not state.

Using error which throws unconditionally.

The check function is used to verify the state of the program. Here, it ensures the user is logged in before accessing the dashboard.

3fill in blank

hard

Fix the error in the code to throw an exception with a message if the list is empty.

Kotlin

fun processList(items: List<String>) {
    if (items.isEmpty()) [1]("List cannot be empty")
    println("Processing list")
}

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

Arequire

Bcheck

Cerror

Dassert

Attempts:

3 left

💡 Hint

Common Mistakes

Using require or check without a condition.

Not throwing any exception when the list is empty.

The error function throws an IllegalStateException with the given message unconditionally. It is used here to stop processing if the list is empty.

4fill in blank

hard

Fill both blanks to create a map of word lengths for words longer than 3 characters.

Kotlin

val words = listOf("apple", "bat", "carrot", "dog")
val lengths = words.associateWith { it.[1] }
    .filter { it.key.length [2] 3 }
println(lengths)

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

Alength

B>

C<

Dcount

Attempts:

3 left

💡 Hint

Common Mistakes

Using count instead of length for string length.

Using '<' instead of '>' in the filter condition.

The length property gives the length of the string. The filter keeps words with length greater than 3.

5fill in blank

hard

Fill all three blanks to create a map of uppercase words to their lengths for words longer than 3 characters.

Kotlin

val words = listOf("apple", "bat", "carrot", "dog")
val result = words.filter { it.length [1] 3 }
    .associateBy({ it.[2]() }, { it.[3] })
println(result)

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

A>

Buppercase

Clength

DtoUpperCase

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'uppercase' property which does not exist in Kotlin.

Using 'uppercase()' instead of 'toUpperCase()' in older Kotlin versions.

Using '<' instead of '>' in the filter.

The filter keeps words longer than 3 characters using '>'. The toUpperCase() function converts words to uppercase keys. The length property gives the value.

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