When with ranges and types in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if number is in the range 1 to 10 using when.

Kotlin

val number = 5
val result = when (number) {
    in [1] -> "Number is between 1 and 10"
    else -> "Number is out of range"
}

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

A0..9

B1 until 10

C10..1

D1..10

Attempts:

3 left

💡 Hint

Common Mistakes

Using '1 until 10' excludes 10, so it won't match number 10.

Using reversed ranges like '10..1' does not work as expected.

The range 1..10 includes numbers from 1 to 10 inclusive, which matches the condition.

2fill in blank

medium

Complete the code to check if the input is a String using when.

Kotlin

fun checkType(input: Any) = when (input) {
    is [1] -> "Input is a String"
    else -> "Input is not a String"
}

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

ADouble

BInt

CString

DBoolean

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase type names like 'string' instead of 'String'.

Checking for wrong types like Int when expecting String.

The 'is' keyword checks the type of the input. We want to check if it is a String.

3fill in blank

hard

Fix the error in the when expression to correctly check if number is in 1..5 or 6..10.

Kotlin

val number = 7
val result = when (number) {
    [1] -> "Between 1 and 5"
    in 6..10 -> "Between 6 and 10"
    else -> "Out of range"
}

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

Anumber in 1..5

Bin 1..5

C1..5

Din 1 until 5

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting 'in' keyword before the range.

Using 'number in 1..5' inside when case which is not valid syntax.

The 'in' keyword is needed before the range to check if number is inside it.

4fill in blank

hard

Fill both blanks to check if input is Int in 1..10 or String of length > 5.

Kotlin

fun describe(input: Any) = when (input) {
    is [1] -> if (input in 1..10) "Int in range" else "Int out of range"
    is [2] -> if (input.length > 5) "Long String" else "Short String"
    else -> "Unknown"
}

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

AInt

BString

CDouble

DBoolean

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up types or using wrong type names.

Forgetting to use 'is' keyword before type.

We check if input is Int or String using 'is' keyword and then apply conditions.

5fill in blank

hard

Fill all three blanks to create a when expression that returns different messages for Int ranges and String lengths.

Kotlin

fun analyze(input: Any) = when (input) {
    is [1] -> when {
        input [2] 1..5 -> "Small number"
        input [3] 6..10 -> "Medium number"
        else -> "Large number"
    }
    is String -> "String of length ${input.length}"
    else -> "Unknown type"
}

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

AInt

Bin

C!in

DDouble

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong type names or forgetting 'is'.

Confusing 'in' and '!in' operators.

We check if input is Int, then use 'in' and '!in' to check ranges inside nested when.

Practice

1. What does the when expression in Kotlin do when used with ranges like in 1..5?

easy

A. It throws an error if the value is outside the range.

B. It creates a new range from 1 to 5.

C. It assigns the value to the range variable.

D. It checks if the value falls within the specified range.

Solution

1. Step 1: Understand the when with range syntax

   The syntax in 1..5 inside when checks if the value is between 1 and 5 inclusive.

2. Step 2: Interpret the check

   If the value is inside the range, the corresponding branch executes; otherwise, it moves to the next case.

3. Final Answer:

   It checks if the value falls within the specified range. -> Option D

4. Quick Check:

   when with in checks range membership [OK]

Hint: Remember: in means inside the range [OK]

Common Mistakes:

• Thinking in creates a range instead of checking membership
• Confusing in with assignment
• Assuming it throws errors for out-of-range values

2. Which of the following is the correct syntax to check if a variable x is NOT in the range 10 to 20 using when in Kotlin?

easy

A. when(x) { !in 10..20 -> "Outside" }

B. when(x) { not in 10..20 -> "Outside" }

C. when(x) { x !in 10..20 -> "Outside" }

D. when(x) { outside 10..20 -> "Outside" }

Solution

1. Step 1: Recall the correct negation syntax in when

   In Kotlin, !in is used to check if a value is NOT in a range.

2. Step 2: Match the syntax with options

   when(x) { !in 10..20 -> "Outside" } uses !in 10..20 correctly inside when. Other options use invalid keywords or syntax.

