Run automated migrations for latest Kotlin version and clean up some additional warnings by hand.

Author: incendium

exercises/practice/acronym/.meta/src/reference/kotlin/Acronym.kt

@@ -1,6 +1,6 @@
 object Acronym {
     fun generate(phrase: String) = Regex("[A-Z]+[a-z]*|[a-z]+")
             .findAll(phrase.replace("'", ""))
-            .map { it.value.first().toUpperCase() }
+            .map { it.value.first().uppercaseChar() }
             .joinToString("")
 }

exercises/practice/affine-cipher/.meta/src/reference/kotlin/AffineCipher.kt

@@ -26,7 +26,7 @@ object AffineCipher {
         require(inv != 1) { "Key A and alphabet size must be coprime!" }
 
         return text
-                .toLowerCase()
+            .lowercase()
                 .mapNotNull { c ->
                     when {
                         c.isDigit() -> c

exercises/practice/all-your-base/.meta/src/reference/kotlin/BaseConverter.kt

@@ -1,8 +1,11 @@
+import kotlin.math.floor
+import kotlin.math.pow
+
 class BaseConverter(originalBase: Int, originalDigits: IntArray) {
 
     companion object {
-        private val MINIMUM_VALID_BASE = 2
-        private val INVALID_BASE_ERROR_MESSAGE = "Bases must be at least 2."
+        private const val MINIMUM_VALID_BASE = 2
+        private const val INVALID_BASE_ERROR_MESSAGE = "Bases must be at least 2."
     }
 
     private val numeral: Int
@@ -25,11 +28,11 @@ class BaseConverter(originalBase: Int, originalDigits: IntArray) {
         var remainder = numeral
 
         for (currentExponent in largestExponent downTo 0) {
-            val coefficient = Math.floor(remainder / Math.pow(newBase.toDouble(), currentExponent.toDouble())).toInt()
+            val coefficient = floor(remainder / newBase.toDouble().pow(currentExponent.toDouble())).toInt()
 
             result[largestExponent - currentExponent] = coefficient
 
-            remainder -= (coefficient * Math.pow(newBase.toDouble(), currentExponent.toDouble())).toInt()
+            remainder -= (coefficient * newBase.toDouble().pow(currentExponent.toDouble())).toInt()
         }
 
         return result
@@ -38,9 +41,9 @@ class BaseConverter(originalBase: Int, originalDigits: IntArray) {
     private fun computeNumeral(originalBase: Int, originalDigits: IntArray): Int {
         val largestExponent = originalDigits.size - 1
 
-        val result = (largestExponent downTo 0).sumBy { exponent ->
+        val result = (largestExponent downTo 0).sumOf { exponent ->
             (originalDigits[largestExponent - exponent]
-                * Math.pow(originalBase.toDouble(), exponent.toDouble())).toInt()
+                    * originalBase.toDouble().pow(exponent.toDouble())).toInt()
         }
 
         return result
@@ -49,7 +52,7 @@ class BaseConverter(originalBase: Int, originalDigits: IntArray) {
     private fun computeLargestExponentForBase(newBase: Int): Int {
         var result = 0
 
-        while (Math.pow(newBase.toDouble(), (result + 1).toDouble()) < numeral) {
+        while (newBase.toDouble().pow((result + 1).toDouble()) < numeral) {
             result += 1
         }
 

exercises/practice/anagram/.meta/src/reference/kotlin/Anagram.kt

@@ -1,11 +1,11 @@
 class Anagram(private val word: String) {
 
     fun match(anagrams: Collection<String>) =
-            anagrams.filter { containSameChars(it.toLowerCase()) }
+            anagrams.filter { containSameChars(it.lowercase()) }
                     .filterNot { it.equals(word, ignoreCase = true) }
                     .toSet()
 
     private fun containSameChars(candidate: String) =
-            candidate.toLowerCase().toCharArray().sorted() == word.toLowerCase().toCharArray().sorted()
+            candidate.lowercase().toCharArray().sorted() == word.lowercase().toCharArray().sorted()
 
 }

exercises/practice/armstrong-numbers/.meta/src/reference/kotlin/ArmstrongNumber.kt

@@ -6,9 +6,8 @@ object ArmstrongNumber {
         val str = input.toString()
         val inputLength = str.length
         val calculated = str
-                .map { Character.getNumericValue(it) } // digit character to its numeric (not ASCII!) value
-                .map { BigInteger.valueOf(it.toLong()).pow(inputLength).toLong() } // calculate digit^inputLength
-                .sum()
+            .map { Character.getNumericValue(it) } // digit character to its numeric (not ASCII!) value
+            .sumOf { BigInteger.valueOf(it.toLong()).pow(inputLength).toLong() } // calculate digit^inputLength
 
         return input == calculated
     }

exercises/practice/atbash-cipher/.meta/src/reference/kotlin/Atbash.kt

@@ -1,16 +1,16 @@
 object Atbash {
-    private val GROUP_SIZE = 5
+    private const val GROUP_SIZE = 5
 
     fun encode(s: String): String = cipherSubstitution(s).mapIndexed { index, char -> char + groupFinalizer(index) }.joinToString("").trimEnd()
 
     fun decode(s: String): String = cipherSubstitution(s)
 
-    private fun cipherSubstitution(s: String): String = s.fold("", { accum, char -> accum + substitute(char) })
+    private fun cipherSubstitution(s: String): String = s.fold("") { accum, char -> accum + substitute(char) }
 
     private fun substitute(c: Char): String {
         return when {
             c.isDigit() -> c.toString()
-            c.isLetter() -> ('a' + ('z' - c.toLowerCase())).toString()
+            c.isLetter() -> ('a' + ('z' - c.lowercaseChar())).toString()
             else -> ""
         }
     }

exercises/practice/binary/.meta/src/reference/kotlin/Binary.kt

@@ -1,11 +1,11 @@
 object Binary {
     fun toDecimal(s: String): Int {
-        return s.fold(0, { accum, char ->
+        return s.fold(0) { accum, char ->
             when (char) {
                 '0' -> accum * 2
                 '1' -> (accum * 2) + 1
                 else -> return 0
             }
-        })
+        }
     }
 }

exercises/practice/bob/.meta/src/reference/kotlin/Bob.kt

@@ -16,7 +16,7 @@ object Bob {
     private fun isQuestion(input: String) = input.endsWith("?")
 
     private fun isShout(input: String): Boolean {
-        val isOnlyUppercase = input == input.toUpperCase()
+        val isOnlyUppercase = input == input.uppercase()
         val hasLetter = input.contains(Regex("[A-Z]"))
 
         return hasLetter && isOnlyUppercase

exercises/practice/change/.meta/src/reference/kotlin/ChangeCalculator.kt

@@ -6,19 +6,17 @@ class ChangeCalculator(coins: List<Int>) {
         require(grandTotal >= 0) { "Negative totals are not allowed." }
 
         val minimalCoinsMap = mutableMapOf<Int, List<Int>?>()
-        minimalCoinsMap.put(0, ArrayList())
+        minimalCoinsMap[0] = ArrayList()
 
         for (total in 1..grandTotal) {
             val minimalCoins = sortedCoins
-                    .filter { it <= total }
-                    .mapNotNull { coin ->
-                        val minimalRemainderCoins = minimalCoinsMap[total - coin]
-                        if (minimalRemainderCoins != null) prepend(coin, minimalRemainderCoins) else null
-                    }
-                    .sortedBy { it.size }
-                    .firstOrNull()
-
-            minimalCoinsMap.put(total, minimalCoins)
+                .filter { it <= total }
+                .mapNotNull { coin ->
+                    val minimalRemainderCoins = minimalCoinsMap[total - coin]
+                    if (minimalRemainderCoins != null) prepend(coin, minimalRemainderCoins) else null
+                }.minByOrNull { it.size }
+
+            minimalCoinsMap[total] = minimalCoins
         }
 
         return minimalCoinsMap[grandTotal] ?: throw IllegalArgumentException(

exercises/practice/clock/.meta/src/reference/kotlin/Clock.kt

@@ -1,8 +1,8 @@
 data class Clock(private var hours: Int, private var minutes: Int) {
 
     companion object {
-        private val MINUTES_IN_AN_HOUR = 60
-        private val HOURS_IN_A_DAY = 24
+        private const val MINUTES_IN_AN_HOUR = 60
+        private const val HOURS_IN_A_DAY = 24
     }
 
     init {