// Created for this challenge: // https://www.sololearn.com/post/167428 // CHALLENGE : // A Byte of multiplication. // First step: // You're allowed to: // - use integers 0 and 1 (only) // - use the assignment operator '=' (but // no '==') // - create and use variables // - create and use arrays // - use array indexing, no slicing (as far // as you respect the first rule) // - create and use functions // - anything else is FORBIDDEN (no loop, // no if, no +*/-, no >==<, no <<>>^&|, // no dictionaries, no strings, no tuples, // no sets, no import, no built-ins, // etc...) // Your goal is to create a function for // each logic operator: yes, not, and, or, // xor, nand, nor, nxor, lower than, // greater than, equal to // ex: // yes(1) -> 1 // and(0,1) -> 0 // nxor(1,0) -> 0 // (Step 2 in the comments) // Second step: // With the same tools, your task is to // build functions // able of: // - add 2 8-bits-bytes // - subtract 2 8-bits bytes // - multiply 2 8-bits-bytes. // To respect the rules, bytes will be // built as lists of 0 and 1 // ex: // bAdd([0,0,1,1,1,0,1,0], // [0,1,0,0,1,0,0,1]) // -> [1,0,0,0,0,0,1,1] (58+73 = 131) // bSub([0,1,0,0,1,0,0,1], // [0,0,1,1,1,0,1,0]) // -> [0, 0, 0, 0, 1, 1, 1, 1] (73-58 // = 15) // bMul([0,0,0,0,0,1,1,1], // [0,0,0,1,1,1,0,1]) // -> [1,1,0,0,1,0,1,1] (7*29 = 203) // your functions don't need to deal with // cases involving negative or >255 // integers. // Bonus: Grail goes to who uses some // recursion! (there are multiple grails) // Extend List class with method to retrieve // the sixth value. The three of these allow // destructuring of the eight bit list to // eight separate variables (one to five // are preexisting.) operator fun List.component6() = this[5] // Extend List class with method to retrieve // the seventh value. operator fun List.component7() = this[6] // Extend List class with method to retrieve // the eighth value. operator fun List.component8() = this[7] // Class to play with a single bit. Property // is the bit's value. class Bit(val value: Int) { // Method to return a new bit indentical // to our current. fun yes() = Bit(this.value) // Method to return a new bit the opposite // of our current. fun not() = Bit(listOf(1, 0)[this.value]) // Method to return a new bit with the // 'and' two bits. fun and(operand: Bit) = listOf(Bit(0), operand.yes())[ this.value] // Method to return a new bit with the // 'or' two bits. fun or(operand: Bit) = listOf(operand.yes(), Bit(1))[this.value] // Method to return a new bit with the // 'xor' two bits. fun xor(operand: Bit) = listOf(operand.yes(), operand.not())[this.value] // Method to return a new bit with the // 'not' of the 'and' of two bits. fun nand(operand: Bit) = this.and(operand).not() // Method to return a new bit with the // 'not' of the 'or' of two bits. fun nor(operand: Bit) = this.or(operand).not() // Method to return a new bit with the // 'not' of the 'xor' of two bits. fun nxor(operand: Bit) = this.xor(operand).not() // Method to return a new bit with zero // for false & one for true for the // instance being less than the parameter. fun less(operand: Bit) = listOf(operand.yes(), Bit(0))[ this.value] // Method to return a new bit with zero // for false & one for true for the // instance being equal than the parameter. fun equal(operand: Bit) = listOf(operand.not(), operand.yes())[this.value] // Method to return a new bit with zero // for false & one for true for the // instance being greater than the // parameter. fun greater(operand: Bit) = listOf(Bit(0), operand.not())[ this.value] // Method to fill out a new byte with // eight copies of the bit. fun fill() = Byte(listOf(this, this, this, this, this, this, this, this)) // Method to generate the bit display // string, override fun toString() = "$value" } // Bit // Class to provide eight bit bytes. The // list property is required to contain eight // bits. Failure could cause exceptions. class Byte(val value: List) { // Method to return a new byte with the // 'and' each bit position in both bytes. fun and(operand: Byte) = Byte(List(value.size) { value[it].and( operand.value[it]) }) // Method to return a new byte with the // 'or' each bit position in both bytes. fun or(operand: Byte) = Byte(List(value.size) { value[it].or( operand.value[it]) }) // Method to return a new byte with the // 'xor' each bit position in both bytes. fun xor(operand: Byte) = Byte(List(value.size) { value[it].xor( operand.value[it]) }) // Method to return a new byte with the // 'not' of the 'and' each bit position // in both bytes. fun nand(operand: Byte) = Byte(List(value.size) { value[it].nand( operand.value[it]) }) // Method to return a new byte with the // 'not' of the 'or' each bit position // in both bytes. fun nor(operand: Byte) = Byte(List(value.size) { value[it].nor( operand.value[it]) }) // Method to return a new byte with the // 'not' of the 'xor' each bit position // in both bytes. fun nxor(operand: Byte) = Byte(List(value.size) { value[it].nxor( operand.value[it]) }) // Method to return a new bit with zero // for false & one for true for the // instance being less than the parameter. fun less(operand: Byte): Bit { val (f1, f2, f3, f4, f5, f6, f7, f8) = value val (s1, s2, s3, s4, s5, s6, s7, s8) = operand.value return f1.less(s1).or(f1.equal( s1).and(f2.less(s2).or(f2.equal( s2).and(f3.less(s3).or(f3.equal( s3).and(f4.less(s4).or(f4.equal( s4).and(f5.less(s5).or(f5.equal( s5).and(f6.less(s6).or(f6.equal( s6).and(f7.less(s7).or(f7.equal( s7).and(f8.less(s8))))))))))))))) } // less // Method to return a new bit with zero // for false & one for true for the // instance being equal to the parameter. fun equal(operand: Byte): Bit { val (f1, f2, f3, f4, f5, f6, f7, f8) = xor(operand).value return f1.or(f2).or(f3).or(f4).or(f5). or(f6).or(f7).or(f8).not() } // equal // Method to return a new bit with zero // for false & one for true for the // instance being greater than the // parameter. fun greater(operand: Byte) = equal(operand).or(less(operand)).not() // Method to return a new byte with the // instance bits shifted left with a // zero bit added on the right. fun shift(): Byte { val (f1, f2, f3, f4, f5, f6, f7, f8) = value return Byte(listOf(f2, f3, f4, f5, f6, f7, f8, Bit(0))) } // shift // Method to add both bytes and return // the result in a new byte. fun add(operand: Byte): Byte { val (f1, f2, f3, f4, f5, f6, f7, f8) = value val (s1, s2, s3, s4, s5, s6, s7, s8) = operand.value var c = Bit(0) val r8 = f8.xor(s8).xor(c) c = f8.and(s8).or(f8.and(c)).or(s8.and(c)) val r7 = f7.xor(s7).xor(c) c = f7.and(s7).or(f7.and(c)).or(s7.and(c)) val r6 = f6.xor(s6).xor(c) c = f6.and(s6).or(f6.and(c)).or(s6.and(c)) val r5 = f5.xor(s5).xor(c) c = f5.and(s5).or(f5.and(c)).or(s5.and(c)) val r4 = f4.xor(s4).xor(c) c = f4.and(s4).or(f4.and(c)).or(s4.and(c)) val r3 = f3.xor(s3).xor(c) c = f3.and(s3).or(f3.and(c)).or(s3.and(c)) val r2 = f2.xor(s2).xor(c) c = f2.and(s2).or(f2.and(c)).or(s2.and(c)) val r1 = f1.xor(s1).xor(c) c = f1.and(s1).or(f1.and(c)).or(s1.and(c)) return Byte(listOf(r1, r2, r3, r4, r5, r6, r7, r8)) } // add // Method to return a new byte with the // result of subtracting the parameter // from the instance. The instance is // required to be the bigger number. fun sub(operand: Byte): Byte { val (f1, f2, f3, f4, f5, f6, f7, f8) = value val (s1, s2, s3, s4, s5, s6, s7, s8) = operand.value var b = Bit(0) val r8 = f8.xor(s8).xor(b) b = f8.not().or(f8.and(b)).and(s8).or( b.and(f8.not()).and(s8.not())) val r7 = f7.xor(s7).xor(b) b = f7.not().or(f7.and(b)).and(s7).or( b.and(f7.not()).and(s7.not())) val r6 = f6.xor(s6).xor(b) b = f6.not().or(f6.and(b)).and(s6).or( b.and(f6.not()).and(s6.not())) val r5 = f5.xor(s5).xor(b) b = f5.not().or(f5.and(b)).and(s5).or( b.and(f5.not()).and(s5.not())) val r4 = f4.xor(s4).xor(b) b = f4.not().or(f4.and(b)).and(s4).or( b.and(f4.not()).and(s4.not())) val r3 = f3.xor(s3).xor(b) b = f3.not().or(f3.and(b)).and(s3).or( b.and(f3.not()).and(s3.not())) val r2 = f2.xor(s2).xor(b) b = f2.not().or(f2.and(b)).and(s2).or( b.and(f2.not()).and(s2.not())) val r1 = f1.xor(s1).xor(b) b = f1.not().or(f1.and(b)).and(s1).or( b.and(f1.not()).and(s1.not())) return Byte(listOf(r1, r2, r3, r4, r5, r6, r7, r8)) } // sub // Method to return a new byte with the // result of multifacation of the parameter // by the instance. The instance is // required to be the bigger number. fun mult(operand: Byte): Byte { val (f1, f2, f3, f4, f5, f6, f7, f8) = value var result = f8.fill().and(operand) var temp = operand.shift() result = result.add(f7.fill().and(temp)) temp = temp.shift() result = result.add(f6.fill().and(temp)) temp = temp.shift() result = result.add(f5.fill().and(temp)) temp = temp.shift() result = result.add(f4.fill().and(temp)) temp = temp.shift() result = result.add(f3.fill().and(temp)) temp = temp.shift() result = result.add(f2.fill().and(temp)) temp = temp.shift() result = result.add(f1.fill().and(temp)) return result } // mult // Method to generate the list of bits // display string, override fun toString() = "$value" } // Byte // Extend the Byte class with a method to // make an integer out of the bits. fun Byte.toInt() = value.fold(0, { a, e -> a*2+e.value }) // Extend the Byte class with a constructor // to convert the integer into our list // of bits before calling the primary // constructor. Add leading zero bits to // the front of the bits of the integer and // keep the last eight. fun Byte(number: Int) = Byte((List(7) { Bit(0) }+ number.toString(2).map { Bit(it-'0') }).takeLast(8)) // Main function to demonstrate our class // for the challenge. fun main(args: Array) { // Allocate the test bytes and display // them. val five = Byte(5) println("${five.toInt()} = $five") val ten = Byte(10) println("${ten.toInt()} = $ten") val fifteen = Byte(15) println("${fifteen.toInt()} = $fifteen") println() // Demonstrate our various methods with // five and ten. println("${five.toInt()} < ${ten.toInt()}"+ " = ${five.less(ten)}") println("${five.toInt()} == ${ten.toInt()}"+ " = ${five.equal(ten)}") println("${five.toInt()} > ${ten.toInt()}"+ " = ${five.greater(ten)}") println("${five.toInt()} ^ ${ten.toInt()}"+ " = ${five.xor(ten)}") println("${five.toInt()} & ${ten.toInt()}"+ " = ${five.and(ten)}") println("${five.toInt()} | ${ten.toInt()}"+ " = ${five.or(ten)}") println("${five.toInt()} + ${ten.toInt()}"+ " = ${five.add(ten)}") println("${ten.toInt()} - ${five.toInt()}"+ " = ${ten.sub(five)}") println("${ten.toInt()} * ${five.toInt()}"+ " = ${ten.mult(five)} or "+ "${ten.mult(five).toInt()}") println() // Demonstrate our various methods with // fifteen and ten. println("${fifteen.toInt()} < ${ten.toInt()}"+ " = ${fifteen.less(ten)}") println("${fifteen.toInt()} == "+ "${ten.toInt()} = ${fifteen.equal(ten)}") println("${fifteen.toInt()} > ${ten.toInt()}"+ " = ${fifteen.greater(ten)}") println("${fifteen.toInt()} ^ ${ten.toInt()}"+ " = ${fifteen.xor(ten)}") println("${fifteen.toInt()} & ${ten.toInt()}"+ " = ${fifteen.and(ten)}") println("${fifteen.toInt()} | ${ten.toInt()}"+ " = ${fifteen.or(ten)}") println("${fifteen.toInt()} + ${ten.toInt()}"+ " = ${fifteen.add(ten)}") println("${fifteen.toInt()} - ${ten.toInt()}"+ " = ${fifteen.sub(ten)}") println("${fifteen.toInt()} * ${ten.toInt()}"+ " = ${fifteen.mult(ten)} or "+ "${fifteen.mult(ten).toInt()}") println() // Prove the borrows work with sixteen // minus one and equal works. println("16 - 1 = ${Byte(16).sub(Byte(1))}") println("${fifteen.toInt()} - ${ten.toInt()}"+ " == ${five.toInt()} "+ "${fifteen.sub(ten).equal(five)}") } // main

byte ch