How to Use Kotlin to Solve Coding Problems

I have talked to many Android developers, and most of them are excited about Kotlin. So am I. When I just started learning Kotlin, I was solving Kotlin Koans, and along with other great features, I was impressed with the power of functions for performing operations on collections. Since then, I spent three years writing Kotlin code but rarely utilised all the potential of the language.

During this year, I did more than a hundred coding problems on Leetcode in Java. I didn’t switch to Kotlin because I know the syntax of Java 6 so well, that I could effortlessly write code without autocompletion and syntax highlighting. But I didn’t keep track of new Java features, as Android support of Java SDK lagged many versions behind. I didn’t switch to Kotlin for solving problems right away.

Although I was writing Kotlin code for several years, I felt that I need to make an extra cognitive effort to get the syntax and the language constructions right. Solving algorithmic problems, especially under time pressure, is very different from Android app development. Still, the more I learned about Kotlin, the more I realised how many powerful features I’m missing, and how much boilerplate code I need to write.

One day, I have decided that I need to move on, so I started a new session in Leetcode and switched the compiler to Kotlin. I solved just a few easy problems, but I already feel that I have something to share.

Loops

Let’s start with loops. Let’s say, you have an 

IntArray

0, 1, 2, 3, 4, 5, 6, 7, 8, 9

123456789

val array = intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
for(index in (1 until array.size)) {
  print(array[index])
}

(1 until array.size)

IntRange

Int

1

9

until

ArrayIndexOutOfBoundsException

But what if we want to print all the elements of the array, except the element at index 5? Like this 

012346789

if

val array = intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
for(index in array.indices - 5) {
  print(array[index])
}

array.indices

array.indices

IntRange

(0..9)

(0..9) - 5

[0, 1, 2, 3, 4, 6, 7, 8, 9]

Kotlin also provides an ability to iterate from the greater number down to the smaller number using 

downTo

step

val array = intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
for(index in array.size - 1 downTo 1 step 2) {
  print(array[index])
}

The code above with result in 

97531

Remove Vowels from a String

It’s problem number 1119 on Leetcode.

Given a string S, remove the vowels 'a', 'e', 'i', 'o', and 'u' from it, and return the new string.

Even in Java there is a 1 line regex solution, but my intuition was the following:

1. Create a StringBuilder

2. Iterate over characters, and if the current character is not a vowel, append it to the StringBuilder

3. Return String from the StringBuilder

public String removeVowels(String S) {
  StringBuilder sb = new StringBuilder();  
  for(char s: S.toCharArray()) {
    if(s != 'a' && s != 'e' && s != 'i' && s !='o' && s != 'u') {
      sb.append(s);  
    }
  }
  return sb.toString();
}

What about Kotlin? More idiomatic way is to use 

filter()

filterNot()

fun removeVowels(S: String): String {
  val vowels = setOf('a', 'e', 'i', 'o', 'u')
  return S.filter { it !in vowels }
}

filter {predicate: (Char) -> Boolean}

But instead of inverting 

!in

filterNot()

fun removeVowels(S: String): String {
  val vowels = setOf('a', 'e', 'i', 'o', 'u')
  return S.filterNot { it in vowels }
}

That was simple even for a beginner. Let’s move on to something a bit more sophisticated.

Running Sum of 1d Array

It’s another easy problem from Leetcode. Number 1480.

Given an array nums. We define a running sum of an array as runningSum[i] = sum(nums[0]…nums[i]). Return the running sum of nums.

Input: nums = [1,2,3,4]
Output: [1,3,6,10]
Explanation: Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].

So we need to iterate over the array, adding the value at the current index to the running sum, and put it to the same index in the result array.

Is there something in Kotlin to help us with the running sum? Well, there’s different variations of 

fold()

reduce()

Here’s a good explanation of those functions. But since Kotlin 1.4 there’s even more: 

runningFold()

runningReduce()

runningReduce()

/**
 * Returns a list containing successive accumulation values generated by applying [operation] from left to right
 * to each element and current accumulator value that starts with the first element of this array.
 * 
 * @param [operation] function that takes current accumulator value and an element, and calculates the next accumulator value.
 * 
 * @sample samples.collections.Collections.Aggregates.runningReduce
 */
