self-learning

Let’s continue learning how to write idiomatic Kotlin code by solving the Advent of Code tasks! Today, we’re discussing the solution for the day 2 task.

Day 2. Password philosophy

We need to confirm that passwords meet the corporate policy. Find the full task description at https://adventofcode.com/2020/day/2*.

First, we need to read the input:

1-3 a: abcde
1-3 b: cdefg
2-9 c: ccccccccc

Each line contains the password policy and the password. Our task is to check that the password is valid and conforms to the given policy. The policies are different in the first and the second parts of the task.

In the first part, the password policy indicates the lowest and highest number of times a given letter must appear for the password to be valid. For example, 1-3 a means that the password must contain a at least once and at most 3 times. In the example, two passwords, the first and the third ones, are valid. The first contains one a, and the third contains nine cs, both within the limits of their respective policies. The second password, cdefg, is invalid, as it contains no instances of b but needs at least 1.

In the second part, the policy describes two positions in the password, where 1 means the first character, 2 means the second character, and so on (indexing starts at 1, not 0). Exactly one of these positions must contain the given letter. Other occurrences of the letter are irrelevant. Given the same example list from above:

1. 1-3 a: abcde is valid: position 1 contains a and position 3 does not.
2. 1-3 b: cdefg is invalid: neither position 1 nor position 3 contains b.
3. 2-9 c: ccccccccc is invalid: both positions 2 and position 9 contain c.

We should count the number of passwords from the given input that are valid according to the interpretations of the policies.

As usual, if you haven’t done it, please solve the task yourself first. Here’s how you can set up Kotlin for this purpose.

Solution

First, we should read and parse the input. Let’s create a data class for storing a given password together with its policy:

data class PasswordWithPolicy(
   val password: String,
   val range: IntRange,
   val letter: Char
)

Each policy specifies an integer range and a letter that we store in the IntRange and Char types, accordingly. The modifier data instructs the compiler to generate some useful methods for this class, including the constructor, equals, hashCode, and toString.

Parsing input

Let’s write a function that parses one input line into this class. Since it’s a function that creates an instance, let’s put it into a companion object in our data class. Then we can call it by the class name: PasswordWithPolicy.parse().

data class PasswordWithPolicy(...) {
   companion object {
       fun parse(line: String): PasswordWithPolicy { 
           TODO()
       }
   }
}

While developing, you can put the TODO() call that throws the NotImplementedError exception. Because it returns the Nothing type, which is a subtype of any other type, the compiler won’t complain. The function is supposed to return PasswordWithPolicy, but throwing an exception inside is totally valid from the compiler’s point of view.

There are two ways to parse the input: by using utility functions on Strings or by using regular expressions. Let’s discuss both of these ways.

The Kotlin standard library contains many useful functions on Strings, including substringAfter() and substringBefore() which perfectly solve the task in our case:

// 1-3 a: abcde
fun parse(line: String) = PasswordWithPolicy(
   password = line.substringAfter(": "),
   letter = line.substringAfter(" ").substringBefore(":").single(),
   range = line.substringBefore(" ").let {
       val (start, end) = it.split("-")
       start.toInt()..end.toInt()
   },
)

We provide the parameter names explicitly while calling the PasswordWithPolicy constructor. The input format convention requires that:

• password be the string that goes right after the colon
• the letter go between the whitespace and the colon, and
• the range go before the whitespace and consist of two numbers split by “-”

To build a range, we first take the substring before the whitespace and split it with the “-” delimiter. We then use only the first two parts (start and end), and build a range using the “..” operator converting both lines to Ints. We use let to convert the result of substringBefore() to the desired range.

In this code, we assume that all the input lines follow the rules. In a real-world scenario, we should check that the input is correct. substringAfter() and similar functions take a second argument default to the string itself that should be returned in the event the given delimiter is not found. toInt() and single() have toIntOrNull() and singleOrNull() counterparts returning null if the string can’t be converted to an integer number or consists of more than one character.

Let’s now implement the same logic using regular expressions. Here is a regular expression describing the input format:

(d+)-(d+) ([a-z]): ([a-z]+)

First are two numbers split by -, then a letter and a password.

Our new parse function matches the line against a regular expression and then builds PasswordWithPolicy on the result:

private val regex = Regex("""(d+)-(d+) ([a-z]): ([a-z]+)""")
fun parseUsingRegex(line: String): PasswordWithPolicy =
   regex.matchEntire(line)!!
       .destructured
       .let { (start, end, letter, password) ->
           PasswordWithPolicy(password, start.toInt()..end.toInt(), letter.single())
       }

