Conditionals and Loops in Kotlin

Until now your programs have been like a one-way road: every statement runs, in order, exactly once. Real programs need to decide ("if the user is under 18, show this message") and to repeat ("do this for every student in the class"). Those two powers, conditionals and loops, are what turn a list of instructions into a program that can handle many situations.

Think of a danfo conductor collecting fares. For each passenger he decides: is this a child? a student? an adult? That is a conditional. Then he does the same routine for every passenger on the bus until the bus is empty. That is a loop. By the end of this lesson you will be able to write both, and you will practise on a full set of problems.

By the end of this lesson you will be able to:

• Make decisions with if, else if and else.
• Use if as an expression that produces a value.
• Choose between many options with when, including ranges and multiple values.
• Create ranges with .., until, downTo and step.
• Repeat work with for, while, do-while and repeat.
• Control loops with break, continue and labels.
• Combine conditions with &&, || and !.
• Solve the full Practice: Kotlin Basics style problem set with worked solutions.

How this fits the bigger picture: This lesson covers the Write conditionals in Kotlin codelab and the full practice set that follows it in Unit 2, Pathway 1 of Android Basics with Compose. In lesson 17 you will use when to choose which dice image to show, and in lesson 21 you will turn a list into screen items. Both rely on what you learn here.

1. Boolean values and comparisons (lesson 07)

A Boolean is true or false. Comparison operators (==, !=, <, >, <=, >=) produce Booleans, and &&, || and ! combine them. Every decision in this lesson is based on a Boolean.

2. Functions (lesson 08)

We write most examples as small functions that return a value. If fun fareFor(age: Int): Int looks unfamiliar, revisit lesson 08.

3. Blocks and braces

A block is a group of statements inside { }. A variable created in a block lives only inside it (scope, lesson 08).

4. Remainder operator

n % 2 == 0 is true when n is even. We use % often in this lesson. If it is unfamiliar, see lesson 07.

The decision picture

              +-----------------+
              |  age >= 18 ?    |
              +--------+--------+
                 yes   |   no
          +------------+-----------+
          v                        v
   "You may vote"          "Come back later"
          \                        /
           +----------+-----------+
                      v
            program carries on

An if checks a Boolean condition. If it is true, one block runs. If not, Kotlin skips it (or runs the else block). After that, the program carries on.

The loop picture

        +--------------------+
   +--->| is there more work?|--- no ---> carry on after the loop
   |    +---------+----------+
   |          yes |
   |              v
   |      do the loop body
   |              |
   +--------------+

A loop asks "is there more work?" before each pass. As long as the answer is yes, the body runs again. A common bug is a loop whose answer is always yes, which never ends. We will see how to avoid that.

Choosing the right tool

Example 1: A simple if

fun main() {
 val temperature = 33
 if (temperature > 30) {
 println("It is hot. Drink water.")
 }
 println("Done checking.")
}

It is hot. Drink water.
Done checking.

The condition goes inside parentheses, and must be a Boolean. Kotlin (unlike some languages) does not accept if (1) or if (name).

Example 2: if with else

fun main() {
 val age = 16
 if (age >= 18) {
 println("You can vote.")
 } else {
 println("You are too young to vote.")
 }
}

You are too young to vote.

Example 3: Several branches with else if

Kotlin checks conditions from top to bottom and runs the first block whose condition is true, then skips the rest.

fun main() {
 val score = 67
 if (score >= 70) {
 println("Grade A")
 } else if (score >= 60) {
 println("Grade B")
 } else if (score >= 50) {
 println("Grade C")
 } else {
 println("Grade F")
 }
}

Grade B

67 is not at least 70, so the first block is skipped. It is at least 60, so "Grade B" prints and the remaining branches are ignored. Order matters. If you tested score >= 50 first, every score from 50 upwards would get Grade C.

Example 4: Combining conditions

fun main() {
 val age = 15
 val hasTicket = true
 val isMember = false
 if (age >= 12 && hasTicket) {
 println("Welcome in.")
 }
 if (isMember || age < 10) {
 println("Free snack.")
 } else {
 println("No free snack today.")
 }
 if (!hasTicket) {
 println("Please buy a ticket.")
 }
}

Welcome in.
No free snack today.

The first condition needs both parts true (&&). The second needs at least one (||). The third flips the Boolean (!). && and || are short-circuit: if the left side already settles the answer, Kotlin does not look at the right side.

Example 5: if as an expression

