// Input: nothing for default test cases, // code comments listing examples, or one // or more lines correctly formatted (see // rules listed 55 to 68 and meanings listed // 70 to 86.) // Created for this challenge: // https://www.sololearn.com/post/164163 // In Abap - the language for SAP-Systems - // one can describe a range of numbers with // an object/list of four fields: // sign option low high // sign is I or E means Including/Excluding. // option has many opportunities, we might // take EQ like equal, BT like between GT > // or LT <. // low and high are the boundaries. // If option is EQ or GT or LT high may not // be filled or ignored. // Now given a domain 1 to 1000... or as u // want 95, 96 maybe // I EQ 95; // I EQ 96 // or // I BT 95 96 // A bit more // 5,6....12, 14,15,...18,20,...900 // I GT 4 // I LT 901 // E EQ 13 // E EQ 19 // easy challenge: user enters 3 lines like: // I BT 3 11 // as one line example and the progs output // are the numbers: 3, 4, ... 10, 11 // for runaways: User enters a set of numbers // within the domain and the prog tries to // describe the set with the given Syntax but // as little lines as possible. // My rules: // - lines have three or four space separated // fields for sign, option, low, & high in // this order high being optional, // - character case is ignored, // - high field can only be specified for BT // command, // - sign field can only be E or I, // - option field can only be BT, EQ, GE, GT, // LE, or LT, // - low & high fields must be zero to 1000, // - high must be greater or equal to low, // and // - command order has no effect so the // meaning is the same regardless of order. // Meanings: // - sign of I means include specified values, // - sign of E means exclude specified values, // - option of BT means values between low // and high, // - option of EQ means the low value, // - option of GE means values between low // and 1000 or first existing value found, // - option of GT means values above low to // 1000 or first existing value found, // - option of LE means values between low // and 0 or first existing value found, // - option of LT means values below low to // 0 or first existing value found, and // - if a command uses 0 or 1000 to terminate // their range, those values will be removed // if a later command would have stopped it. // Examples: // Input: // I GT 4 // I LT 901 // E EQ 13 // E EQ 19 // Actions: // Add 5 to 1000 into set. // Detecting the default 1000 of previous // command so remove 901 to 1000 from set. // Remove 13 from set. // Remove 19 from set. // Output: // 5 to 12, 14 to 18, 20 to 900 // Input: // I GT 905 // I LT 5 // Actions: // Add 906 to 1000 into set. // Add 4 to 0 into set. // Output: // 0 to 4, 906 to 1000 // Input: // I EQ 3 // I LT 10 // Actions: // Add 3 into set. // Add 9 to 4 (stopping at the 3) into set. // Output: // 3 to 9 // Input: // I LT 10 // I EQ 3 // Actions: // Add 9 to 0 into set. // Detecting the default 0 of previous // command so remove 0 to 2 from set. // Output: // 3 to 9 // Input: // I LT 51 // E LT 20 // Actions: // Add 50 to 0 into set. // Detecting the default 0 of previous // command so remove 0 to 19 from set. // Output: // 20 to 50 // Enumerate class for our sign: exclude // the values or include the values. enum class Sign { EXCLUDING, INCLUDING; // Method to generate the display string. override fun toString() = if (this == EXCLUDING) "E" else "I" } // Sign // Enumerate class for our option: between, // equal, greater or equal, greater than, // less or equal, and less than. enum class Option { BT, EQ, GE, GT, LE, LT } // Data class to hold the command. data class Command(val sign: Sign, val option: Option, val low: Int, val high: Int) { // Method to generate the display string. override fun toString() = "$sign $option $low"+ if (option == Option.BT) " $high" else "" } // Command // Function to generate an integer to sort // the command by. Forcing the commands into // a known order makes it easier to solve. // Sorting order by option of equal, low, // sign (include first), and option // (reverse alphabetical except equal.) fun value(command: Command) = (command.low+10+ when (command.option) { Option.BT -> 0 Option.EQ -> 11000 Option.GE -> 4 Option.GT -> 3 Option.LE -> 2 Option.LT -> 1 }+ // when when (command.sign) { Sign.EXCLUDING -> 9 Sign.INCLUDING -> 0 }) // when // Function to process our challenge. Make // a mutable copy of our commands and // an empty set of numbers. fun process(test: List) { val commands = MutableList(test.size) { test[it] } val numbers = mutableSetOf() // Function to output the results of our // commands. If none, say so. Otherwise, // default our first & last to force our // initial number to display and remember // we haven't started a range. Sort our // numbers set. For each number, decide // which gets displayed. Once done, if // we were processing a range, display // the finish of it and always display // the end of lines. Our loop decision // tests to see if the current number // is one bigger than the last one. If // not, our number needs displaying so // if we had a range going, finish it // off (a range of two lists them) and // note it was dealt with, prior to // displaying our number. If we are // one bigger, we now have a range so // note it. In all cases remember the // number so we can detect or continue // the range. fun display() { if (numbers.size == 0) print("none") else { var first = -2 var last = -2 var to = false val list = numbers.sortedBy { it } for (index in list) { if (last+1 != index) { if (to) { to = false if (first+1 == last) print(", $last") else print(" to $last") } // if print( (if (index == list[0]) "" else ", ")+"$index") first = index } else to = true last = index } // for if (to) print(" to $last") } // if println("\n") } // display // Sort our commands and for each of them // decide how it should be processed. commands.sortBy { value(it) } for (current in commands.indices) // When between, grab the range and if // including, add them, else remove // them. when (commands[current].option) { Option.BT -> { val high = commands[current].high val low = commands[current].low if (commands[current].sign == Sign.INCLUDING) numbers.addAll((low..high).toList()) else numbers.removeAll((low..high). toList()) } // BT // When equal, grab the range and if // including, add it, else remove it. Option.EQ -> { val high = commands[current].low val low = commands[current].low if (commands[current].sign == Sign.INCLUDING) numbers.addAll((low..high).toList()) else numbers.removeAll((low..high). toList()) } // EQ // When greater equal, grab our lower // bounds and our upper ends at 1000, // when there isn't another coomand, // else just before it's lower. If // including, add our range, else // remove it. Option.GE -> { val low = commands[current].low val high = if (current == commands.size-1) 1000 else when (commands[current+1]. option) { Option.GT -> commands[current+1].low else -> commands[current+1].low-1 } // when if (commands[current].sign == Sign.INCLUDING) numbers.addAll((low..high).toList()) else numbers.removeAll((low..high). toList()) } // GE // When greater than, grab our lower // bounds and our upper ends at 1000, // when there isn't another coomand, // else just before it's lower. If // including, add our range, else // remove it. Option.GT -> { val low = commands[current].low+1 val high = if (current == commands.size-1) 1000 else when (commands[current+1]. option) { Option.GT -> commands[current+1].low else -> commands[current+1].low-1 } // when if (commands[current].sign == Sign.INCLUDING) numbers.addAll((low..high).toList()) else numbers.removeAll((low..high). toList()) } // GT // When less equal, grab our upper // bounds and our lower ends at zero, // when we are the first coomand, // else just before the previous's // upper. If including, add our range, // else remove it. Option.LE -> { val high = commands[current].low val low = if (current == 0) 0 else when (commands[current-1]. option) { Option.BT -> commands[current-1].high+1 Option.GT -> commands[current-1].low+2 else -> commands[current-1].low+1 } // when if (commands[current].sign == Sign.INCLUDING) numbers.addAll((low..high).toList()) else numbers.removeAll((low..high). toList()) } // LE // When less than, grab our upper // bounds and our lower ends at zero, // when we are the first coomand, // else just before the previous's // upper. If including, add our range, // else remove it. Option.LT -> { val high = commands[current].low-1 val low = if (current == 0) 0 else when (commands[current-1]. option) { Option.BT -> commands[current-1].high+1 Option.GT -> commands[current-1].low+2 else -> commands[current-1].low+1 } // when if (commands[current].sign == Sign.INCLUDING) numbers.addAll((low..high).toList()) else numbers.removeAll((low..high). toList()) } // LT } // when // Display our numbers. display() } // process // Function to display the inputs for our // challenge and process it. fun display(test: List) { for (command in test) println(command) process(test) } // display // Function to convert input command string // to our data class. On error, return null. fun verify(input: String): Command? { // Split our string into fields. If we // don't have our three required fields // or our sign is invalid, sign is null. // Otherwise, it is our enumerate. val data = input.split(" ") val sign = if (data.size < 3) null else when (data[0].toUpperCase()) { "E" -> Sign.EXCLUDING "I" -> Sign.INCLUDING else -> null } // when // If we don't have our three required // fields or our option is invalid, // option is null. Otherwise, it is our // enumerate. val option = if (data.size < 3) null else when (data[1].toUpperCase()) { "BT" -> Option.BT "EQ" -> Option.EQ "GE" -> Option.GE "GT" -> Option.GT "LE" -> Option.LE "LT" -> Option.LT else -> null } // when // If we don't have our three required // fields or our low is invalid, low // is null. Otherwise, it is the integer. val low = if (data.size < 3) null else data[2].toIntOrNull() // If we don't have four fields or our // high is invalid, high is null. // Otherwise, it is the integer. val high = if (data.size < 4) null else data[3].toIntOrNull() // Return null when we had too many fields, // the required sign, option, or low is // null, low is out of range, high is not // null and out of range, high is null & // option is between making high required, // high was specified & shouldn't be (all // other options), or high was specified // & less than low. Otherwise, return the // valid command. return ( if (data.size > 4 || sign == null || option == null || low == null || low !in 0..1000 || high ?: 0 !in 0..1000 || high == null && option == Option.BT || data.size > 3 && option != Option.BT || high ?: low < low) null else Command(sign, option, low, if (high == null) low else high)) } // verify // Main function created for this challenge. fun main(args: Array) { // Try reading the user's list of commands. // Cause an exception on end of file, no // data, non integer, incorrect field // value, or no command. Otherwise, // process them. try { val list = mutableListOf() while (true) { val input = readLine() ?: break if (input.isEmpty()) break val data = verify(input) if (data == null) throw IllegalArgumentException( "Bad command!") list.add(data) } // while if (list.size == 0) throw IllegalArgumentException( "Bad input!") display(list) // On exception, complain and process our // test cases. Use strings so it is // readable and ignore null as they won't // happen. } catch (error: Throwable) { println("Bad input using defaults!") // error.printStackTrace() for (test in listOf( listOf( verify("I GT 4")!!, verify("I LT 901")!!, verify("E EQ 13")!!, verify("E EQ 19")!!), listOf( verify("I BT 3 11")!!), listOf( verify("I EQ 95")!!, verify("I EQ 96")!!), listOf( verify("I GT 905")!!, verify("I LT 5")!!), listOf( verify("I LT 51")!!, verify("E LT 20")!!))) display(test) } // try } // main

abap ch