In Kotlin, you use the Regex class to define a regular expression. Note how we put it inside a triple-quoted string, so you don’t need to escape . For regular strings, escaping is done in the conventional way, with a backslash, so if you need a backslash character in the string, you repeat it: "(\d+)-(\d+)".

We assume that our input is correct, which is why we use !! to throw an NPE if the input doesn’t correspond to the regular expression. An alternative is to use the safe access ?. here and return null as the result.

The destructured property provides components for a destructuring assignment for groups defined in the regular expression. We use its result together with let and destruct it inside the lambda expression, defining start, end, letter, and password as parameters. As before, we need to convert strings to Ints and Char.

Password validation

After we read the input, we need to validate whether the passwords comply with the given policy.

In the first part, we need to ensure that the number of occurrences of a given letter is in a range. It’s one line in Kotlin:

data class PasswordWithPolicy(
   val password: String,
   val range: IntRange,
   val letter: Char
) {
   fun validatePartOne() =
       password.count { it == letter } in range
   ...
}

We count the occurrences of letter in the password string, and check that the result is in range. in checks that the given element belongs to a range. For numbers and other comparable elements, x in range is the same as writing explicitly range.first <= x && x <= range.last.

The second part isn’t difficult. We need to check that exactly one of the positions (stored in the range) contains the given letter. We use the boolean xor operator for that, which returns true if the operands are different. That’s exactly what we need here:

fun validatePartTwo() =
   (password[range.first - 1] == letter) xor (password[range.last - 1] == letter)

We need to subtract 1 from first and last because they imply indexing from one, but string indexation starts from zero.

Added all together, this gives us our main function that finds the result for both parts:

fun main() {
   val passwords = File("src/day2/input.txt")
       .readLines()
       .map(PasswordWithPolicy::parse)
   println(passwords.count { it.validatePartOne() })
   println(passwords.count { it.validatePartTwo() })
}

Note how we pass a member reference PasswordWithPolicy::parse to the map function to convert the strings to passwords.

That’s it! We discussed how to solve this problem, and along the way, looked at string utility functions, regular expressions, operations on collections, and how let helps transform the expression nicely to the form you need.

Please let us know if you find this format useful and would like us to provide solutions for more difficult tasks!

—

*Used with the permission of Advent of Code (Eric Wastl).

What’s the best way to learn a language other than writing some code with it? Solving fun and short tasks like the ones from Advent of Code might be a great opportunity to practice your language skills, and you can learn a lot if you compare your solutions with how others have solved the same problem.

Lots of developers from around the world, including some from the Kotlin team, take part in the Advent of Code challenges created by Eric Wastl. Advent of Code is a series of tasks published every December, which you solve and compete with others. Many would agree that it’s the best advent calendar to celebrate Christmas and New Year!

To help the community learn idiomatic Kotlin, and motivate more developers to solve Advent of Code tasks in Kotlin in the future, we decided to prepare solutions for the tasks from Advent of Code 2020. It doesn’t matter if you solved it back in December, you’re ready to solve it now, or you just want to check the solutions – we hope you’ll find something useful in these materials. Of course, it works best if you try to solve the same task first yourself!

Below is the solution and video for the first task. If you find this format useful and want us to cover more tasks in a similar fashion, please share in the comments!

Day 1. Report Repair

We’re fixing an expense report! Find the full task description at https://adventofcode.com/2020/day/1*.

You need to find the two (and in the second part, three) entries from the list of numbers that sum to 2020 and then multiply those two (or three) numbers together.

How to solve the task

Register at https://adventofcode.com/, open the task at https://adventofcode.com/2020/day/1, write your solution in Kotlin, and check the result on the site. You can either write Kotlin code online or using an IDE:

• download the free Community Edition of IntelliJ IDEA
• create a Kotlin project
• write your solution there

Finally, compare your solution with the solution below.

We marked the src folder as a source set to put the code directly there. We copied input files, like src/day1/input.txt, to the source folder for convenience. You can find the solutions in this project.

Solution

Here’s the sample input:

1721
979
366
299
675
1456

First, we need to read and parse the input. We can use the Kotlin readLines() function for reading a list of lines from a given file:

File("src/day1/input.txt").readLines()

The readLines() returns a list of Strings, and we convert it to a list of numbers:

import java.io.File
fun main() {
   val numbers = File("src/day1/input.txt")
       .readLines()
       .map(String::toInt)


}

You put this code inside the main function, the entry point for your program. When you start typing, IntelliJ IDEA imports the java.io.File automatically.

Now we can simply iterate through the list, and then for each number repeat the iteration and check the sum:

for (first in numbers) {
   for (second in numbers) {
       if (first + second == 2020) {
           println(first * second)
           return
       }
   }
}

You put this code inside main, so return returns from main when the required numbers are found.

