I pretty much exclusively use Kotlin for competitive programming, mostly because it's the language I'm currently most comfortable with. Here are some scattered notes and tidbits about my experience which I think might be useful to others; if you have any tips/suggestions, feel free to let me know.↵
↵
### Primer↵
↵
- Kotlin has an official [primer for competitive programming](https://kotlinlang.org/docs/tutorials/competitive-programming.html). However, the IO code suggested there is only so-so; it's definitely better than `Scanner`, but you definitely can save a lot of runtime in heavy input problems by using the classic Java combination of `BufferedReader` + `StringTokenizer`↵
↵
<spoiler summary="My current IO template">↵
```↵
@JvmField val INPUT = System.`in`↵
@JvmField val OUTPUT = System.out↵
↵
@JvmField val _reader = INPUT.bufferedReader()↵
fun readLine(): String? = _reader.readLine()↵
fun readLn() = _reader.readLine()!!↵
@JvmField var _tokenizer: StringTokenizer = StringTokenizer("")↵
fun read(): String {↵
while (_tokenizer.hasMoreTokens().not()) _tokenizer = StringTokenizer(_reader.readLine() ?: return "", " ")↵
return _tokenizer.nextToken()↵
}↵
fun readInt() = read().toInt()↵
fun readDouble() = read().toDouble()↵
fun readLong() = read().toLong()↵
fun readStrings(n: Int) = List(n) { read() }↵
fun readLines(n: Int) = List(n) { readLn() }↵
fun readInts(n: Int) = List(n) { read().toInt() }↵
fun readIntArray(n: Int) = IntArray(n) { read().toInt() }↵
fun readDoubles(n: Int) = List(n) { read().toDouble() }↵
fun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }↵
fun readLongs(n: Int) = List(n) { read().toLong() }↵
fun readLongArray(n: Int) = LongArray(n) { read().toLong() }↵
↵
@JvmField val _writer = PrintWriter(OUTPUT, false)↵
inline fun output(block: PrintWriter.() -> Unit) { _writer.apply(block).flush() }↵
```↵
↵
The `output` function allows me to wrap all code within the `main` function in an `output { ... }` block, and call `println` etc. within it. It's automatically flushed when the block is finished.↵
</spoiler>↵
↵
### Useful features↵
↵
- A lot less boilerplate than Java. Members are `public` by default. Type inference means a lot less "Pokémon speak". Variables and functions can be declared straight in the top-level of the file. (basically the equivalent of `static` functions). Fields have implicit getters and setters that can easily be overridden when necessary.↵
↵
- PHP-like string templates, e.g. `"$id $cost"`↵
↵
- Extension functions – syntactic sugar for static functions; gives more natural "afterthought" syntax, as well as allowing direct access to public members of the receiver↵
↵
- `data class`es – basically custom tuples. Allows convenient [destructuring declarations](https://kotlinlang.org/docs/reference/multi-declarations.html) too.↵
↵
- Has access to the data structures in the Java standard library (`TreeMap`, `HashMap`, `PriorityQueue` etc.), and also can use `BigInteger` and `BigDecimal` if needed↵
↵
- Functional idioms for collection manipulation – `map`, `fold`, `filter`, etc.↵
↵
- Sequences – lazy sequence generators, potentially infinite, has standard collection manipulation functions too. Using the `sequence { ... }` block function allows building a sequence using a scoped `yield(value)` function, reminiscent of Python↵
↵
- `inline class`es – allows the creation of a new type that wraps over a base type, but that is represented by an underlying type at runtime. Especially useful for "modulo $10^9 + 7$" problems, as I keep code for a `ModInt` class that overloads the arithmetic operators appropriately, but is represented as a plain `int` in JVM runtime. Keep in mind that they are experimental as of Kotlin 1.3, but that's fine for CP in my opinion↵
↵
- unsigned integer types in the standard library that use the `inline class` feature. Not used very often, but handy if needed↵
↵
- `inline fun`ctions – tells the compiler to inline the function to call sites. Useful for higher-order functions (JVM won't need to create a new object for the lambda) as well as small functions that are called very often; basically, anything you might use a macro for in C++, you probably want to use an `inline fun` or `inline val` for↵
↵
- `tailrec fun` – tail recursion optimization↵
↵
- `run` block function – great way to write code that needs to shortcut (e.g. `return@run "NO"`) without having to write a new function and pass every relevant argument↵
↵
- functions in functions – functions can be defined within e.g. the `main` function, so again, no having to pass lots of arguments or global variables. Keep in mind that these are represented as objects during runtime. It's too bad they can't be `inline` as of yet↵
↵
### Potential pitfalls↵
↵
- Generic wrappers for JVM primitive types can cause TLE for some problems. Use primitive arrays (`IntArray` etc.) whenever possible to avoid this, but see next point↵
↵
- Inherits the hack-prone quicksort from Java for primitive arrays. Easiest solution is to use generic arrays or lists instead, but due to the performance benefit of primitive arrays, I've took the trouble to write code that shuffles them randomly before sorting.↵
↵
- For Kotlin versions < 1.3.30, [there is a bug](https://youtrack.jetbrains.com/issue/KT-29520) that will throw an exception when using `.asJavaRandom()` on instances of `kotlin.random.Random`, including Kotlin's default instance. Either use Java's own Random class, or steal this wrapper: ↵
↵
<spoiler summary="Code for Java Random wrapper">↵
```↵
class JavaRandom(val kt: Random) : java.util.Random(0) {↵
override fun next(bits: Int): Int = kt.nextBits(bits)↵
override fun nextInt(): Int = kt.nextInt()↵
override fun nextInt(bound: Int): Int = kt.nextInt(bound)↵
override fun nextBoolean(): Boolean = kt.nextBoolean()↵
override fun nextLong(): Long = kt.nextLong()↵
override fun nextFloat(): Float = kt.nextFloat()↵
override fun nextDouble(): Double = kt.nextDouble()↵
↵
override fun nextBytes(bytes: ByteArray) {↵
kt.nextBytes(bytes)↵
}↵
↵
override fun setSeed(seed: Long) {}↵
}↵
```↵
</spoiler>↵
↵
↵
### Primer↵
↵
- Kotlin has an official [primer for competitive programming](https://kotlinlang.org/docs/tutorials/competitive-programming.html). However, the IO code suggested there is only so-so; it's definitely better than `Scanner`, but you definitely can save a lot of runtime in heavy input problems by using the classic Java combination of `BufferedReader` + `StringTokenizer`↵
↵
<spoiler summary="My current IO template">↵
```↵
@JvmField val INPUT = System.`in`↵
@JvmField val OUTPUT = System.out↵
↵
@JvmField val _reader = INPUT.bufferedReader()↵
fun readLine(): String? = _reader.readLine()↵
fun readLn() = _reader.readLine()!!↵
@JvmField var _tokenizer: StringTokenizer = StringTokenizer("")↵
fun read(): String {↵
while (_tokenizer.hasMoreTokens().not()) _tokenizer = StringTokenizer(_reader.readLine() ?: return "", " ")↵
return _tokenizer.nextToken()↵
}↵
fun readInt() = read().toInt()↵
fun readDouble() = read().toDouble()↵
fun readLong() = read().toLong()↵
fun readStrings(n: Int) = List(n) { read() }↵
fun readLines(n: Int) = List(n) { readLn() }↵
fun readInts(n: Int) = List(n) { read().toInt() }↵
fun readIntArray(n: Int) = IntArray(n) { read().toInt() }↵
fun readDoubles(n: Int) = List(n) { read().toDouble() }↵
fun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }↵
fun readLongs(n: Int) = List(n) { read().toLong() }↵
fun readLongArray(n: Int) = LongArray(n) { read().toLong() }↵
↵
@JvmField val _writer = PrintWriter(OUTPUT, false)↵
inline fun output(block: PrintWriter.() -> Unit) { _writer.apply(block).flush() }↵
```↵
↵
The `output` function allows me to wrap all code within the `main` function in an `output { ... }` block, and call `println` etc. within it. It's automatically flushed when the block is finished.↵
</spoiler>↵
↵
### Useful features↵
↵
- A lot less boilerplate than Java. Members are `public` by default. Type inference means a lot less "Pokémon speak". Variables and functions can be declared straight in the top-level of the file. (basically the equivalent of `static` functions). Fields have implicit getters and setters that can easily be overridden when necessary.↵
↵
- PHP-like string templates, e.g. `"$id $cost"`↵
↵
- Extension functions – syntactic sugar for static functions; gives more natural "afterthought" syntax, as well as allowing direct access to public members of the receiver↵
↵
- `data class`es – basically custom tuples. Allows convenient [destructuring declarations](https://kotlinlang.org/docs/reference/multi-declarations.html) too.↵
↵
- Has access to the data structures in the Java standard library (`TreeMap`, `HashMap`, `PriorityQueue` etc.), and also can use `BigInteger` and `BigDecimal` if needed↵
↵
- Functional idioms for collection manipulation – `map`, `fold`, `filter`, etc.↵
↵
- Sequences – lazy sequence generators, potentially infinite, has standard collection manipulation functions too. Using the `sequence { ... }` block function allows building a sequence using a scoped `yield(value)` function, reminiscent of Python↵
↵
- `inline class`es – allows the creation of a new type that wraps over a base type, but that is represented by an underlying type at runtime. Especially useful for "modulo $10^9 + 7$" problems, as I keep code for a `ModInt` class that overloads the arithmetic operators appropriately, but is represented as a plain `int` in JVM runtime. Keep in mind that they are experimental as of Kotlin 1.3, but that's fine for CP in my opinion↵
↵
- unsigned integer types in the standard library that use the `inline class` feature. Not used very often, but handy if needed↵
↵
- `inline fun`ctions – tells the compiler to inline the function to call sites. Useful for higher-order functions (JVM won't need to create a new object for the lambda) as well as small functions that are called very often; basically, anything you might use a macro for in C++, you probably want to use an `inline fun` or `inline val` for↵
↵
- `tailrec fun` – tail recursion optimization↵
↵
- `run` block function – great way to write code that needs to shortcut (e.g. `return@run "NO"`) without having to write a new function and pass every relevant argument↵
↵
- functions in functions – functions can be defined within e.g. the `main` function, so again, no having to pass lots of arguments or global variables. Keep in mind that these are represented as objects during runtime. It's too bad they can't be `inline` as of yet↵
↵
### Potential pitfalls↵
↵
- Generic wrappers for JVM primitive types can cause TLE for some problems. Use primitive arrays (`IntArray` etc.) whenever possible to avoid this, but see next point↵
↵
- Inherits the hack-prone quicksort from Java for primitive arrays. Easiest solution is to use generic arrays or lists instead, but due to the performance benefit of primitive arrays, I've took the trouble to write code that shuffles them randomly before sorting.↵
↵
- For Kotlin versions < 1.3.30, [there is a bug](https://youtrack.jetbrains.com/issue/KT-29520) that will throw an exception when using `.asJavaRandom()` on instances of `kotlin.random.Random`, including Kotlin's default instance. Either use Java's own Random class, or steal this wrapper: ↵
↵
<spoiler summary="Code for Java Random wrapper">↵
```↵
class JavaRandom(val kt: Random) : java.util.Random(0) {↵
override fun next(bits: Int): Int = kt.nextBits(bits)↵
override fun nextInt(): Int = kt.nextInt()↵
override fun nextInt(bound: Int): Int = kt.nextInt(bound)↵
override fun nextBoolean(): Boolean = kt.nextBoolean()↵
override fun nextLong(): Long = kt.nextLong()↵
override fun nextFloat(): Float = kt.nextFloat()↵
override fun nextDouble(): Double = kt.nextDouble()↵
↵
override fun nextBytes(bytes: ByteArray) {↵
kt.nextBytes(bytes)↵
}↵
↵
override fun setSeed(seed: Long) {}↵
}↵
```↵
</spoiler>↵
↵
