// (c) Copyright 2021 All Rights Reserved. // Permission to copy methods or functions // is granted as long as a link to this // code is included with the copied source. //00000001111111111222222222233333333334444|444445555555555666666666677777777778| //34567890123456789012345678901234567890123|567890123456789012345678901234567890| // Created to provide template for new code // and common methods/functions for reuse. // Sealed class example: // https://code.sololearn.com/cBfX6s2pIDzF // Hamilton Cycle Backtracking available // here: // https://code.sololearn.com/c8D9FEv7Nx85 // Input: nothing for default test cases, // copy some comments on this code and // paste into the prompt for some existing // tests, or an integer between one and // five. // multiple lines of space separated // integers between one and five for a // matrix. // a positive integer. // a space separated list of integers // between one and five. // a string. // a space separated list of strings. // Created for this code golf challenge: // Created for this challenge: // // Import a huge integer for numbers // larger than sixty-four bits. import java.math.BigInteger // Recursive method to extend BigInteger class // with a factorial. tailrec fun BigInteger.factorial( run: BigInteger = BigInteger.ONE): BigInteger = if (this == BigInteger.ONE) run else (this-BigInteger.ONE).factorial(run*this) // Method to extend the BigInteger class with a // filter to verify the user's input. fun BigInteger.filter(range: BigIntegerProgression) = if (this in range) this else throw IllegalArgumentException( "Bad data!") infix fun BigInteger.downTo(last: BigInteger) = BigIntegerProgression(this, last, BigInteger.ONE) operator fun BigInteger.rangeTo(that: BigInteger) = BigIntegerRange(this, that) infix fun BigInteger.until(last: BigInteger) = BigIntegerRange(this, last-BigInteger.ONE) class BigIntegerIterator(val start: BigInteger, val endInclusive: BigInteger) : Iterator { var value = start override fun hasNext() = value <= endInclusive override fun next() = value.also { value++ } } // BigIntegerIterator open class BigIntegerProgression(val first: BigInteger, val last: BigInteger, val step: BigInteger) : Iterator { var number = first operator open fun contains(value: BigInteger): Boolean = if (first > last) value >= last && value <= first && (value-first)%step == BigInteger.ZERO else value <= last && value >= first && (value-first)%step == BigInteger.ZERO override fun hasNext() = if (first > last) number >= last else number <= last override fun next() = number.also { if (first > last) number -= step else number += step } infix fun step(skip: BigInteger) = BigIntegerProgression(first, last, skip) override fun toString() = if (first <= last) "$first..$last step $step" else "$first downTo $last step $step" } // BigIntegerProgression class BigIntegerRange(override val start: BigInteger, override val endInclusive: BigInteger) : BigIntegerProgression(start, endInclusive, BigInteger.ONE), ClosedRange, Iterable { override operator fun contains(value: BigInteger): Boolean = value <= endInclusive && value >= start override fun iterator(): Iterator = BigIntegerIterator(start, endInclusive) override fun toString() = "$start..$endInclusive" } // BigIntegerRange // Method to extend the Double class with an // absolute value. fun Double.abs() = Math.abs(this) // Method to extend Double class with // generating a ceiling as requested. fun Double.ceil() = Math.ceil(this) // Method to extend Double class with // generating a floor as requested. fun Double.floor() = Math.floor(this) // Method to extend Double class with // generating a power as requested. fun Double.pow(exponent: Double) = Math.pow(this, exponent) // Method to extend Double class with // generating a square root as requested. fun Double.sqrt() = Math.sqrt(this) // Method to extend Double class with // generating a square as requested. fun Double.square() = this*this // Method to extend the Int class with an // absolute value. fun Int.abs() = Math.abs(this) // Method to extend Int class with // generating a list of digits. Size is // the number of columns desired. Digits // in only: 1, 2, 3 for 123 fun Int.digits(size: Int = this.size()) = List(size) { this/(10.pow(size-it-1))%10 } // Method to extend Int class with // generating a list of digits. Size is // the number of columns desired. Digits // in correct powers: 100, 20, 3 for 123 fun Int.digitsPower(size: Int = this.size()) = List(size) { this/(10.pow(size-it-1))%10* (10.pow(size-it-1)) } // Recursive method to extend Int class // with a factorial. tailrec fun Int.factorial(current: Int, next: Int = 1): Int = if (this <= 1) current else (this-1).factorial(next, next*this) // Method to extend the Int class with a // filter to verify the user's input. fun Int.filter(range: IntProgression) = if (this in range) this else throw IllegalArgumentException( "Bad data!") // Method to extend Int class with // selecting the larger of both integers. fun Int.max(other: Int) = Math.max(this, other) // Method to extend Int class with // selecting the smaller of both integers. fun Int.min(other: Int) = Math.min(this, other) // Method to extend Int class with // generating a power as requested. fun Int.pow(exponent: Int) = Math.pow(this.toDouble(), exponent.toDouble()).toInt() // Method to extend Int class to return // the number of columns needed to display // the value. fun Int.size() = "$this".length // Method to extend Int class with // generating a square root as requested. fun Int.sqrt() = Math.sqrt(this.toDouble()).toInt() // Recursive method to extend the Int class // with a sum of all numbers from one to // this. Exit cases are all number less than // or equal to one with either that one or // a zero. Otherwise, add this to the sum // for this minus one. fun Int.sum(): Int = if (this == 1) 1 else if (this < 1) 0 else this+(this-1).sum() // Method to extend the Int class with // returning the word display string. // Since we need the words multiple times, // allocate those lists first. Default to // an empty string. fun Int.toWords(): String { val ones = listOf("one", "two", "three", "four", "five", "six", "seven", "eight", "nine") val teens = listOf("ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen") val tens = listOf("twenty", "thirty", "fourty", "fifty", "sixty", "seventy", "eighty", "ninety") var result = "" // Generate the result string for a // period. fun value(number: Int) { // If the period has hundreds, add them // to our result. if (number >= 100) result += ones[number/100%10-1]+ " hundred " // Group the rest of the period into // zero, one to nine, ten to nineteen, // and above. Generate the corresponding // result string. result += ( when { number%100 == 0 -> if (this == 0) "zero " else "" number%100 in 1..9 -> ones[number%10-1]+" " number%100 in 10..19 -> teens[number%100-10]+" " else -> tens[number/10%10-2]+( if (number%10 > 0) "-"+ones[number%10-1] else "")+" " }) } // value // If the number is negative, store that // word in the string and make the number // positive. if (this < 0) result += "negative " val number = this.abs() // Break the number into its periods // starting with billions. For each // period, store its value in the // string and tack on the period name. var period = 1000000000 while (period > 0) { if (number/period > 0 || (this == 0 && period == 1)) { value(number/period%1000) result += ( when (period) { 1000000000 -> "billion " 1000000 -> "million " 1000 -> "thousand " else -> "" }) } // if period /= 1000 } // while // Return our string without any extra // spaces before or after. return result.trim() } // toWords // Method to extend the String class with // capitalizing the string. fun String.capitalize() = "${this[0].toUpperCase()}"+ this.substring(1, this.length). toLowerCase() // Function to return a random number in the // range. fun rand(minimum: Int, maximum: Int) = java.util.Random().nextInt( maximum-minimum+1)+minimum // Function to return a random number in the // range of zero to this integer. fun Int.rand() = java.util.Random().nextInt(this+1) // Function to return a random number in the // range. /* fun rand(range: IntRange) = java.util.Random().nextInt( range.endInclusive-range.start+1)+ range.start */ // Extention method for IntRange to return // a random number for specified range. fun IntRange.rand() = java.util.Random().nextInt( endInclusive-start+1)+start // Extention method for IntProgression to // return a random number for specified // progression. /* fun rand(progression: IntProgression) = java.util.Random().nextInt( (progression.last- progression.first)/ progression.step+1)* progression.step+ progression.first */ // Function to return a random number for // specified progression. fun IntProgression.rand() = java.util.Random().nextInt( (last-first)/step+1)*step+first // Class to provide random number support. class RandomNumber { // Companion object to make static // methods. companion object { // Random instance of Java class. private val random = java.util.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 // Extend the Array class with a shuffle // method to swap random elements three // times for each existing element. Exists // in 1.3 version. fun Array.shuffle() { for (index in 0..this.size*3) { val first = rand(0, this.size-1) val second = rand(0, this.size-1) this[first] = this[second].also { this[second] = this[first] } } // for } // shuffle // Method to extend Array with a sum that // shares both index and value. fun Array.sumByIndexed(selector: ( index: Int, value: T) -> Int): Int { var total = 0 for (index in 0 until count()) total += selector(index, elementAt(index)) return total } // sumByIndexed // Method to extend Iterable class with a // joinToString version to allow passing // index to the transform. fun Iterable.joinIndexedToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Int, T) -> CharSequence)? = null ): String { // Start the result with the prefix. For // each element, add them to the result. var result = "$prefix" for (index in 0 until count()) { // Get the value to display either as // a string or using the transform, // when specified. val value = if (transform == null) "${elementAt(index)}" else { val temp = transform(index, elementAt(index)) "$temp" } // if // Get the separator we need. First // element needs none. The rest need // our normal one. val start = when (index) { 0 -> "" else -> "$separator" } // when // Store our element value and separator // as needed. If we reached our limit, // use our truncated string. If we // are above the limit, use nothing. // Otherwise, use our separator and // value. result += when { index == limit -> "$truncated" limit != -1 && index > limit -> "" else -> "$start$value" } // when } // for // Finish off with the postfix and return // the result. result += "$postfix" return result } // joinIndexedToString // Method to extend Iterable class with a // joinToString version to allow a different // separator before the last element. For // example, listOf(1,2,3) giving 1, 2, and // 3. fun Iterable.joinedToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", last: CharSequence = separator, limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null ): String { // Start the result with the prefix. For // each element, add them to the result. var result = "$prefix" for (index in 0 until count()) { // Get the value to display either as // a string or using the transform, // when specified. val value = if (transform == null) "${elementAt(index)}" else "${transform(elementAt(index))}" // Get the separator we need. First // element needs none. Last element // needs our special last one. The // rest need our normal one. val start = when (index) { 0 -> "" this.count()-1 -> "$last" else -> "$separator" } // when // Store our element value and separator // as needed. If we reached our limit, // use our truncated string. If we // are above the limit, use nothing. // Otherwise, use our separator and // value. result += when { index == limit -> "$truncated" limit != -1 && index > limit -> "" else -> "$start$value" } // when } // for // Finish off with the postfix and return // the result. result += "$postfix" return result } // joinedToString // Extend Iterable with a random method. fun Iterable.random() = elementAt(java.util.Random(). nextInt(count())) // 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 = java.util.Random(). nextInt(count) while (list[index] != -1) index = (index+1)%count list[index] = loop } // for return List(count) { index -> this.elementAt(list[index]) } } // shuffled // Method to extend Iterable with a sum that // shares both index and value. fun Iterable.sumByIndexed(selector: ( index: Int, value: T) -> Int): Int { var total = 0 for (index in 0 until count()) total += selector(index, elementAt(index)) return total } // sumByIndexed // 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. typealias Random = java.util.Random 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 // 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. //typealias Random = java.util.Random fun MutableList.shuffle( random: Random) { val list = this.shuffled(random) for (loop in 0 until this.size) this[loop] = list[loop] } // shuffle // 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 // 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 // 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 // Method to extend Map class with a // joinToString version to allow a different // separator before the last element. For // example, mapOf(1 to 'a', 2 to 'b', 3 to // 'c') giving a, b, and c. fun Map.joinedToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", last: CharSequence = separator, limit: Int = -1, truncated: CharSequence = "...", transform: ((V) -> CharSequence)? = null ): String { // Start the result with the prefix and // we have not seen our limit. For each // element, add them to the result. var result = "$prefix" var flag = false for (key in keys) { // Get the value to display either as // a string or using the transform, // when specified. val value = if (transform == null) "${get(key)}" else "${transform(get(key)!!)}" // Get the separator we need. First // element needs none. Last element // needs our special last one. The // rest need our normal one. val start = when (key) { keys.elementAt(0) -> "" keys.elementAt(keys.size-1) -> "$last" else -> "$separator" } // when // Store our element value and separator // as needed. If we are above the limit, // use nothing. If we reached our limit, // use our truncated string and remember // it. Otherwise, use our separator // and value. result += when { limit != -1 && flag -> "" limit != -1 && key == keys.elementAt(limit) -> { flag = true "$truncated" } // limit else -> "$start$value" } // when } // for // Finish off with the postfix and return // the result. result += "$postfix" return result } // joinedToString // 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 // 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 // Function to calculate the primes into a list. fun primes(size: Int): MutableList { // Make the list empty. For two until // number requested, see if it might be a // prime. val list = MutableList(0) { 0 } outer@ for (value in 2..size) { // For all of the primes seen so far, // if our current value is evenly // divisible by our prime, go on // to the next value. Otherwise, // if the current prime is too big, // we found another prime so exit // this loop. for (element in list) if (value%element < 1) continue@outer else if (element*element > value) break // If our value gets here, it must be // a prime so add it to our list. list.add(value) } // for // Return our primes. return list } // primes // Class to hold a list of primes. Override // the iterator and add a new method. class Primes: ArrayList() { // Method to create an interator over the // list. operator override fun iterator(): MutableIterator = PrimesIterator(this) // Method to return the value of the last // node. fun last(): Int = this[size-1] } // Primes // Class to iterate over our primes. Figure // out the next prime number so there is an // infinite supply. class PrimesIterator(private val self: Primes): MutableIterator { // Method to test for there being another // prime, which there always is. override fun hasNext(): Boolean = true // Method to figure out the next prime, // add it to our list, and return it. override fun next(): Int = // If our list is empty, our first is // two. if (self.size == 0) { self.add(2) 2 // Otherwise, if we returned two, our // second is three. } else if (self.size == 1) { self.add(3) 3 // Otherwise, we can now find it by // processing our last one so do it. } else { // Take the last prime found and // start at the next odd number // looping until a new one is found. var number = self.last()+2 outer@ while (true) { // For each of the primes found so // far, if it divides evenly into // the number, the number can't be // a prime so skip checking the // others. Otherwise, if the prime // is too big to be the smallest // factor of the number, the number // must be a prime. Otherwise, // continue processing the next // prime. for (index in 0 until self.size) { val factor = self[index] if (number%factor == 0) break else if (factor*factor > number) break@outer } // for number += 2 } // while // No factor was found so add the // prime to our list and return it. self.add(number) number } // if // Method to remove last number. Should // never be used. override fun remove() { throw IllegalStateException( "Can not remove a prime!") } // remove } // PrimesIterator // Class to iterate over all permutations of // the values zero to size-1. Properties are // the number of value to permutate, the // index into the remaining elements having // removed any previously used ones, the // values to return next, and our having // returned all possible combinations. class Permutation(val size: Int) : Iterator> { val index = Array(size) { 0 } val value = Array(size) { it } var done = size < 1 // Method to tell whether there is any more // combinations. override fun hasNext() = !done // Method to return the combination we know // about and figure out if there is another. override fun next(): List { // Save the result as a list to return at // the end. Start at the last index to // find what needs changing next. While // the index has reached the end of // possibilities, move to the previous. val result = value.toList() var position = size-1 while (position >= 0 && index[position] == size-1-position) position-- // If we are at the end of all combinations, // we are done. if (position < 0) done = true // Otherwise, figure out our next // combination. else { // Make a list to play with. For all // previous positions that are going // to remain the same, remove the // element they currently have from // the list. val list = MutableList(size) { it } for (element in 0 until position) list.removeAt(index[element]) // Update our position that needs changing // to it's next choice for both the index // & value and remove it from our list. index[position]++ value[position] = list.removeAt(index[position]) // All remainding positions, get reset // to zero and take the first choice // removing it from the list. for (element in position+1 until size) { index[element] = 0 value[element] = list.removeAt(0) } // for } // if // Return our saved list. return result } // next } // Permutation // Class to iterate over unique combinations // of the numbers 0 to size-1 from none // to all. Properties are number of numbers // to use, flag to terminate the iteration, // and list with next value. class Combinations(val size: Int) : Iterator> { var done = size < 1 val list = MutableList(0) { 0 } // Method to stop the iteration. override fun hasNext() = !done // Method to return the next combination. override fun next(): List { // Recursive function to increment to // next combination. If this element // maxed out, recurse to the previous // and set this one to next higher // value. Otherwise, increment this // element. fun increment(level: Int) { if (list[level] == size-( list.size-level)) { increment(level-1) list[level] = list[level-1]+1 } else list[level]++ } // increment // Set the result to the current list. // When the list is empty, put the // first element in. val result = list.toList() when (list.size) { 0 -> list.add(0) // When we got the last, we are done. size -> done = true // Otherwise, if we maxed this number // of elements, reset and add a new one. // Otherwise, start our recursive // increment to the next combination. else -> { if (list[0] == size-list.size) { for (index in 0 until list.size) list[index] = index list.add(list.size) } else increment(list.size-1) } // else } // when return result } // next } // Combinations // Class to iterate over unique combinations // of the numbers 0 to size-1 for the // specified elements. Properties are number // of numbers to use per combination, the // number to return in our combination, flag // to terminate the iteration, and list with // next value. class Combination(val size: Int, val elements: Int) : Iterator> { var done = size < 1 val list = Array(elements) { it } // Method to stop the iteration. override fun hasNext() = !done // Method to return the next combination. override fun next(): List { // Recursive function to increment to // next combination. If this element // maxed out, recurse to the previous // and set this one to next higher // value. Otherwise, increment this // element. fun increment(level: Int) { if (list[level] == size-( list.size-level)) { increment(level-1) list[level] = list[level-1]+1 } else list[level]++ } // increment // Set the result to the current list. // If we maxed this number of elements, // we have no more. Otherwise, start // our recursive increment to the next // combination. val result = list.toList() if (list[0] == size-list.size) done = true else increment(list.size-1) return result } // next } // Combination // Expanded function with comments to process // our code golf challenge. // Function to process our code golf challenge. // Function to display the inputs and outputs // for our code golf challenge. // Main function created for this code golf // challenge. // Class to hide integer based main. class DummyInt { // Function to process our challenge. fun process(test: Int): Int { return 0 } // process // Function to display the inputs and outputs // for our challenge. fun display(test: Int) { println("$test -> ${process(test)}") } // display // Main function created for this challenge // to get one user test case or a list of // default test cases. fun main() { // Try reading the user's integer. Cause an // exception on end of file, non integer, or // out of our supported range. Otherwise, // process it. try { val test = readLine()!!.toInt() if (test !in 1..5) throw IllegalArgumentException( "Bad input!") display(test) // On exception, complain and process our // default test cases. } catch (error: Throwable) { // error.printStackTrace() println("Bad input using defaults!") for (test in listOf(1)) display(test) } // try } // main } // DummyInt // Class to hide integer list based main. class DummyList { // Function to process our challenge. fun process(test: List): Int { return 0 } // process // Function to display the inputs and outputs // for our challenge. fun display(test: List) { println("$test -> ${process(test)}") } // display // Main function created for this challenge // to get the user's list or use our default // test cases. fun main() { // Try reading the user's list of integers. // Cause an exception on end of file, non // integer, or out of our supported range. // Otherwise, process it. try { val test = readLine()!!.split(" ").map { it.toInt() } if (test.size != test.filter { it in 1..5 }.size) throw IllegalArgumentException( "Bad input!") display(test) // On exception, complain and process our // default test cases. } catch (error: Throwable) { // error.printStackTrace() println("Bad input using defaults!") for (test in listOf(listOf(1))) display(test) } // try } // main } // DummyList // Class to hide integer matrix based main. class DummyMatrix { // Function to process our challenge. fun process(test: MutableList>): Int { return 0 } // process // Function to display the inputs and outputs // for our challenge. fun display(test: MutableList>) { println("$test -> ${process(test)}") } // display // Main function created for this challenge // to get the user's matrix or use our // default test cases. fun main() { // Try reading the user's matrix of // integers. Cause an exception on end of // file, non integer, invalid matrix size, // or out of our supported range. // Otherwise, process it. Loop reading // each line as a matrix row. Fill in // missing elements to make all rows the // same size. try { val matrix = mutableListOf>() do { val line = readLine() ?: break val data = line.split(" ").map { it.toInt() } if (data.size != data.filter { it in 1..5 }.size) throw IllegalArgumentException( "Bad data!") matrix.add(MutableList(0) { 0 }) matrix[matrix.size-1].addAll(data) } while (true) if (matrix.size < 2 || matrix.maxBy { it.size }.size < 2) throw IllegalArgumentException( "Bad sizes!") val columns = matrix.maxBy { it.size }.size for (row in matrix) while (row.size < columns) row.add(0) display(matrix) // On exception, complain and process our // default test cases. } catch (error: Throwable) { // error.printStackTrace() println("Bad input using defaults!") for (matrix in listOf(mutableListOf( mutableListOf(0), mutableListOf(0)))) display(matrix) } // try } // main } // DummyMatrix class DummyTestCases { // Function to process our challenge. fun process(test: Int): Int { return 0 } // process // Function to display the input and output // for our challenge. fun display(test: Int) { println("$test -> ${process(test)}") } // display // Main function created for this challenge // to get a list of test cases and process // them. fun main() { // Try reading the user's integer for the // number of test cases followed by the // list of cases (one per line). Cause an // exception on end of file, non integer, // too many lines, or out of our supported // ranges. Otherwise, process it. try { val cases = readLine()!!.toInt() if (cases !in 1..10) throw IllegalArgumentException( "Bad number of cases!") val tests = List(cases) { readLine()!!.toInt() } if (tests.size != tests.filter { it in 1..5 }.size) throw IllegalArgumentException( "Bad test case!") if (readLine() != null) throw IllegalArgumentException( "Extra lines!") for (test in tests) display(test) // On exception, complain and process our // default test cases. } catch (error: Throwable) { // error.printStackTrace() println("Bad input using defaults!") for (test in listOf(1)) display(test) } // try } // main } // DummyTestCases // Class to hide string based main. class DummyString { // Function to process our challenge. fun process(test: String): Int { return 0 } // process // Function to display the inputs and outputs // for our challenge. fun display(test: String) { println("$test -> ${process(test)}") } // display // Main function created for this challenge // to get the user's string or use our // default test cases. fun main() { // Try reading the user's string. Cause an // exception on end of file, or empty // string. Otherwise, process it. try { val test = readLine()!! if (test.length == 0) throw IllegalArgumentException( "Bad input!") display(test) // On exception, complain and process our // default test cases. } catch (error: Throwable) { // error.printStackTrace() println("Bad input using defaults!") for (test in listOf("")) display(test) } // try } // main } // DummyString // Class to hide string list based main. class DummyWords { // Function to process our challenge. fun process(test: List): String { return "" } // process // Function to display the inputs and outputs // for our challenge. fun display(test: List) { println("$test -> ${process(test)}") } // display // Main function created for this challenge // to get the user's words or use our default // test cases. fun main() { // Try reading the user's list of strings. // Cause an exception on end of file, no // data, or single empty data. Otherwise, // process it. try { val test = readLine()!!.split(" ") if (test.size < 1 || test[0].isEmpty()) throw IllegalArgumentException( "Bad input!") display(test) // On exception, complain and process our // default test cases. } catch (error: Throwable) { // error.printStackTrace() println("Bad input using defaults!") for (test in listOf(listOf(""))) display(test) } // try } // main } // DummyWords // Main function showing error and displaying // stack frame. fun main() { try { println("Don't run me!") throw IllegalStateException( "Don't run me!") } catch (error: Throwable) { error.printStackTrace() } // try } // main

Template mi