In a similar way, you check the sum of three numbers:

for (first in numbers) {
   for (second in numbers) {
       for (third in numbers) {
           if (first + second + third == 2020) {
               println(first * second * third)
               return
           }
       }
   }
}

You can run it and get the result for a given input. That’s it! The first task is really a simple one.

However, we iterate over the same list again and again for each of the elements. Having two nested loops for finding two numbers makes it N² operations, where N is the number of elements. When we need to find three numbers, that’s three nested loops, and N³ operations. If the list of numbers is large, that’s not the most efficient way to solve this type of problem. Surely there is a better way, right?

There definitely is and the Kotlin standard library can help us express that concisely. As often happens, we can replace the long calculation with some kind of smart storage used to find the result.

Solving the task for two numbers

First, let’s build a map for number “complements” – numbers that together with the given number sum up to 2020:

val complements = numbers.associateBy { 2020 - it }

We use the Kotlin associateBy function to build the map. Its lambda argument returns a key in this map, by which the list element is getting stored. For the sample input it’ll be the following map:

numbers: [1721, 979, 366, 299, 675, 1456]
complements map: {299=1721, 1041=979, 1654=366, 1721=299, 1345=675, 564=1456}

After this procedure, you can clearly see the answer! The very first number 1721 from the list is present in the complements map as a key: 1721=299, which means it’s the complement for the number 299, and they sum to 2020.

Having stored this information in a map, we can check if any number from the list has a complement in this map. The following code finds the first number with an existing complement:

val pair = numbers.mapNotNull { number ->
   val complement = complements[number]
   if (complement != null) Pair(number, complement) else null
}.firstOrNull()

We transform each number into a pair consisting of the number and its complement (if the complement exists) and then find the first non-null result.

We use mapNotNull, which transforms each element in a list and filters out all the resulting nulls. It’s shorthand for calling first map, and then filterNotNull on the result.

firstOrNull returns the first element in the list or null if the list is empty. Kotlin standard library often uses the OrNull suffix to mark functions returning null on failure rather than throwing an exception (like elementAtOrNull, singleOrNull, or maxOrNull).

Starting with Kotlin 1.5.0, you can also replace the two consequent operations mapNotNull and first(OrNull) with one function call: firstNotNullOf(OrNull).

After building the auxiliary structure, we managed to find the resulting two numbers in N operations, not in N² as before!

We need a multiplication of these numbers, so here’s the last step:

println(pair?.let { (a, b) -> a * b })

The pair variable contains a nullable Pair of two numbers and is null if the initial list contains no numbers that sum up to 2020. We use safe access ?. together with the let function and destructuring in a lambda syntax to display the result in case pair is not null.

Solving the task for three numbers

The next step is solving this problem for three numbers. Let’s reuse what we’ve done so far and extract the logic of finding a pair of numbers summing up to a given number into a separate function:

fun List<Int>.findPairOfSum(sum: Int): Pair<Int, Int>? {
   // Map: sum - x -> x
   val complements = associateBy { sum - it }
   return firstNotNullOfOrNull { number ->
       val complement = complements[number]
       if (complement != null) Pair(number, complement) else null
   }
}

We also used the firstNotNullOfOrNull function.

Now, we use findPairOfSum to build a helper map that stores the complement pair of values for each number which together with this number sums up to 2020:

// Map: x -> (y, z) where y + z = 2020 - x
val complementPairs: Map<Int, Pair<Int, Int>?> =
   numbers.associateWith { numbers.findPairOfSum(2020 - it) }

For the same initial input, here’s the complement pairs map:

numbers: [1721, 979, 366, 299, 675, 1456]
complement pairs: {1721=null, 979=(366, 675), 366=(979, 675), 299=null, 675=(979, 366), 1456=null}

As before, you already can see the answer! It’s the number that corresponds to a non-null pair in a map.

However, we don’t really need to build the whole map — we only need to find the first number that corresponds to a non-null pair! Let’s find it using the already familiar firstNotNullOfOrNull function:

fun List<Int>.findTripleOfSum(): Triple<Int, Int, Int>? =
   firstNotNullOfOrNull { x ->
       findPairOfSum(2020 - x)?.let { pair ->
           Triple(x, pair.first, pair.second)
       }
   }

Note Kotlin’s concise syntax – the function can return an expression directly.

The final step is to find the multiplication if the resulting triple is non-null, similar to how we did it before:

println(triple?.let { (x, y, z) -> x * y * z} )

That’s all!

In the next part, we’ll discuss how to solve the second task. Please let us know if you find this content useful and would like us to provide solutions for more tasks!

—

*Used with the permission of Advent of Code (Eric Wastl).