// Add a Random class plus various 1.2 // features that are not as yet available // in SoloLearn. // Type alias to shorten using Java's // random class. typealias Random = java.util.Random // Class to provide random number support. class RandomNumber { // Companion object to make static // methods. companion object { // Random instance of Java class. private val random = Random() // Random number from 0 to maximum // getting it from the Java instance. fun rand(maximum: Int) = random.nextInt(maximum) // Random number from minimum to maximum. // Calculate the number of possible // integers in the range for the random // lookup and add the minimum to the // result. fun rand(minimum: Int, maximum: Int) = rand(maximum-minimum+1)+minimum // Random number for specified range. // Pass the minimum & maximum of the // range to the random lookup. fun rand(range: IntRange) = rand(range.start, range.endInclusive) // Random number for specified // progression. Calculate the number of // possible integers in the range after // the step for the random lookup, // multiple the result by the step and // add the minimum to it. fun rand(progression: IntProgression) = rand((progression.last- progression.first)/ progression.step+1)* progression.step+ progression.first } // companion } // RandomNumber // Test Random class by calling each method // 5 times. Output for each only has two // values. fun randomTest() { for (loop in 1..5) { print("Random: ${RandomNumber.rand(2)} ") // 0 or 1 print("${RandomNumber.rand(2, 3)} ") // 2 or 3 print("${RandomNumber.rand(4..5)} ") // 4 or 5 println("${RandomNumber.rand(6..8 step 2)}") // 6 or 8 } // for } // randomTest // Extend Iterable with a shuffled method. // Randomly select indexes for the list. If // it is in use, pick the next higher // wrapping around as needed. Once done, // create the new list with the selected // element from the old list. fun Iterable.shuffled(): List { val count = this.count() val list = MutableList(count, {-1}) for (loop in 0 until count) { var index = RandomNumber.rand(0 until count) while (list[index] != -1) index = (index+1)%count list[index] = loop } // for return List(count) { index -> this.elementAt(list[index]) } } // shuffled // Second extension of Iterable with a // shuffled method. Works the same as the // first, but lets the caller provide there // own random instance. Randomly select // indexes for the list. If it is in use, // pick the next higher wrapping around // as needed. Once done, create the new // list with the selected element from the // old list. fun Iterable.shuffled( random: Random): List { val count = this.count() val list = MutableList(count) { -1 } for (loop in 0 until count) { var index = random.nextInt(count) while (list[index] != -1) index = (index+1)%count list[index] = loop } // for return List(count) { index -> this.elementAt(list[index]) } } // shuffled // Test shuffled extension. Get 5 shuffled // results and display them. fun shuffledTest() { val items = (1..5).toList() for (loop in 1..5) { val result = items.shuffled() println("Shuffled: $result") } // for println("Shuffled: "+ "${items.shuffled(Random())}") } // shuffledTest // Extend MutableList with a shuffle function. // Use the shuffled method to get a randomized // list and change the original to match. fun MutableList.shuffle() { val list = this.shuffled() for (loop in 0 until this.size) this[loop] = list[loop] } // shuffle // Second extension of MutableList with a // shuffle method. Works the same as the // first, but lets the caller provide there // own random instance. Use the shuffled // method to get a randomized list and change // the original to match. fun MutableList.shuffle( random: Random) { val list = this.shuffled(random) for (loop in 0 until this.size) this[loop] = list[loop] } // shuffle // Test shuffle extension. Shuffle the list // 5 times. fun shuffleTest() { val items = ('a'..'e').toMutableList() for (loop in 1..5) { items.shuffle() println("Shuffle: $items") } // for items.shuffle(Random()) println("Shuffle: $items") } // shuffleTest // Extend Interable with chunked method. // Figure out the number of outer lists // before creating the result. The inner // lists have the requested size elements // or what is left over. The inner list // contents are the next chunk of the // original list. fun Iterable.chunked( size: Int): List> { var count = this.count() val outer = (count+size-1)/size return List(outer) { index -> List( if (count > size) { count -= size size } else count) { this.elementAt(index*size+it) } } } // chunked // Second extension of Interable with // chunked method. Works the same as the // first, but lets the caller provide // their own transformation. Figure out the // number of lists for the result before // creating it. Create a list having the // requested size elements or what is left // over. This list contents are the next // chunk of the original list and it gets // passed into the transform function to // created the elements of the resultant // list. fun Iterable.chunked(size: Int, transform: (List) -> R): List { var count = this.count() val outer = (count+size-1)/size return List(outer) { index -> transform(List( if (count > size) { count -= size size } else count) { this.elementAt(index*size+it) }) } } // chunked // Triple class for 3D points. data class Point(val x: Int, val y: Int, val z: Int) // Test chunked extension. Output the list // in two different ways. fun chunkedTest() { val items = (1..9).map { it*it } val grouped = items.chunked(4) println("Chunked: $grouped") val points3d = items.chunked(3) { (x, y, z) -> Point(x, y, z) } println("Chunked: $points3d") } // chunkedTest // Extend MutableList to add fill method. // Change each element in the list to the // specified value. fun MutableList.fill(value: T) { for (index in 0 until this.size) this[index] = value } // fill // Test fill extension. Fill the list with // 5 different values each getting displayed. fun fillTest() { val items = MutableList(5) { -1 } for (loop in 5 downTo 1) { items.fill(loop) println("Fill: $items") } // for } // fillTest // Extend Iterable with the windowed method. // Default an empty list and for each // starting point, if there remains enough // elements for the full size of inner list, // create it. Otherwise, if we can have a // partial list, create it with whatever // remains. fun Iterable.windowed( size: Int, inc: Int = 1, partialWindows: Boolean = false): List> { val list = mutableListOf>() for (index in 0 until this.count() step inc) if (this.count()-index >= size) list.add(List(size) { this.elementAt(index+it) }) else if (partialWindows) list.add(List(this.count()-index) { this.elementAt(index+it) }) return list.toList() } // windowed // Second extension of Interable with // windowed method. Works the same as // the first, but lets the caller provide // their own transformation. Default an // empty list and for each starting point, // if there remains enough elements for // the full size of inner list, create it // and call the transformation on it. // Otherwise, if we can have a partial list, // create it with whatever remains and call // the transformation on it. fun Iterable.windowed(size: Int, inc: Int = 1, partialWindows: Boolean = false, transform: (List) -> R): List { val list = mutableListOf() for (index in 0 until this.count() step inc) if (this.count()-index >= size) list.add(transform(List(size) { this.elementAt(index+it) })) else if (partialWindows) list.add(transform( List(this.count()-index) { this.elementAt(index+it) })) return list.toList() } // windowed // Test the windowed extensions. fun windowedTest() { val items = listOf(0, 1, 2, 3, 4, 5, 6) println("Windowed: "+ "${items.windowed(2, 3, true)}") val mult = items.windowed(2, 3, true) { list -> if (list.size == 1) list[0] else list[0]+list[1] } println("Windowed: $mult") val pairs = items.windowed(2, 3) { (a, b) -> Pair(a, b) } println("Windowed: $pairs") println("Windowed: "+ "${items.windowed(3, 2, true)}") println("Windowed: ${items.windowed(3, 2)}") println("Windowed: ${items.windowed(5)}") } // windowedTest // Extend Iterable with zipWithNext method. // Window into number pairs and store into // the result. Note: the window won't return // partially full elements so the list // conversion won't cause an exception. fun Iterable.zipWithNext(): List> { return this.windowed(2, 2) { (first, second) -> Pair(first, second) } } // zipWithNext // Second extension of Interable with // zipWithNext method. Works the same as // the first, but lets the caller provide // their own transformation. Window into // number pairs, transform, and store into // the result. Note: the window won't return // partially full elements so the list // conversion won't cause an exception. fun Iterable.zipWithNext( transform: (a: T, b: T) -> R): List { return this.windowed(2, 2) { (first, second) -> transform(first, second) } } // zipWithNext // Test zipWithNext extension. Display the // paired list and it's usage. Prove odd // number of elements don't throw an // exception. fun zipWithNextTest() { val items = listOf(1, 2, 3, 4, 5) val pairs = items.zipWithNext() val map = items.zipWithNext() {a, b -> a*b} println("ZipWithNext: $pairs") println("ZipWithNext: $map") } // zipWithNextTest // Extend MutableList with a replaceAll // function. For each element in the list, // call the function on it. fun MutableList.replaceAll( func: (v: T) -> Unit) { for (index in 0 until this.size) func(this[index]) } // replaceAll // Test replaceAll extension. Display the // original and updated lists. fun replaceAllTest() { val items = ('a'..'e').toMutableList() println("Replace: $items") items.replaceAll { (it.toInt()+5).toChar() } println("Replace: $items") } // replaceAllTest // Test each extension. fun main(args: Array) { randomTest() shuffledTest() shuffleTest() chunkedTest() fillTest() windowedTest() zipWithNextTest() replaceAllTest() } // main

1.2 Extensions mn