// Created for this challenge: // https://www.sololearn.com/post/176506 // Base 2 to 26 Numbers // Implement a class that performs unsigned // base 2 to 26 math using the letters in a // string as your numbers. You may not use // built in language features to shortcut // your implementation. For example, your // math must not convert to standard language // types like integer. You may treat upper // and lower case as identical or only deal // with lower. // You should provide a constructor taking a // string for the number and base. The string // format is "digits(base)". The base is a // single letter. Zero (i.e. 'a') is used for // base 26. Two (i.e. 'c') is the smallest // base. Twenty-five is 'z'. The number // should be an empty string on underflow, // divide by zero, or any calculation using // an empty string. Math with numbers using // different bases automatically converts the // smaller to the higher. // You must support methods converting between // bases, comparing two numbers (-1 for less, // 0 for equal, & 1 for greater), addition, // subtraction, multiplication, division, // modulo, and returning the string with base // in the format specified above. When your // language supports it, provide operator // overloading. // You may have external helper functions to // convert between an integer and a string for // dealing with making test cases or displays. // zzz(a)+b(c)=baaa(a) is 17575+1=17576 // sg(z)-ts(u)=ci(z) is 456-398=58 // zz(a)*bababaaabb(c)=zyab(a) is 675*675= // 455625 // Data class to hold the multiplication // resulting value in our times table. data class Value(var tens: Char, var ones: Char) // Class to implement a character based // number that supports multiple bases. // Properties are the digit string and // the base letter. They must be public // so our extensions can access them. class Number(value: String) { val string = value.split("(")[0] val base = if (value.isEmpty()) 'a' else value.split("(")[1][0] // Constructor to verify the parameter // was formatted correctly. For each // index in the string, test the character. // Cause an exception on issues. There must // be four or more characters. The last // three characters must be open // parentheses, base, and close // parentheses. Base is all letters // except 'b'. All the rest must be // letters. Only lowercase letters are // supported. init { if (value.length in 1..3) throw IllegalStateException( "Missing data!") for (index in value.indices) when (index) { value.length-1 -> if (value[index] != ')') throw IllegalStateException( "Missing close!") value.length-2 -> if (value[index] !in 'c'..'z' && value[index] != 'a') throw IllegalStateException( "Invalid base!") value.length-3 -> if (value[index] != '(') throw IllegalStateException( "Missing open!") else -> if (value[index] !in 'a'..'z') throw IllegalStateException( "Invalid digit!") } // when } // init // Class static methods. companion object { // Static method to retrieve the legal // characters for the specified base. private fun getLegal(base: Char): String { var result = "" for (letter in 'a' until ( if (base == 'a') '{' else base)) result += letter return result } // getLegal // Static method to retrieve the // multiplication table for the // specified base. Our map is indexed // by our two character getting // multiplied and returns our two // character result. Our table for // binary would have 4 entries: // { 'a' to { 'a' to "aa", 'b' to "aa" }, // 'b' to { 'a' to "aa", 'b' to "ab" } } private fun getTable(base: Char): MutableMap> { val legal = getLegal(base) val map = mutableMapOf>() // Function to add our first character // to our last result. We are placing // all multiples of first into the // various columns (second being our // current one.) Last holds the // previous column. fun inc(first: Char, second: Char, last: Value): Value { // Get our legal characters making // two copies so our answer is there. // If either digit is zero so is our // answer. Otherwise, toss the // beginning legals to get to our // last ones column we were given // and index to the one we are adding // for our ones column result. Given // binary our legal would be "abab", // if our last was "ab", it's ones // would be 'b' so we drop to "bab". // Our first of 'b' would index to // the 'a'. val legal = getLegal(base).repeat(2) val ones = if (first == 'a' || second == 'a') 'a' else legal.drop(legal.indexOf( last.ones))[ legal.indexOf(first)] // If our ones result is less than // what we started with, we wrapped // around into the second copy of // legals so we need to add the // carry into the tens. Otherwise, // we can keep it the same. Toss // the beginning legals to get to // our last tens column we were // given and index to it or the // next when we got a carry. // Create and return the times // table entry. Continuing the // binary example above, 'a' is // less than 'b' so carry is 1. // Our tens would be 'a' so we // drop nothing for that and one // for the carry, giving "bab" // so 'b' making "ab"+"b"="ba". val carry = if (ones < last.ones) 1 else 0 val tens = legal.drop(legal.indexOf( last.tens)+carry)[0] return Value(tens, ones) } // inc // For each of our legal characters, // create an empty map for it, default // our last times table entry to zero, // and for each of our legal characters, // increment to our next times table // entry and add it to our map. for (first in legal) { map.put(first, mutableMapOf()) var last = Value('a', 'a') for (second in legal) { last = inc(first, second, last) map[first]!!.put(second, last) } // for } // for return map } // getTable // Static method to add two character // lists. Shared code used by inc, plus, // and times methods. The first is // updated by adding the second to it. // Both numbers are in the base specified. // This algorithm was the base that the // inc function of getTable was coded // from. Note the example there works // here. private fun add(first: MutableList, second: MutableList, base: Char) { // Default our carry to none and get // double our legals. Both lists // must be the same size so add // leading zeros to the shorter one. var carry = 0 val legal = getLegal(base).repeat(2) while (first.size < second.size) first.add(0, 'a') while (first.size > second.size) second.add(0, 'a') // For each character from the ones // column down to the highest column, // add the digits in the column from // both numbers and carry, figure // out the new carry, and update the // first number with our result. for (index in first.size-1 downTo 0) { val next = legal.drop(legal.indexOf( first[index])+carry)[ legal.indexOf(second[index])] carry = if (next <= first[index] && (second[index] != 'a' || carry == 1)) 1 else 0 first[index] = next } // for // If we are left with a carry, add // a new column in front of the // number with a one or 'b'. Remove // any leading zeros we added to // our second number. if (carry > 0) first.add(0, 'b') while (second.size > 1 && second[0] == 'a') second.removeAt(0) } // add // Static method to subtract two character // lists. Shared code used by dec, minus, // and div methods. The first is updated // by subtracting the second from it. // Both numbers are in the base specified. // Note the inc function of getTable // example works here. By using the // reversed string our string is "baba" // so incrementing after the drop moves // towards lower characters. private fun subtract( first: MutableList, second: MutableList, base: Char) { // Default our borrow to none, get // double our legals, and make a // reversed copy of it. Both lists // must be the same size so add // leading zeros to the shorter one. var borrow = 0 val legal = getLegal(base).repeat(2) val reverse = legal.reversed() while (first.size < second.size) first.add(0, 'a') while (first.size > second.size) second.add(0, 'a') // For each character from the ones // column down to the highest column, // subtract the digits in the column // of both numbers and borrow, figure // out the new borrow, and update the // first number with our result. for (index in first.size-1 downTo 0) { val next = reverse.drop( reverse.indexOf( first[index])+borrow)[ legal.indexOf(second[index])] borrow = if (next > first[index] || next == first[index] && (first[index] < second[index] || borrow == 1)) 1 else 0 first[index] = next } // for // If we are left with a borrow, we // underflowed so empty our result. // Remove any leading zeros we added // to our both numbers. if (borrow > 0) first.clear() while (first.size > 1 && first[0] == 'a') first.removeAt(0) while (second.size > 1 && second[0] == 'a') second.removeAt(0) } // subtract } // object // Method to increment the number supporting // both operator forms: ++demo or demo++. operator fun inc(): Number { // If the number is junk so is our // answer. if (string.isEmpty()) return Number("") // Generate both character lists and // perform the add. The first is our // number. The second is one. val first = MutableList(string.length) { string[it] } val second = MutableList(1) { 'b' } add(first, second, base) // If we still have a number, add our // base to it, create the new number, and // return it. if (first.size > 0) { first.add('(') first.add(base) first.add(')') } // if return Number(first.joinToString("")) } // inc // Method to decrement the number supporting // both operator forms: --demo or demo--. operator fun dec(): Number { // If the number is junk so is our // answer. if (string.isEmpty()) return Number("") // Generate both character lists and // perform the subtract. The first is our // number. The second is one. val first = MutableList(string.length) { string[it] } val second = MutableList(1) { 'b' } subtract(first, second, base) // If we still have a number, add our // base to it, create the new number, and // return it. if (first.size > 0) { first.add('(') first.add(base) first.add(')') } // if return Number(first.joinToString("")) } // dec // Method to add two numbers supporting a // single operator form: demo+operand. operator fun plus(operand: Number): Number { // If either number is junk so is our // answer. if (string.isEmpty() || operand.string.isEmpty()) return Number("") // If our base and the operand base do // not match, make them both the bigger // base and recurse to perform the math. if (base != operand.base) return ( if (base < operand.base && base != 'a') convert(operand.base).plus(operand) else plus(operand.convert(base))) // Generate both character lists and // perform the add. The first is our // number. The second is the operand. val first = MutableList(string.length) { string[it] } val second = MutableList( operand.string.length) { operand.string[it] } add(first, second, base) // If we still have a number, add our // base to it, create the new number, and // return it. if (first.size > 0) { first.add('(') first.add(base) first.add(')') } // if return Number(first.joinToString("")) } // plus // Method to subtract two numbers supporting // a single operator form: demo-operand. operator fun minus(operand: Number): Number { // If either number is junk so is our // answer. if (string.isEmpty() || operand.string.isEmpty()) return Number("") // If our base and the operand base do // not match, make them both the bigger // base and recurse to perform the math. if (base != operand.base) return ( if (base < operand.base && base != 'a') convert(operand.base).minus(operand) else minus(operand.convert(base))) // Generate both character lists and // perform the subtract. The first is our // number. The second is the operand. val first = MutableList(string.length) { string[it] } val second = MutableList( operand.string.length) { operand.string[it] } subtract(first, second, base) // If we still have a number, add our // base to it, create the new number, and // return it. if (first.size > 0) { first.add('(') first.add(base) first.add(')') } // if return Number(first.joinToString("")) } // minus // Method to multiplying two numbers // supporting a single operator form: // demo*operand. operator fun times(operand: Number): Number { // If either number is junk so is our // answer. if (string.isEmpty() || operand.string.isEmpty()) return Number("") // If our base and the operand base do // not match, make them both the bigger // base and recurse to perform the math. if (base != operand.base) return ( if (base < operand.base && base != 'a') convert(operand.base).times(operand) else times(operand.convert(base))) // Generate the character list for the // second number our operand. Make our // answer a zero the length of our first // number. Get our times table map. val second = MutableList( operand.string.length) { operand.string[it] } val answer = MutableList(string.length) { 'a' } val map = getTable(base) // For each digit in our second number // from our ones column down to our // highest column, multiply it my our // first number and add the result into // our answer. for (index in second.size-1 downTo 0) { // Generate the character list for the // first number and add trailing zeroes // based on which digit of the second // number we are processing. val first = MutableList(string.length) { string[it] } for (position in index until second.size-1) first.add('a') // Default our temporary result for // this digit's multiplication to // zero. For each digit in our first // number from the ones column down // to our highest, lookup the answer // to the two digits multiplaction // in our times table map, change // it into the correct answer based // on our column, and add it to our // temporary result. val temp = MutableList(1) { 'a' } for (position in first.size-1 downTo 0) { val value = map[first[position]]!![ second[index]]!! val element = MutableList(first.size- position+1) { when (it) { 0 -> value.tens 1 -> value.ones else -> 'a' } } add(temp, element, base) } // for // Add our temporary result of this // digit's multiplication to our // answer. add(answer, temp, base) } // for // If our answer is valid, add our base // to it. In either case, generate a new // number to return. if (answer.size > 0) { answer.add('(') answer.add(base) answer.add(')') } // if return Number(answer.joinToString("")) } // times // Method to modulo two numbers supporting // a single operator form: demo%operand. operator fun rem(operand: Number): Number = // If our base and the operand base do // not match, make them both the bigger // base and recurse to perform the math. // Otherwise, our answer is the // remainder of the division calculated // by dividing our number by the // operand, multiplying that by the // operand, and subtracting that from // our number. if (base != operand.base) if (base < operand.base && base != 'a') convert(operand.base).rem(operand) else rem(operand.convert(base)) else this-this/operand*operand // Method to divide two numbers supporting // a single operator form: demo/operand. operator fun div(operand: Number): Number { // Function to test if the first can // be subtracted from the second. If // the shorter string is our first, // it's good. If they are equal, // loop to the last character or the // first non equal character and our // result is the result of that // comparison. fun more(first: MutableList, second: MutableList): Boolean { if (first.size < second.size) { return true } else if (first.size > second.size) { return false } else { var index = 0 while (index < first.size-1 && first[index] == second[index]) index++ return first[index] <= second[index] } // if } // more // If either number is junk so is our // answer. If we try to divide by zero, // our number becomes junk. if (string.isEmpty() || operand.string.isEmpty() || operand == Number("a($base)")) return Number("") // If our base and the operand base do // not match, make them both the bigger // base and recurse to perform the math. if (base != operand.base) return ( if (base < operand.base && base != 'a') convert(operand.base).div(operand) else div(operand.convert(base))) // Generate our second character list for // the operand. Make the first character // list empty. Default our result to // empty. val second = MutableList( operand.string.length) { operand.string[it] } val first = MutableList(0) { string[it] } var result = "" // For each character in the first // number's string, add it to our first // number list, default our count to // zero, subtract our second as many // times as possible counting them, // and append the answer to our result. for (size in 0 until string.length) { first.add(string[size]) var count = 'a' while (more(second, first)) { subtract(first, second, base) count++ } // while result += count } // for // Remove any leading zeroes from our // result and return the new number. while (result.length > 1 && result[0] == 'a') result = result.drop(1) return Number("$result($base)") } // div // Method to compare two numbers supporting // a multiple operator form: demo == // operand (!= < > <= >=) returning -1, 0, 1 // base on the comparison. operator fun compareTo(operand: Number): Int = // If our base and the operand base do // not match, make them both the bigger // base and recurse to perform the // compare. if (base != operand.base) if (base < operand.base && base != 'a') convert(operand.base). compareTo(operand) else compareTo(operand.convert(base)) // Otherwise, the shorter string is // the smaller number. If they are // the same size but empty, they're // equal. If they are not empty, // loop to the last character or the // first non equal character and our // result is the result of that // comparison. else when { string.length < operand.string.length -> -1 string.length > operand.string.length -> 1 string.length == 0 -> 0 else -> { var index = 0 while (index < string.length-1 && string[index] == operand.string[index]) index++ string[index].compareTo( operand.string[index]) } // else } // when // Method to convert a number to a new // base. fun convert(new: Char): Number { // If the base is invalid, throw an // exception. if (new != 'a' && new !in 'c'..'z') throw IllegalStateException( "Invalid base!") // If the number is junk so is our // answer. if (string.isEmpty()) return Number("") // Generate our conversion map and // figure out our new base value in // our old base number. Default our // current number to zero. Default // our temporary for the divisor to // null. Create our empty map. For // each possible character and base, // add a map for the current number // string to the character, if the // character matches our base, update // our temporary to a new number, and // regardless increment our number. var number = Number("a($base)") var temp: Number? = null var map = mutableMapOf() for (character in 'a'..'{') { map.put(number.string, character) if (new == 'a' && character == '{' || new != 'a' && new == character) temp = Number("${number.string}($base)") number++ } // for // Convert our number to our new base. // Save our divisor. Create a new zero // number. Get our original number. // Default our result to zero or empty // based on our original being zero. // While our number is greater than // zero, get the current digit, remove // it from our number, lookup the new // character for our new base, and // add it to our result. Once done, // make a new number in our new base // out of our result. val divisor = temp!! val zero = Number("a($base)") number = this var result = if (number == zero) "a" else "" while (number > zero) { val digit = number%divisor number /= divisor result = map[digit.string]!!+result } // while return Number("$result($new)") } // convert // Method to generate a display string. override fun toString() = if (string.isEmpty()) string else string+"($base)" } // Number // Extend the Number class to return the // base as an integer. fun Number.getBase() = if (base == 'a') 26 else base-'a' // Extend the Number class to convert the // string to an integer. Assumes it is // valid. fun Number.toInt() = string.fold(0, { a, e -> a*getBase()+(e-'a') }) // Function to test the number class. fun main(args: Array) { // Test addition with: zzz(a) + b(c) = // baaa(a), which is: 17575 + 1 = 17576. var first = Number("zzz(a)") println("$first is ${first.toInt()}"+ "(${first.getBase()})") var second = Number("b(c)") println("$second is ${second.toInt()}"+ "(${second.getBase()})") var answer = first+second println("+ $answer is ${answer.toInt()}"+ "(${answer.getBase()})") println() // Test subtraction with: sg(z) - ts(u) = // ci(z), which is: 456 - 398 = 58. first = Number("sg(z)") println("$first is ${first.toInt()}"+ "(${first.getBase()})") second = Number("ts(u)") println("$second is ${second.toInt()}"+ "(${second.getBase()})") answer = first-second println("- $answer is ${answer.toInt()}"+ "(${answer.getBase()})") println() // Test multiplication with: zz(a) * // bababaaabb(c) = zyab(a), which is 675 // * 675 = 455625. first = Number("zz(a)") println("$first is ${first.toInt()}"+ "(${first.getBase()})") second = Number("bababaaabb(c)") println("$second is ${second.toInt()}"+ "(${second.getBase()})") answer = first*second println("* $answer is ${answer.toInt()}"+ "(${answer.getBase()})") println() // Test division with: zzz(a) / st(v) = // bs(a), which is 17575 / 397 = 44. first = Number("zzz(a)") println("$first is ${first.toInt()}"+ "(${first.getBase()})") second = Number("st(v)") println("$second is ${second.toInt()}"+ "(${second.getBase()})") answer = first/second println("/ $answer is ${answer.toInt()}"+ "(${answer.getBase()})") println() // Test modulo with: zzz(a) % st(v) = // ed(a), which is 17575 % 397 = 107. println("$first is ${first.toInt()}"+ "(${first.getBase()})") println("$second is ${second.toInt()}"+ "(${second.getBase()})") answer = first%second println("% $answer is ${answer.toInt()}"+ "(${answer.getBase()})") println() // Test compare, convert, decrement, and // increment. zzz(a) == bsrt(v) [0], zzz(a) // < bsru(v) [-1], zzz(a) > bsrs(v) [1], // and converting zzz(a) is bsrt(v) is // ckna(t). Used increment and decrement // to change second number for compares. second = Number("bsrt(v)") println("$first ? $second ["+ "${second.convert('a')}] "+ "${first.compareTo(second)}") second++ println("$first ? ++ $second ["+ "${second.convert('a')}] "+ "${first.compareTo(second)}") second-- second-- println("$first ? -- $second ["+ "${second.convert('a')}] "+ "${first.compareTo(second)}") answer = first.convert('v') println("$first is $answer") println("$answer is ${answer.convert('t')}") } // main

base ch