Kotlin for Competitive Programming: A Comprehensive Guide

March 2025
M	T	W	T	F	S	S
	1	2
3	4	5	6	7	8	9
10	11	12	13	14	15	16
17	18	19	20	21	22	23
24	25	26	27	28	29	30
31

Introduction

Competitive programming is a unique mind sport where participants solve algorithmic problems within strict time and space constraints. For competitive programmers, choosing the right programming language can be crucial to writing efficient, clean, and readable solutions. While many languages are used for this domain, Kotlin has emerged as an excellent choice for solving competitive programming problems, offering both concise syntax and robust performance.

This tutorial is designed for both Kotlin developers new to competitive programming and competitive programmers looking to explore Kotlin. It assumes the reader already possesses general programming skills and a basic understanding of competitive programming concepts.

Why Kotlin?

Kotlin, a modern programming language running on the JVM, has quickly gained popularity in various domains, including Android development. Its concise syntax, powerful features, and seamless interoperability with Java make it a great fit for competitive programming. Here’s why Kotlin stands out:

Conciseness: Kotlin reduces boilerplate code, allowing developers to focus more on the problem-solving aspect.
Immutability: With features like val (immutable variables), Kotlin promotes immutability by default, which can lead to cleaner code and fewer bugs.
Functional Programming: Kotlin supports functional programming paradigms, making it possible to express algorithms in a more declarative manner.
Performance: Kotlin runs on the JVM, meaning it inherits the performance optimizations provided by the JVM, which is crucial for time-sensitive problems.
Tooling: Kotlin offers excellent IDE support, such as IntelliJ IDEA, making coding, debugging, and testing easier for competitive programmers.

Setting up Kotlin for Competitive Programming

To begin using Kotlin, you need to set up your development environment for Kotlin on JVM. Here’s a step-by-step guide to getting started:

Install IntelliJ IDEA: IntelliJ IDEA is an excellent IDE for Kotlin development and offers various features, such as intelligent code completion, refactoring tools, and integrated testing frameworks.
Kotlin SDK: Download and install the Kotlin SDK for your environment.
Set up Kotlin for JVM: Refer to Kotlin’s official website for detailed setup instructions: Get started with Kotlin/JVM.

Once your environment is set up, you can create a single Kotlin file for each problem’s solution. Competitive programmers often work with a single file per problem and may use an extensive library of utility functions for convenience.

Simple Example: Reachable Numbers Problem

To demonstrate Kotlin’s features, let’s look at the “Reachable Numbers” problem from Codeforces Round 555.

Problem Summary:

The task is to implement a function f(x) that:

Adds 1 to x.
Removes any trailing zeros from the result.

We are required to find how many distinct integers are generated by repeatedly applying f(x) starting from a given number n.

Kotlin Implementation:

First, we define the function f(x) in Kotlin, using both functional and imperative approaches.

Functional Approach (Tail Recursion):

tailrec fun removeZeroes(x: Int): Int =
    if (x % 10 == 0) removeZeroes(x / 10) else x

fun f(x: Int) = removeZeroes(x + 1)

tailrec fun removeZeroes(x: Int): Int =

if (x % 10 == 0) removeZeroes(x / 10) else x

fun f(x: Int) = removeZeroes(x + 1)

Imperative Approach (Using While Loop):

fun f(x: Int): Int {
    var cur = x + 1
    while (cur % 10 == 0) cur /= 10
    return cur
}

fun f(x: Int): Int {

var cur = x + 1

while (cur % 10 == 0) cur /= 10

return cur

}

Solution Code:

Now, we will read input and repeatedly apply function f(x) until we get all distinct numbers:

fun main() {
    var n = readln().toInt()  // Read integer input
    val reached = HashSet&lt;Int&gt;()  // A hash set to track distinct numbers

    // Repeatedly apply f(x) while adding the result to the set
    while (reached.add(n)) {
        n = f(n)
    }

    // Output the number of distinct results
    println(reached.size)
}

fun main() {

var n = readln().toInt() // Read integer input

val reached = HashSet<Int>() // A hash set to track distinct numbers

// Repeatedly apply f(x) while adding the result to the set

while (reached.add(n)) {

n = f(n)

}

// Output the number of distinct results

println(reached.size)

}

In competitive programming, handling input is crucial, and Kotlin makes this easy:

private fun readStr() = readln() // Read string line
private fun readInt() = readStr().toInt() // Single integer input

private fun readStr() = readln() // Read string line

private fun readInt() = readStr().toInt() // Single integer input

By using these helper functions, you simplify the input reading for various types.

Functional Operators Example: Long Number Problem

Kotlin’s rich functional programming support allows for concise and elegant solutions to more complex problems. Let’s take a look at the “Long Number” problem.

Problem Summary:

This problem requires you to greedily find a substring that can be transformed based on some transformation rules and output the result.

Kotlin Implementation:

fun main() {
    val n = readln().toInt()
    val s = readln()
    val fl = readln().split(" ").map { it.toInt() }

    // Define local transformation function
    fun f(c: Char) = '0' + fl[c - '1']

    // Greedily find first and last indices
    val i = s.indexOfFirst { c -&gt; f(c) &gt; c }.takeIf { it &gt;= 0 } ?: s.length
    val j = s.withIndex().indexOfFirst { (j, c) -&gt; j &gt; i &amp;&amp; f(c) &lt; c }
        .takeIf { it &gt;= 0 } ?: s.length

    // Compose and print the result
    val ans = s.substring(0, i) +
              s.substring(i, j).map { c -&gt; f(c) }.joinToString("") +
              s.substring(j)
    println(ans)
}

fun main() {

val n = readln().toInt()

val s = readln()

val fl = readln().split(" ").map { it.toInt() }

// Define local transformation function

fun f(c: Char) = '0' + fl[c - '1']

// Greedily find first and last indices

val i = s.indexOfFirst { c -> f(c) > c }.takeIf { it >= 0 } ?: s.length

val j = s.withIndex().indexOfFirst { (j, c) -> j > i && f(c) < c }

.takeIf { it >= 0 } ?: s.length

// Compose and print the result

val ans = s.substring(0, i) +

s.substring(i, j).map { c -> f(c) }.joinToString("") +

s.substring(j)

println(ans)

}

This solution is clean, leveraging Kotlin’s powerful collection operators like map, indexOfFirst, and joinToString.

More Tips and Tricks

Destructuring Declaration: Kotlin allows you to destructure input efficiently. For example, to read two integers from a single line:

val (n, k) = readInts()

1
2

val (n, k) = readInts()
Efficient Output: When dealing with a large number of output lines, use joinToString() for fast output:

println(a.joinToString("\n"))

1
2

println(a.joinToString("\n"))
Avoid Using Scanner: While Java’s Scanner class is available, it’s slower than Kotlin’s native input functions. Always prefer readln() or readLine().

Conclusion

Kotlin is a powerful and efficient language for competitive programming, with its concise syntax, functional programming support, and excellent JVM performance. By leveraging Kotlin’s features like immutability, concise syntax, and functional operators, you can write clean, efficient code for solving algorithmic problems.

Competitive programming in Kotlin offers a balanced approach to solving problems with minimal boilerplate, powerful libraries, and an easy-to-use development environment. Whether you are a seasoned competitive programmer or new to the field, Kotlin is a language that can help you excel in coding challenges.