// Input: nothing for default test cases, // there are comments with existing data // that can be copied & pasted in the prompt, // or a resistor. There are three types of // resistors: parallel, series, and single. // The parallel is a comma separated list of // resistors enclosed in braces. The Series // is a comma separated list of resistors // enclosed in parentheses. The single // is a single positive integer. The lists // are limited to three elements. The // maximum depth of nesting those lists is // also three. Note: too wide a display // wraps unevenly so it is difficult to // understand. // Created for this challenge: // https://www.sololearn.com/post/407721 // Series and Parallel Resistor // Read a circuit specification provided by // the user. Draw the resulting circuit and // specify the total ohms rounding to three // significant digits using the letter that // provides the range (e.g. 0.000001 is // L001, 1.23 is 1R23.) Naming resistance // from here: // https://en.m.wikipedia.org/wiki/RKM_code // You can optionally show the calculations. // You must handle groupings of three // resistors in series, such as (1,2,3) // for a total of 6, or parallel, such as // [1,2,3] for a total of 0.55. Each of // these resistors could be a nested group // limited to a depth of three, for a // possible maximum of 27 resistors in the // circuit: // ( ( ( 1, 2, 3), [ 4, 5, 6], ( 7, 8, 9) ), // [ (10,11,12), [13,14,15], (16,17,18) ], // ( (19,20,21), [22,23,24], (25,26,27) ) ) // To calculate the total, there are two // formulas: parallel and series. Start at // the deepest nesting level and work your // way up. See my examples below for the // formula usage. The formula of series // resistors is: // r = r1 + r2 + r3 // For psrallel, the formula is: // 1/r = 1/r1 + 1/r2 + 1/r3 // You may choose your own input format as // long as you provide comments explaining // how to use it and provide my example // inputs in your format. I ignore spaces, // but require the input to be on a single // line. // You may choose your own output format as // long as the output is obvious as to what // circuit is being shown. Showing the // calculations is optional. The picture // has examples in my choices. // Note: the drawing part is new, while the // calculation of total was posted here: // https://www.sololearn.com/post/159065 // Input: // (8, [6, 12]) // Calculation: // [6, 12] = // (1 / 6) + (1 / 12) = (1 / 4) // becomes 4 // (8, [6, 12]) = // (8, 4) = // 8 + 4 = 12 // Output: // 6R // +--~~~~--+ // 8R | 12R | // o--~~~~--+--~~~~--+--o 12R // Input: // [(11, [(1, 5), 12]), (3, 7)] // Calculation: // (1, 5) = // 1 + 5 = 6 // [(1, 5), 12] = // [6, 12] = // (1 / 6) + (1 / 12) = (1 / 4) // becomes 4 // (11, [(1, 5), 12]) = // (11, 4) = // 11 + 4 = 15 // (3, 7) = // 3 + 7 = 10 // [(11, [(1, 5), 12]), (3, 7)] = // [15, 10] = // 1 / 15 + 1 / 10 = 1 / 6 // becomes 6 // Output: // 1R 5R // +--~~~~--~~~~--+ // 11R | 12R | // +--~~~~--+--~~~~--------+--+ // | 3R 7R | // o--+--~~~~--~~~~--------------+--o 6R // Method to extend Int class with selecting // the larger of both integers. fun Int.max(other: Int) = Math.max(this, other) // Class to provide fractional math. Math // hints used from here: // https://medium.com/i-math/the-no-nonsense-straightforward-da76a4849ec // Properties are the denominator and // numerator. class Fraction() { private var denominator = 1L private var numerator = 0L // Class static properties are the map of // denominators to factors and list of // prime numbers. companion object { private val map = mutableMapOf>() private val primes = mutableListOf(2L, 3L) // Static method to return the list of // factors for the denominator to // simplify the fraction. They are // created once and stored in the map // for reuse. private fun factors(value: Long) = // If the map does not exist, // create it. if (map[value] == null) { // Default our list to first // factor, clone our value, // make sure we have all the // primes we need, and for // each prime, see if it is // a factor. val list = mutableListOf(1L) var remainder = value setup(value) outer@ for (prime in primes) // For each time this prime // goes into our value, add // it to our list, remove it // from our value, and, if // nothing remains, abort // our outer loop. while (remainder%prime == 0L) { list.add(prime) remainder /= prime if (remainder == 1L) break@outer } // while // Convert to immutable list, // store it in the map, and // return it. val result = list.toList() map[value] = result result // Otherwise, the map exists so // return the list. } else map[value]!! // Static method to update the list of // primes for the factor method to use. private fun setup(size: Long) { // For the odd only range of next // possible prime to our end point, // find them all that might divide // evenly into our end point. outer@ for (value in primes[primes.size-1]+ 2L..size step 2L) // If this number is too big to be // used, we have them all so exit // our loop. if (value*value >= size) break // Otherwise, see if it is a prime. // For each prime, if it divides // evenly into our possible, it can // not be prime so skip to the next // one. If we run out of primes or // the prime is too big to be used, // the possible is a definite so // exit the loop and add it to our // primes. else { for (prime in primes) if (value%prime == 0L) continue@outer else if (prime*prime > value) break primes.add(value) } // if } // setup } // object // Constructor to set the fraction with // its creation. constructor(value: Long, morsel: Long = 1L) : this() { update(value, morsel) } // constructor // Operator method to compare fractions. // Basically, short cut the make the // denominators the same with only // calculating the numerator part. operator fun compareTo(operand: Fraction): Int { val our = numerator*operand.denominator val their = denominator*operand.numerator return ( when { our < their -> -1 our > their -> 1 else -> 0 }) } // compareTo // Operator method to destructure our // class to return the numerator. operator fun component1() = numerator // Operator method to destructure our // class to return the denominator. operator fun component2() = denominator // Operator method to perform division. // Invert the operand and multiply. operator fun div(operand: Fraction) = times(Fraction(operand.denominator, operand.numerator)) // Method to test for equals. If the // operand is a fraction, see if it // compares as equal. Otherwise, it // does not. override fun equals(operand: Any?) = if (operand is Fraction) compareTo(operand) == 0 else false // Operator method to perform subtraction. // Change both to a common denominator // prior to performing the subtraction. operator fun minus(operand: Fraction) = Fraction(numerator*operand.denominator -operand.numerator*denominator, denominator*operand.denominator) // Operator method to perform addition. // Change both to a common denominator // prior to performing the addition. operator fun plus(operand: Fraction) = Fraction(numerator*operand.denominator +operand.numerator*denominator, denominator*operand.denominator) // Method to remove any factor in both // numerator and denominator simplifying // the fraction. private fun simplify() { for (factor in factors(denominator)) if (numerator%factor == 0L) { numerator /= factor denominator /= factor } // if } // simplify // Operator method to perform // multiplication. Multiply both // numerators together to get the // resulting numerator. Do the same with // the denominators. operator fun times(operand: Fraction) = Fraction(numerator*operand.numerator, denominator*operand.denominator) // Method to return a double. fun toDouble() = numerator.toDouble()/ denominator.toDouble() // Method to generate an ohms display // string. The letter replaces the decimal // point. L (thousandths period) is used // for 0.000,001 (L001) to below 1 (999L) // values. R (ones) is used for 1.0 (1R) // to below 1,000 (999R) values. K // (thousands) is used for 1,000 (1K) to // below 1,000,000 (999K) values. M // (millions) is used for 1,000,000 (1M) // to below 1,000,000,000 (999M). While // G (billions) and T (trillions) are // defined, I am not supporting them. All // values are limited to the three most // significant digits, ignoring // fractional trailing zeroes. Based on: // https://en.m.wikipedia.org/wiki/RKM_code fun toOhms(): String { val ints = "%.4f".format(toDouble()). replace(Regex("^0[.]|[.]"), ""). substring(0..3).map { it-'0' } val digits = Array(4) { ints[it] } if (digits[3] > 5) { digits[3] = 0 if (digits[2] == 9) { digits[2] = 0 if (digits[1] == 9) { digits[1] = 0 digits[0]++ } else digits[1]++ } else digits[2]++ } // if return ( when { toDouble() == 0.0 -> "0R" toDouble() < 0.001 -> ("L${digits[0]}${digits[1]}"+ "${digits[2]}").trim { it == '0' } toDouble() < 0.01 -> "${digits[0]}L"+("${digits[1]}"+ "${digits[2]}").trim { it == '0' } toDouble() < 0.1 -> "${digits[0]}${digits[1]}L"+ "${digits[2]}".trim { it == '0' } toDouble() < 1.0 -> ("${digits[0]}${digits[1]}"+ "${digits[2]}L").trim { it == '0' } toDouble() < 10.0 -> "${digits[0]}R"+("${digits[1]}"+ "${digits[2]}").trim { it == '0' } toDouble() < 100.0 -> "${digits[0]}${digits[1]}R"+ "${digits[2]}".trim { it == '0' } toDouble() < 1000.0 -> "${digits[0]}${digits[1]}"+ "${digits[2]}R" toDouble() < 10000.0 -> "${digits[0]}K"+("${digits[1]}"+ "${digits[2]}").trim { it == '0' } toDouble() < 100000.0 -> "${digits[0]}${digits[1]}K"+ "${digits[2]}".trim { it == '0' } toDouble() < 1000000.0 -> "${digits[0]}${digits[1]}"+ "${digits[2]}K" toDouble() < 10000000.0 -> "${digits[0]}M"+("${digits[1]}"+ "${digits[2]}").trim { it == '0' } toDouble() < 100000000.0 -> "${digits[0]}${digits[1]}M"+ "${digits[2]}".trim { it == '0' } toDouble() < 1000000000.0 -> "${digits[0]}${digits[1]}"+ "${digits[2]}M" else -> "????" }) // when } // toOhms // Method to generate the display string. override fun toString() = if (denominator == 1L) "$numerator" else "($numerator / $denominator)" // Method to update the fraction with // a new value. The denominator must // be positive and simplify the fraction. fun update(value: Long, morsel: Long = 1L) { numerator = value denominator = morsel if (morsel <= 0L) throw IllegalStateException( "Denominator must be positive!") simplify() } // update } // Fraction // Sealed class to hold our inputs. sealed class Resistor { val value = Fraction() // Internal subclass to hold a list of // resistors in a parallel group. class Parallel(val list: List) : Resistor() { // Method to draw the resistor. override fun draw(): MutableList { val result = MutableList(0) { "" } when (list.size) { 1 -> for (value in list[0].draw()) result.add(value) 2 -> { val first = list[0].draw() val second = list[1].draw() val max = second[0].length.max( first[0].length) val one = max-first[0].length val two = max-second[0].length var center = first.indexOfFirst { it[0] == '-' } for (index in first.indices) if (index < center) result.add(" "+first[index] +" ".repeat(one)+" ") else if (index == center) result.add(" +-"+first[index] +"-".repeat(one)+"-+ ") else result.add(" | "+first[index] +" ".repeat(one)+" | ") center = second.indexOfFirst { it[0] == '-' } for (index in second.indices) if (index < center) result.add(" | "+second[index] +" ".repeat(two)+" | ") else if (index == center) result.add("-+-"+second[index] +"-".repeat(two)+"-+-") else result.add(" "+second[index] +" ".repeat(two)+" ") } // 2 3 -> { val first = list[0].draw() val second = list[1].draw() val third = list[2].draw() val max = second[0].length.max( first[0].length.max( third[0].length)) val one = max-first[0].length val two = max-second[0].length val three = max-third[0].length var center = first.indexOfFirst { it[0] == '-' } for (index in first.indices) if (index < center) result.add(" "+first[index] +" ".repeat(one)+" ") else if (index == center) result.add(" +-"+first[index] +"-".repeat(one)+"-+ ") else result.add(" | "+first[index] +" ".repeat(one)+" | ") center = second.indexOfFirst { it[0] == '-' } for (index in second.indices) if (index < center) result.add(" | "+second[index] +" ".repeat(two)+" | ") else if (index == center) result.add("-+-"+second[index] +"-".repeat(two)+"-+-") else result.add(" | "+second[index] +" ".repeat(two)+" | ") center = third.indexOfFirst { it[0] == '-' } for (index in third.indices) if (index < center) result.add(" | "+third[index] +" ".repeat(three)+" | ") else if (index == center) result.add(" +-"+third[index] +"-".repeat(three)+"-+ ") else result.add(" "+third[index] +" ".repeat(three)+" ") } // 3 } // when return result } // draw // Method to show the equation // evalulation. Default our result to // empty. If the resistor has a nested // list, display the simplified result. // Display the math formula. override fun evalulate(): String { var result = "" if (list.any { it !is Single }) result += list.joinToString(", ", " =\n [", "]", transform = { "${it.value}" }) result += list.joinToString( " + ", " =\n ", transform = { val (numerator, denominator) = it.value val fraction = Fraction( denominator, numerator) "$fraction" }) return result } // evalulate // Recursive method to calculate the // resistance for this resistor. Sum // their reciprocals, save it's // reciprocal, display it, and return // it. override fun process(): Fraction { var result = Fraction() for (element in list) result += Fraction(1)/ element.process() val (numerator, denominator) = Fraction(1)/result value.update(denominator, numerator) println("$this%s = %s". format(evalulate(), value)) value.update(numerator, denominator) println(" becomes "+( if (denominator == 1L) "%s".format(value) else "%s or %.6f".format( value, value.toDouble()). trim { it == '0' })) return value } // process // Method to return the display string. override fun toString() = list.joinToString(", ", "[", "]") } // Parallel // Internal subclass to hold a list of // resistors in a series group. class Series(val list: List) : Resistor() { // Method to draw the resistor. override fun draw(): MutableList { // Method to join two lists of strings. fun combine(first: MutableList, second: MutableList) { if (first.size == 0) for (value in second) first.add(value) else { val center = first.indexOfFirst { it[0] == '-' } val middle = second.indexOfFirst { it[0] == '-' } if (center < middle) { val spacing = " ".repeat( first[0].length) for (index in 1..(middle-center)) first.add(0, spacing) } else { val spacing = " ".repeat( second[0].length) for (index in 1..(center-middle)) second.add(0, spacing) } // if if (first.size < second.size) { val spacing = " ".repeat( first[0].length) for (index in 1..(second.size- first.size)) first.add(spacing) } else { val spacing = " ".repeat( second[0].length) for (index in 1..(first.size- second.size)) second.add(spacing) } // if for (index in second.indices) first[index] += second[index] } // if } // combine val result = MutableList(0) { "" } for (element in list) combine(result, element.draw()) return result } // draw // Method to show the equation // evalulation. Default our result to // empty. If the resistor has a nested // list, display the simplified result. // Display the math formula. override fun evalulate(): String { var result = "" if (list.any { it !is Single }) result += list.joinToString(", ", " =\n (", ")", transform = { "${it.value}" }) result += list.joinToString( " + ", " =\n ", transform = { "${it.value}" }) return result } // evalulate // Recursive method to calculate the // resistance for this resistor. Sum // them, save it, display it, and // return it. override fun process(): Fraction { var result = Fraction() for (element in list) result += element.process() val (numerator, denominator) = result value.update(numerator, denominator) println("$this%s = %s".format( evalulate(), value)) if (denominator != 1L) println(" is %.6f". format(value.toDouble()). trim { it == '0' }) return value } // process // Method to return the display string. override fun toString() = list.joinToString(", ", "(", ")") } // Series // Internal subclass to hold a single // resistor. class Single(number: Long = 0L) : Resistor() { init { value.update(number) } // init // Method to draw the resistor. override fun draw() = mutableListOf(" %4s ".format( value.toOhms()), "-~~~~-") // Method to show the equation // evalulation. override fun evalulate() = "" // Method to calculate the resistance for // this resistor. override fun process() = value } // Single // Method to display the inputs and // outputs for our challenge. fun display() { println("Input:\n$this") println("\nCalculation:") process() println("\nOutput:") println(draw().joinToString("\n", transform = { if (it[0] == '-') "o-$it-o ${value.toOhms()}" else " $it " })) println() } // display // Method to draw the resistor. abstract fun draw(): MutableList // Method to show the equation evalulation. abstract fun evalulate(): String // Method to calculate the resistance for // this resistor. abstract fun process(): Fraction override fun toString() = "$value" } // Resistor // Type aliases to shorten the internal class // names. typealias Parallel = Resistor.Parallel typealias Series = Resistor.Series typealias Single = Resistor.Single // Enumerate class of types for the tokens: // end of string, comma, open parentheses, // close parentheses, left brace, right brace, // number, and unknown character. enum class Type { DONE, COMMA, OPEN, CLOSE, LEFT, RIGHT, NUMBER, ERROR } // Data class for the current token with // properties for type of token and string of // the token. data class Token(val type: Type, val string: String) // Function to parse the input string into the // resistors to be processed for the user. fun parse(data: String) { var index = 0 var next = Token(Type.ERROR, "") // Function to retrieve the next token. fun token() { // Skip over any spacing. while (index < data.length && data[index] == ' ') index++ // Set the next token. If we reached // the end of the string, that makes // our done token. Otherwise, our // token is based on the current // character. next = if (index >= data.length) Token(Type.DONE, "") else when (data[index]) { // When the character is a // comma, move to the next // character and return our // token. ',' -> { index++ Token(Type.COMMA, ",") } // comma // When the character is a // open parentheses, move to // the next character and // return our token. '(' -> { index++ Token(Type.OPEN, "(") } // open // When the character is a // close parentheses, move to // the next character and // return our token. ')' -> { index++ Token(Type.CLOSE, ")") } // close // When the character is a // left brace, move to the // next character and return // our token. '[' -> { index++ Token(Type.LEFT, "[") } // left // When the character is a // right brace, move to the // next character and return // our token. ']' -> { index++ Token(Type.RIGHT, "]") } // right // When the character is a // digit, we have a number // so start our string empty, // while there are characters // left & they are digits, // stuff the digit at the end // of the string and move to // the next character, plus // after the digits return // our token. in '0'..'9' -> { var string = "" while (index < data.length && data[index] in '0'..'9') { string += data[index] index++ } // while Token(Type.NUMBER, string) } // number // Otherwise, the character is // not valid so return an error // token. else -> Token(Type.ERROR, "${data[index]}") } // when } // token // Recursive function to process a resistor. fun resistor(depth: Int): Resistor = // If we recursed too many times, // cause an exception. if (depth > 3) throw IllegalStateException( "Nested too many levels ($depth)!") // Otherwise, we can process this // level. else // When the token is an open // parentheses, we have a series // of resistors so process and // return it. Start our list // empty, repeat until we don't // have a comma, get the next // token, recurse to get our // resistor, & add it to our list, // plus after our list is done, // if the token is not our close // parentheses, cause an exception. // Otherwise, get the next token, // if the list has too many // elements, cause an exception, // and return our series. when (next.type) { Type.OPEN -> { val list = mutableListOf() do { token() list.add(resistor(depth+1)) } while (next.type == Type.COMMA) if (next.type != Type.CLOSE) throw IllegalStateException( "Expected ')' got "+ "'${next.string}'!") token() if (list.size > 3) throw IllegalStateException( "Too many elements ("+ list.size+") in series!") Series(list.toList()) } // open // When the token is an left brace, // we have a parallel set of // resistors so process and return it. // Start our list empty, repeat until // we don't have a comma, get the next // token, recurse to get our // resistor, & add it to our list, // plus after our list is done, // if the token is not our right // brace, cause an exception. // Otherwise, get the next token, // if the list has too many // elements, cause an exception, // and return our series. Type.LEFT -> { val list = mutableListOf() do { token() list.add(resistor(depth+1)) } while (next.type == Type.COMMA) if (next.type != Type.RIGHT) throw IllegalStateException( "Expected ']' got "+ "'${next.string}'!") token() if (list.size > 3) throw IllegalStateException( "Too many elements ("+ list.size+") in parallel!") Parallel(list.toList()) } // left // When the token is a number, we // have a single resistor so process // and return it. Convert the number // to a double, get the next token, // and return our single resistor. Type.NUMBER -> { val element = next.string.toLong() token() Single(element) } // number // Otherwise, we got a token we // didn't plan on so cause an // exception. else -> throw IllegalStateException( "Expected a resistor "+ "'${next.string}'!") } // when // Preload our first token, process the // top resistor, if we didn't get to the // end of our input string, cause an // exception. Otherwise, display and // process our resistor. token() val element = resistor(0) if (next.type != Type.DONE) throw IllegalStateException( "Expected end of string "+ "got '${next.string}'!") element.display() } // parse // Main function created for this challenge. fun main(args: Array) { // Try reading the user's test case. Cause // an exception on end of file, illegal // character, or syntax. Otherwise, display // and process it. try { parse(readLine()!!) // On exception, complain and process our // test cases. } catch (error: Throwable) { println("Bad input using defaults!") for (test in listOf( Series(listOf( Single(8L), Parallel(listOf( Single(6L), Single(12L))))), Parallel(listOf( Series(listOf( Single(11L), Parallel(listOf( Series(listOf( Single(1L), Single(5L))), Single(12L))))), Series(listOf( Single(3L), Single(7L))))))) test.display() } // try } // main

Resistors ch