3. Final Answer:

   when(x) { !in 10..20 -> "Outside" } -> Option A

4. Quick Check:

   Use !in to check exclusion from range [OK]

Hint: Use !in to say NOT in range [OK]

Common Mistakes:

• Using 'not in' instead of '!in'
• Writing variable name inside when case
• Using undefined keywords like 'outside'

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

val x: Any = 42
val result = when (x) {
  is Int -> "Integer"
  in 1..10 -> "Small number"
  else -> "Unknown"
}
println(result)

medium

A. Small number

B. Unknown

C. Integer

D. Compilation error

Solution

1. Step 1: Check the type of x

   Variable x is of type Any but holds the value 42, which is an Int.

2. Step 2: Evaluate when branches in order

   The first branch checks is Int, which is true, so it returns "Integer". The second branch is not checked because the first matched.

3. Final Answer:

   Integer -> Option C

4. Quick Check:

   when matches first true branch [OK]

Hint: Type checks with is come before range checks [OK]

Common Mistakes:

• Assuming range check runs before type check
• Confusing value 42 as outside 1..10
• Thinking when checks all branches

4. Identify the error in this Kotlin when expression:

val y: Any = "Hello"
val output = when (y) {
  in 1..5 -> "Number"
  is String -> "Text"
  else -> "Other"
}
println(output)

medium

A. Cannot use in with Any type without casting

B. The is String check should come before the range check

C. Missing break statements in when

D. No error, code runs fine

Solution

1. Step 1: Analyze the in 1..5 check on Any

   The variable y is of type Any. The in operator with ranges requires a comparable type like Int. Using in 1..5 on Any causes a type mismatch error.

2. Step 2: Check order of branches and syntax

   The is String check is valid but unreachable if the first branch errors. Also, when in Kotlin does not require break.

3. Final Answer:

   Cannot use in with Any type without casting -> Option A

4. Quick Check:

   Range checks need compatible types [OK]

Hint: Check variable type before using in with ranges [OK]

Common Mistakes:

• Ignoring type mismatch for in operator
• Thinking when needs break
• Assuming order of branches causes error

5. You want to write a Kotlin when expression that returns:
- "Small Int" if the value is an Int between 1 and 10 inclusive,
- "Large Int" if the value is an Int greater than 10,
- "String" if the value is a String,
- "Other" for anything else.

Which of the following when expressions correctly implements this?

hard

A. when (v) {
in 1..10 -> "Small Int"
is Int -> "Large Int"
is String -> "String"
else -> "Other"
}

B. when (v) {
is Int -> if (v in 1..10) "Small Int" else "Large Int"
is String -> "String"
else -> "Other"
}

C. when (v) {
is Int in 1..10 -> "Small Int"
is Int -> "Large Int"
is String -> "String"
else -> "Other"
}

D. when (v) {
is Int && v in 1..10 -> "Small Int"
is Int -> "Large Int"
is String -> "String"
else -> "Other"
}

Solution

1. Step 1: Understand the conditions needed

   We need to check if v is an Int and then check its value range for "Small Int" or "Large Int". Also check if v is a String.

2. Step 2: Analyze each option's correctness

   when (v) { in 1..10 -> "Small Int" is Int -> "Large Int" is String -> "String" else -> "Other" } incorrectly uses in 1..10 without checking type first, causing errors if v is not Int. when (v) { is Int in 1..10 -> "Small Int" is Int -> "Large Int" is String -> "String" else -> "Other" } uses invalid syntax is Int in 1..10. when (v) { is Int && v in 1..10 -> "Small Int" is Int -> "Large Int" is String -> "String" else -> "Other" } uses invalid syntax is Int && v in 1..10 inside when. when (v) { is Int -> if (v in 1..10) "Small Int" else "Large Int" is String -> "String" else -> "Other" } correctly checks type first, then uses an if inside the branch to distinguish ranges.

3. Final Answer:

   Option B correctly implements the logic. -> Option B

4. Quick Check:

   Use nested if inside when for complex conditions [OK]

Hint: Check type first, then range inside branch with if [OK]

Common Mistakes:

• Using invalid syntax combining is and in
• Not checking type before range
• Trying to use logical operators directly in when cases