In Kotlin, if ... else can produce a value. This is a favourite feature because it removes a lot of clutter:

fun main() {
 val a = 12
 val b = 30
 val larger = if (a > b) a else b
 println("Larger: $larger")
 val label = if (a % 2 == 0) "even" else "odd"
 println("$a is $label")
 println("Pass? ${if (a >= 50) "yes" else "no"}")
}

Larger: 30
12 is even
Pass? no

Rules: when if is used as an expression, an else is required (otherwise there would be no value in the "false" case). The last expression in each block is the value of that branch. Because of this, Kotlin has no ? : ternary operator. if already does the job.

A function can return an if directly:

fun maxOf(a: Int, b: Int): Int = if (a > b) a else b

(The standard library already has a function called maxOf; defining your own in a file of your own is fine for learning, but you may see a name clash warning in a bigger project.)

When you compare one value against many possibilities, a long else if chain gets tiring. Kotlin's when is a cleaner tool, like a sorting machine with labelled chutes.

Example 6: when with a subject

fun dayName(number: Int): String {
 return when (number) {
 1 -> "Monday"
 2 -> "Tuesday"
 3 -> "Wednesday"
 4 -> "Thursday"
 5 -> "Friday"
 6, 7 -> "Weekend"
 else -> "Not a valid day"
 }
}
fun main() {
 println(dayName(3))
 println(dayName(7))
 println(dayName(9))
}

Wednesday
Weekend
Not a valid day

Each line has a condition, an arrow -> and a result. Kotlin checks from the top and stops at the first match. 6, 7 -> groups several values on one line. The else branch catches everything else. When when is used as an expression (as here, because we return it), else is required (unless the subject is an enum or sealed type, which you will meet later).

Example 7: when with ranges

fun fareFor(age: Int): Int = when (age) {
 in 0..5 -> 0
 in 6..17 -> 100
 in 18..59 -> 200
 in 60..130 -> 50
 else -> -1 // -1 means "invalid age"
}
fun main() {
 println(fareFor(4))
 println(fareFor(10))
 println(fareFor(30))
 println(fareFor(65))
 println(fareFor(-3))
}

0
100
200
50
-1

in 6..17 means "is the value from 6 up to and including 17?". We will study ranges properly in a moment.

Example 8: when without a subject

If you leave out the subject, each branch is a full Boolean condition. This replaces an else if chain neatly:

fun describeTemperature(c: Int): String = when {
 c <= 0 -> "freezing"
 c < 15 -> "cold"
 c < 30 -> "pleasant"
 else -> "hot"
}
fun main() {
 println(describeTemperature(-3))
 println(describeTemperature(12))
 println(describeTemperature(22))
 println(describeTemperature(35))
}

freezing
cold
pleasant
hot

Example 9: when with types (is)

when can also test what kind of value something is. This is a preview of ideas used later with sealed classes (lesson 29). Any means "a value of any type".

fun describe(x: Any): String = when (x) {
 is Int -> "Int: $x"
 is String -> "String of length ${x.length}"
 else -> "Something else"
}
fun main() {
 println(describe(42))
 println(describe("Kotlin"))
 println(describe(3.5))
}

Int: 42
String of length 6
Something else

Notice x.length works inside the is String branch. Kotlin knows x is a String there. This feature is called a smart cast, and you will see more of it in lesson 10.

A range is a sequence of values with a start and an end. Ranges power both when conditions and for loops.

fun main() {
 val age = 15
 println(age in 13..19) // is age inside the range?
 println(age !in 13..19) // is it outside?
 println(10 in 1 until 10) // end excluded, so false
}

true
false
false

Note 10..1 is an empty range because it counts up from 10 and never reaches 1. To count down, you must say 10 downTo 1.

The for loop

A for loop takes each value of a range (or collection) in turn:

fun main() {
 for (i in 1..5) {
 println("Round $i")
 }
}

Round 1
Round 2
Round 3
Round 4
Round 5

i is the loop variable. Kotlin creates it for you, and it takes the next value each time round. You do not write val, and you cannot reassign it inside the loop.

More shapes:

fun main() {
 for (i in 1 until 4) print("$i ") // 1 2 3
 println()
 for (i in 10 downTo 1 step 3) print("$i ") // 10 7 4 1
 println()
 for (c in 'a'..'e') print("$c ") // a b c d e
 println()
 for (letter in "Kota") print("$letter-") // a string is a sequence of characters
 println()
}