@SinceKotlin("1.4")
@kotlin.internal.InlineOnly
public inline fun IntArray.runningReduce(operation: (acc: Int, Int) -> Int): List<Int>

Sounds a bit too complex, but it will make sense when you’ll see an example.

fun runningSum(nums: IntArray): IntArray {
  return nums.runningReduce { sum, element -> sum + element }.toIntArray()
}

This is the whole solution to the running sum problem using Kotlin 

runningReduce()

sum

element

sum

sum

element

sum: 1; element: 2; sum + element: 3
sum: 3; element: 3; sum + element: 6
sum: 6; element: 4; sum + element: 10
sum: 10; element: 5; sum + element: 15

And the array we return is 

[1, 3, 6, 10, 15]

sum + element: 1

runningReduce

Unfortunately, Leetcode doesn’t support Kotlin 1.4 yet, so the code above might not compile.

Most Common Word

Easy Leetcode problem, number 819.

Given a paragraph and a list of banned words, return the most frequent word that is not in the list of banned words. It is guaranteed there is at least one word that isn’t banned, and that the answer is unique.

Input:
paragraph = "Bob hit a ball, the hit BALL flew far after it was hit."
banned = ["hit"]
Output: "ball"

What are the steps to solve it?

1. Convert string to lower case and split by words.

[bob, hit, a, ball, the, hit, ball, flew, far, after, it, was, hit]

2. Create a set of banned words.

[hit]

3. Create a map of words to their occurrence, excluding the banned words.

{bob=1, a=1, ball=2, the=1, flew=1, far=1, after=1, it=1, was=1}

4. Return word with the highest number of occurrences from the map.

ball

Let’s implement those 4 steps in Java.

public String mostCommonWord(String paragraph, String[] banned) {
  // 1. Covert string to lower case and split by words.
  String[] words = paragraph.replaceAll("[^a-zA-Z0-9 ]", " ").toLowerCase().split("\\s+");

  // 2. Create a set of banned words.
  Set<String> bannedWords = new HashSet();
  for (String word : banned)
    bannedWords.add(word);

  // 3. Create a map of words to their occurrence, excluding the banned words
  Map<String, Integer> wordCount = new HashMap();
  for (String word : words) {
    if (!bannedWords.contains(word))
      wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
  }

  // 4. Return word with the highest number of occurrences from the map.
  return Collections.max(wordCount.entrySet(), Map.Entry.comparingByValue()).getKey();
}

And the same 4 steps in Kotlin.

fun mostCommonWord(paragraph: String, banned: Array<String>): String {
  // 1. Covert string to lower case and split by words.
  val words = paragraph.toLowerCase().split("\\W+|\\s+".toRegex())
  // 2. Create a set of banned words.
  val bannedSet = banned.toHashSet()
  // 3. Create a map of words to their occurrence, excluding the banned words
  val wordToCount = words.filterNot { it in bannedSet }.groupingBy { it }.eachCount()
  // 4. Return word with the highest number of occurrences from the map.
  return wordToCount.maxBy { it.value }!!.key
}

Now let’s go through the functions to see what is happening here.

1. We split the string into 

words: List<String>

banned: Array<String>

HashSet

in

filterNot()

filterNot { it in banned }

List<String>

banned

groupBy()

groupingBy()

Grouping

groupingBy()

eachCount()

Grouping

maxBy()

value

Map.Entry<String, Int>?

ball = 2

Order of elements

When you create a set using 

setOf(“a”, “b”, “c”)

arrayOf(“a”, “b”, “c”).toSet()

LinkedHashSet

The same is true about maps

mapOf(Pair(“a”, 1), Pair(“b”, 2))
arrayOf(Pair(“a”, 1), Pair(“b”, 2)).toMap()

Both functions will return an instance of 

LinkedHashMap

I have covered just a few of all available collection functions in Kotlin. There’s 

map

flatMap

count

find

sum

partition