chore(*): use kotlin 1.2.41 and style code according to kotlin guidelines

Author: bmaslakov

build.gradle

@@ -4,7 +4,7 @@ apply plugin: 'kotlin'
 apply plugin: 'jacoco'
 
 buildscript {
-    ext.kotlin_version = '1.1.2-2'
+    ext.kotlin_version = '1.2.41'
 
     repositories {
         mavenCentral()

src/main/io/uuddlrlrba/ktalgs/datastructures/IndexedPriorityQueue.kt

@@ -139,20 +139,20 @@ class IndexedPriorityQueue<T>(size: Int, val comparator: Comparator<T>? = null)
     }
 
     private fun less(x: T, y: T): Boolean {
-        if (comparator != null) {
-            return comparator.compare(x, y) < 0
+        return if (comparator != null) {
+            comparator.compare(x, y) < 0
         } else {
             val left = x as Comparable<T>
-            return left < y
+            left < y
         }
     }
 
     private fun greater(x: T, y: T): Boolean {
-        if (comparator != null) {
-            return comparator.compare(x, y) > 0
+        return if (comparator != null) {
+            comparator.compare(x, y) > 0
         } else {
             val left = x as Comparable<T>
-            return left > y
+            left > y
         }
     }
 
@@ -172,7 +172,7 @@ class IndexedPriorityQueue<T>(size: Int, val comparator: Comparator<T>? = null)
         var k = n
         while (k > 1 && greater(k / 2, k)) {
             exch(k, k / 2)
-            k = k / 2
+            k /= 2
         }
     }
 

src/main/io/uuddlrlrba/ktalgs/datastructures/tree/BinarySearchTree.kt

@@ -62,12 +62,10 @@ class BinarySearchTree<K: Comparable<K>, V>: Map<K, V> {
     override fun get(key: K): V? {
         var x = root
         while (x != null) {
-            if (key < x.key) {
-                x = x.left
-            } else if (key > x.key) {
-                x = x.right
-            } else {
-                return x.value
+            x = when {
+                key < x.key -> x.left
+                key > x.key -> x.right
+                else -> return x.value
             }
         }
         return null
@@ -87,12 +85,10 @@ class BinarySearchTree<K: Comparable<K>, V>: Map<K, V> {
 
     private fun add(key: K, value: V, x: Node<K, V>?): Node<K, V> {
         if (x == null) return Node(key, value)
-        if (key < x.key) {
-            x.left = add(key, value, x.left)
-        } else if (key > x.key) {
-            x.right = add(key, value, x.right)
-        } else {
-            x.value = value
+        when {
+            key < x.key -> x.left = add(key, value, x.left)
+            key > x.key -> x.right = add(key, value, x.right)
+            else -> x.value = value
         }
         x.size = size(x.left) + size(x.right) + 1
         return x
@@ -104,25 +100,23 @@ class BinarySearchTree<K: Comparable<K>, V>: Map<K, V> {
 
     private fun remove(key: K, root: Node<K, V>?): Node<K, V>? {
         var x: Node<K, V> = root ?: throw NoSuchElementException()
-        if (key < x.key) {
-            x.left = remove(key, x.left)
-        } else if (key > x.key) {
-            x.right = remove(key, x.right)
-        } else {
-            if (x.left == null) return x.right
-            if (x.right == null) return x.left
-            val tmp = x
-            x = pollMin(tmp.right!!)!!
-            x.right = min(tmp.right)
-            x.left = tmp.left
+        when {
+            key < x.key -> x.left = remove(key, x.left)
+            key > x.key -> x.right = remove(key, x.right)
+            else -> {
+                if (x.left == null) return x.right
+                if (x.right == null) return x.left
+                val tmp = x
+                x = pollMin(tmp.right!!)!!
+                x.right = min(tmp.right)
+                x.left = tmp.left
+            }
         }
-        x.size = size(x.left) + size(x.right) + 1;
+        x.size = size(x.left) + size(x.right) + 1
         return x
     }
 
-    private fun size(x: Node<K, V>?): Int {
-        if (x == null) return 0 else return x.size
-    }
+    private fun size(x: Node<K, V>?): Int = x?.size ?: 0
 
     fun height(): Int {
         return height(root)

src/main/io/uuddlrlrba/ktalgs/geometry/SierpinskiTriangle.kt

@@ -43,7 +43,7 @@ class SierpinskiTriangle {
         }
     }
 
-    fun drawTriangles(arr: Array<BooleanArray>, top: Int, left: Int, bottom: Int, right: Int): Unit {
+    fun drawTriangles(arr: Array<BooleanArray>, top: Int, left: Int, bottom: Int, right: Int) {
         val height = bottom - top
         val width = right - left
         for (i in 0..height) {

src/main/io/uuddlrlrba/ktalgs/graphs/BFS.kt

@@ -26,21 +26,21 @@ import io.uuddlrlrba.ktalgs.datastructures.Queue
 
 class BFS {
     companion object Implementations {
-        fun iterative(graph: Graph, levelorder: ((Int) -> Unit)? = null) {
+        fun iterative(graph: Graph, levelOrder: ((Int) -> Unit)? = null) {
             val visited = BooleanArray(graph.V)
             val queue = Queue<Int>()
-            for (i in 0..graph.V - 1) {
+            for (i in 0 until graph.V) {
                 if (!visited[i]) {
                     queue.add(i)
                     visited[i] = true
-                    levelorder?.invoke(i)
+                    levelOrder?.invoke(i)
                     while (!queue.isEmpty()) {
                         val v = queue.poll()
                         for (w in graph.adjacentVertices(v)) {
                             if (!visited[w]) {
                                 queue.add(w)
                                 visited[w] = true
-                                levelorder?.invoke(i)
+                                levelOrder?.invoke(i)
                             }
                         }
                     }

src/main/io/uuddlrlrba/ktalgs/graphs/DFS.kt

@@ -31,7 +31,7 @@ class DFS {
                       postorder: ((Int) -> Unit)? = null) {
             val visited = IntArray(graph.V)
             val queue = Stack<Int>()
-            for (i in 0..graph.V - 1) {
+            for (i in 0 until graph.V) {
                 if (visited[i] == 0) {
                     queue.push(i)
                     visited[i] = 1

src/main/io/uuddlrlrba/ktalgs/graphs/Graph.kt

@@ -27,7 +27,5 @@ interface Graph {
     public var E: Int
     public fun adjacentVertices(from: Int): Collection<Int>
 
-    public fun vertices(): IntRange {
-        return 0..V-1
-    }
-}
+    public fun vertices(): IntRange = 0 until V
+}

src/main/io/uuddlrlrba/ktalgs/graphs/directed/weighted/Dijkstra.kt

@@ -43,7 +43,7 @@ class Dijkstra(graph: DWGraph, val from: Int) {
     private val pq: IndexedPriorityQueue<Double> = IndexedPriorityQueue(graph.V)
 
     init {
-        if (graph.edges().filter { it.weight < 0 }.isNotEmpty()) {
+        if (graph.edges().any { it.weight < 0 }) {
             throw IllegalArgumentException("there is a negative weight edge")
         }
 

src/main/io/uuddlrlrba/ktalgs/graphs/undirected/weighted/BoruvkaMST.kt

@@ -50,7 +50,7 @@ class BoruvkaMST(G: UWGraph): MST {
             }
 
             // add newly discovered edges to MST
-            for (i in 0..G.V - 1) {
+            for (i in 0 until G.V) {
                 val e = closest[i]
                 if (e != null) {
                     val v = e.v

src/main/io/uuddlrlrba/ktalgs/search/BinarySearch.kt

@@ -28,12 +28,10 @@ class BinarySearch<T: Comparable<T>>: AbstractSearchStrategy<T>() {
         var hi = arr.size - 1
         while (lo <= hi) {
             val mid = (lo + hi) / 2
-            if (element < arr[mid]) {
-                hi = mid - 1
-            } else if (element > arr[mid]) {
-                lo = mid + 1
-            } else {
-                return mid
+            when {
+                element < arr[mid] -> hi = mid - 1
+                element > arr[mid] -> lo = mid + 1
+                else -> return mid
             }
         }
         return -1

src/main/io/uuddlrlrba/ktalgs/sorts/BubbleSort.kt

@@ -37,7 +37,7 @@ class BubbleSort : AbstractSortStrategy() {
         var exchanged: Boolean
         do {
             exchanged = false
-            for (i in 1..arr.size - 1) {
+            for (i in 1 until arr.size) {
                 if (arr[i] < arr[i - 1]) {
                     arr.exch(i, i - 1)
                     exchanged = true

src/main/io/uuddlrlrba/ktalgs/sorts/InsertionSort.kt

@@ -31,7 +31,7 @@ package io.uuddlrlrba.ktalgs.sorts
 @StableSort
 class InsertionSort: AbstractSortStrategy() {
     override fun <T : Comparable<T>> perform(arr: Array<T>) {
-        for (i in 1..arr.size - 1) {
+        for (i in 1 until arr.size) {
             for (j in i downTo 1) {
                 if (arr[j - 1] < arr[j]) break
                 arr.exch(j, j - 1)

src/main/io/uuddlrlrba/ktalgs/sorts/MergeSort.kt

@@ -50,14 +50,11 @@ class MergeSort: AbstractSortStrategy() {
         var i = lo
         var j = mid + 1
         for (k in lo..hi) {
-            if (i > mid) {
-                arr[k] = aux[j++]
-            } else if (j > hi) {
-                arr[k] = aux[i++]
-            } else if (aux[j] < aux[i]) {
-                arr[k] = aux[j++]
-            } else {
-                arr[k] = aux[i++]
+            when {
+                i > mid -> arr[k] = aux[j++]
+                j > hi -> arr[k] = aux[i++]
+                aux[j] < aux[i] -> arr[k] = aux[j++]
+                else -> arr[k] = aux[i++]
             }
         }
     }

src/main/io/uuddlrlrba/ktalgs/sorts/SelectionSort.kt

@@ -36,7 +36,7 @@ class SelectionSort : AbstractSortStrategy() {
     public override fun<T : Comparable<T>> perform(arr: Array<T>) {
         for (i in arr.indices) {
             var min = i
-            for (j in i+1..arr.size-1) {
+            for (j in i + 1 until arr.size) {
                 if (arr[j] < arr[min]) {
                     min = j
                 }

src/main/io/uuddlrlrba/ktalgs/sorts/ShellSort.kt

@@ -40,7 +40,7 @@ class ShellSort : AbstractSortStrategy() {
         }
 
         while (h >= 1) {
-            for (i in h..arr.size - 1) {
+            for (i in h until arr.size) {
                 for (j in i downTo h step h) {
                     if (arr[j - h] < arr[j]) break
                     arr.exch(j, j - h)

src/main/io/uuddlrlrba/ktalgs/substring/KMP.kt

@@ -12,7 +12,7 @@ class KMP(val pat: String) {
         var x = 0
         var j = 1
         while (j < m) {
-            for (c in 0..R - 1) {
+            for (c in 0 until R) {
                 dfa[c][j] = dfa[c][x]        // Copy mismatch cases.
             }
             dfa[pat[j].toInt()][j] = j + 1   // Set match case.