1 2 3
10 7 4 1
a b c d e
K-o-t-a-

print keeps everything on one line, and each println() ends the line. (Lines may show a trailing space.) Lesson 14 shows for over lists, sets and maps.

Counting with a running total

fun main() {
 var total = 0
 for (n in 1..100) {
 total += n
 }
 println("Sum of 1 to 100 = $total")
}

Sum of 1 to 100 = 5050

The variable total must be a var, since it changes in every round. This is the standard pattern: a var outside the loop, updated inside.

The while loop

Use while when you do not know in advance how many rounds are needed. It keeps going as long as its condition is true.

fun main() {
 var saved = 0
 var weeks = 0
 while (saved < 15000) {
 saved += 2000
 weeks++
 }
 println("It takes $weeks weeks to save at least ₦15000. Saved: ₦$saved")
}

Working: after 7 weeks the total is 14000 (still under 15000), so the loop runs once more, giving 16000 after 8 weeks.

It takes 8 weeks to save at least ₦15000. Saved: ₦16000

Danger: if nothing inside a while ever makes the condition false, the loop never ends and the program hangs. Always ask: what changes each round so that the loop eventually stops? Here it is saved.

The do-while loop

do-while runs the body first and checks the condition afterwards, so the body always runs at least once:

fun main() {
 var n = 10
 do {
 println("n is $n")
 n++
 } while (n < 5)
 println("Finished with n = $n")
}

n is 10
Finished with n = 11

A plain while (n < 5) would have printed nothing, because 10 is not less than 5. Use do-while for "try at least once" tasks such as showing a menu and asking again.

repeat

When you simply want something done n times, repeat is the shortest form. Inside, it is the round number, starting at 0:

fun main() {
 repeat(3) {
 println("Hip hip hooray! (round ${it + 1})")
 }
}

Hip hip hooray! (round 1)
Hip hip hooray! (round 2)
Hip hip hooray! (round 3)

(repeat takes a lambda, which is the { } block. Lesson 12 explains lambdas and it fully.)

Nested loops

A loop inside a loop runs the inner one fully for each round of the outer one:

fun main() {
 for (row in 1..4) {
 for (col in 1..row) {
 print("*")
 }
 println()
 }
}

*
**

---

---

Row 1 prints one star, row 2 prints two, and so on, because the inner range 1..row grows with the row.

break and continue

• break leaves the loop completely.
• continue skips the rest of this round and moves to the next.

fun main() {
 for (i in 1..9) {
 if (i % 2 == 0) continue // skip even numbers
 if (i > 7) break // stop after 7
 print("$i ")
 }
 println()
}

Round by round: 1 prints, 2 is skipped, 3 prints, 4 skipped, 5 prints, 6 skipped, 7 prints, 8 is skipped (continue happens first), 9 triggers break.

1 3 5 7

Labels: breaking out of nested loops

A plain break leaves only the innermost loop. To leave an outer loop, put a label (name@) on it and write break@name:

fun main() {
 outer@ for (i in 1..5) {
 for (j in 1..5) {
 if (i * j == 12) {
 println("Found $i x $j = 12")
 break@outer
 }
 }
 }
 println("Search finished")
}

For i = 1 and i = 2 no product reaches 12. For i = 3, j = 4 gives 12, so we print and jump out of both loops.

Found 3 x 4 = 12
Search finished

Labels also work with continue@outer. Use them sparingly. If you need many, a function with an early return is often clearer.

All the code above runs in a scratch file or the Kotlin library module from lesson 06. In an Android app, if and when appear inside composable functions to decide what to show. For example, in lesson 17 you will see something like this (shown here only to preview the idea, so imports are minimal):

import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
@Composable
fun StatusMessage(isOnline: Boolean) {
 if (isOnline) {
 Text("You are online")
 } else {
 Text("No connection")
 }
}

The if is the same if you learnt today, deciding which Text to put on screen. Loops like for and repeat are also available inside composables, though lists of items usually use lazy lists (lesson 21).

This set mirrors the style and difficulty of the official Practice: Kotlin Basics problems, using original problems and original wording. Work in the Playground and try each problem before revealing the solution. Do not skip these. The writing of the code is where the learning happens.

fun printNotificationSummary(count: Int) {
 if (count < 100) {
 println("You have $count notifications.")
 } else {
 println("Your phone is blowing up! You have 99+ notifications.")
 }
}
fun main() {
 printNotificationSummary(5)
 printNotificationSummary(250)
}

fun fareFor(age: Int): Int = when (age) {
 in 0..5 -> 0
 in 6..17 -> 100
 in 18..59 -> 200
 in 60..130 -> 50
 else -> -1
}
fun printFare(age: Int) {
 val fare = fareFor(age)
 if (fare == -1) {
 println("Age $age: invalid age")
 } else {
 println("Age $age: ₦$fare")
 }
}
fun main() {
 printFare(30)
 printFare(4)
 printFare(70)
 printFare(-3)
}

fun isLeapYear(year: Int): Boolean =
 (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
fun main() {
 println(isLeapYear(2024))
 println(isLeapYear(1900))
 println(isLeapYear(2000))
 println(isLeapYear(2026))
}

fun main() {
 for (n in 1..15) {
 val text = when {
 n % 15 == 0 -> "FizzBuzz"
 n % 3 == 0 -> "Fizz"
 n % 5 == 0 -> "Buzz"
 else -> n.toString()
 }
 println(text)
 }
}

fun printTable(n: Int, upTo: Int = 5) {
 for (i in 1..upTo) {
 println("$n x $i = ${n * i}")
 }
}
fun main() {
 printTable(7)
 println("---")
 printTable(12, 3)
}

fun countDigits(number: Int): Int {
 var n = number
 var count = 0
 do {
 n /= 10
 count++
 } while (n != 0)
 return count
}
fun main() {
 println(countDigits(4096))
 println(countDigits(7))
 println(countDigits(0))
}

fun isPrime(n: Int): Boolean {
 if (n < 2) return false
 var i = 2
 while (i * i <= n) {
 if (n % i == 0) return false
 i++
 }
 return true
}
fun main() {
 for (n in 1..20) {
 if (isPrime(n)) print("$n ")
 }
 println()
}

fun main() {
 for (i in 5 downTo 1) print("$i ")
 println("Lift off!")
 for (row in 1..3) {
 println("#".repeat(row))
 }
}

Mistake #1: = instead of ==. The wrong code: if (age = 18). The error: assignments are not allowed as conditions. The fix: if (age == 18). In Kotlin the compiler catches this for you.

Mistake #2: A missing else when if is an expression. The wrong code: val label = if (score > 50) "Pass". The error: if must have both main and else branches if used as an expression. The fix: val label = if (score > 50) "Pass" else "Fail".

Mistake #3: A missing else in when. The wrong code: a when used as an expression with only some cases. The error: when expression must be exhaustive. The fix: add else -> ... as the last branch.

Mistake #4: Wrong branch order. The wrong code: testing score >= 50 before score >= 70. The result: an 85 gets the grade for 50. The fix: put the most specific condition first.

Mistake #5: Off-by-one with ranges. The wrong code: for (i in 1 until 5) when you wanted 1 to 5. The result: only 1 to 4 run. The fix: 1..5 includes the end, until excludes it.

Mistake #6: A backwards range. The wrong code: for (i in 5..1). The result: the loop body never runs, with no error. The fix: for (i in 5 downTo 1).

Mistake #7: An infinite loop. The wrong code: var i = 0 then while (i < 5) { println(i) } with no i++. The result: the program prints 0 forever. The fix: make something change inside the loop. In Android Studio, press the red stop button in the Run window to end a runaway program.

Mistake #8: Trying to change the loop variable. The wrong code: for (i in 1..5) { i = i + 1 }. The error: Val cannot be reassigned. The fix: use a while loop if you need to control the counter yourself.

Mistake #9: Comparing strings with a range or forgetting .toString(). The wrong code: val text = if (n % 3 == 0) "Fizz" else n makes the type a mix of String and Int. The fix: write n.toString() when you need text in both branches.

Question 1. What is the value of val x = if (5 > 3) "big" else "small", and why is else needed?

Question 2. What does for (i in 1 until 4) print(i) print, and what changes with 1..4?

Question 3. Why does a do-while loop with a false condition still run once?

Question 4. In a when used as an expression, which branch is chosen if two conditions match?

Question 5. How do you stop an outer loop from inside an inner one?

Go deeper: official resources

• Android Basics with Compose, Unit 2, Pathway 1: the official pathway with the conditionals codelab and practice problems.
• Kotlin docs: Conditions and loops: if, when, for, while, break and continue in one page.
• Kotlin docs: Ranges and progressions: everything about .., until, downTo and step.
• Kotlin Playground: test every example in the browser.