// Created for this challenge: // https://www.sololearn.com/post/224515 // [Challenge] // Write a program that takes 8 hints and // finds the 3 members of group G1.. G6. // The hints give a set of numbers and the // groups which are completely in it. // Run // https://code.sololearn.com/cjxEQ9Gvd4y1 // for detailed informations. // Each run generates a random different puzzle. // Example: // [0, 8, 3, 2, 7, 6, 1]G1G4 // [5, 0, 8, 3, 2, 4, 1]G2G5 // [5, 0, 8, 2, 7, 6, 4]G2G5 // [5, 0, 3, 2, 7, 6, 1]G4G6 // [0, 8, 3, 2, 6, 4, 1]G3G5 // [5, 0, 2, 7, 6, 4, 1]G3G5 // [5, 8, 3, 2, 7, 4, 1]G1G4 // [5, 8, 3, 2, 7, 6, 4]G4G6 // This is the solution // G1: [1, 7, 8] // G2: [0, 8, 5] // G3: [4, 6, 1] // G4: [2, 3, 7] // G5: [2, 0, 4] // G6: [5, 3, 6] // Data class to hold the Group information. // Properties are our identifier and three // data values. data class Group(val id: Int, val data: Array) { // Method to generate our display string. override fun toString() = "G$id: "+data.joinToString(", ", "[", "]") } // Group // Data class to hold the hint information. // Properties are our seven values and the // groups that are fully contained by them. data class Hint(val data: List, val groups: List) { // Method to generate our display string. override fun toString() = "$data"+groups.joinToString("", transform={"G${it.id}"}) } // Hint // Class to iterate over unique combinations // of the numbers 0 to size-1 for the // specified elements. Properties are number // of numbers to use, the number to return in // each of our combinations, flag to // terminate the iteration, and list with // next value. class Combinations(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 } // Combinations // Function to process our challenge. fun process(hints: List, groups: List) { // For each of our groups, find a // combination that works. for (group in groups) // For each possible combination, see if // it is good. for (combo in Combinations(9, 3)) { // Default to good. For each hint, // see it we are still good. If // this combo is completely in // hints our group is specified for // and only partially in hints our // group is not specified for, we // are good. var good = true for ((list, grp) in hints) good = good && if (group in grp) list.filter { it in combo }.size == 3 else list.filter { it in combo }.size < 3 // If we are good, store the // combination into our group. if (good) for (index in 0..2) group.data[index] = combo[index] } // for } // process // Function to display the inputs and outputs // for our challenge. fun display(hints: List, groups: List) { println(hints.joinToString("\n")) process(hints, groups) println() println(groups.joinToString("\n")) println() } // display // Function to generate a new random set // of hints. Code based on: // https://code.sololearn.com/cjxEQ9Gvd4y1 fun generate() { // Allocate and randomize our list of // numbers. val e = MutableList(9) { it } java.util.Collections.shuffle(e) // Allocate and randomize our list of // pairs to remove. val rem = mutableListOf (listOf(0, 7), listOf(0, 5), listOf(2, 3), listOf(2, 7), listOf(6, 5), listOf(6, 1), listOf(8, 3), listOf(8, 1)) java.util.Collections.shuffle(rem) // Pick the three numbers for our six // groups. Put the groups into a list. val G2 = List(3) { e[it] } val G4 = List(3) { e[it+3] } val G3 = List(3) { e[it+6] } val G6 = List(3) { e[3*it+0] } val G5 = List(3) { e[3*it+1] } val G1 = List(3) { e[3*it+2] } val groups = listOf(G1, G2, G3, G4, G5, G6) // Create our group classes, place them // into a list, and create an empty hint // list. val grps = List(6) { Group(it+1, Array(3) { Int.MAX_VALUE }) } val hints = mutableListOf() // For each pair of removals, generate // our value list, figure out which groups // are completely in it, create our hint, // and add it to our hint list. rem.forEach { // Take our original randomized numbers // and remove our pair of numbers to // make our hint value list. val l = e.toMutableList() val r1 = l[it[0]] val r2 = l[it[1]] l.remove(r1) l.remove(r2) // Figure out which groups are // completely in our hint and add them // to our group used list, val used = mutableListOf() if (G1.all { it in l }) used.add(grps[0]) if (G2.all { it in l }) used.add(grps[1]) if (G3.all { it in l }) used.add(grps[2]) if (G4.all { it in l }) used.add(grps[3]) if (G5.all { it in l }) used.add(grps[4]) if (G6.all { it in l }) used.add(grps[5]) // Create our hint class with our hint // value list and group used list. Add // it to our list of hints. hints.add(Hint(l.toList(), used.toList())) } // each // Display our expected solution and // process our hints. println("Generated with expect solution:") for(i in 1..6) println("G$i: ${groups[i-1]}") println() display(hints.toList(), grps) } // generate // Main function created for this challenge. // Set up our group list and hint list for // Oma's example. Process it. Set up a // random example and process it. fun main(args: Array) { val groups = List(6) { Group(it+1, Array(3) { Int.MAX_VALUE }) } val hints = listOf( Hint(listOf(0, 8, 3, 2, 7, 6, 1), listOf(groups[0], groups[3])), Hint(listOf(5, 0, 8, 3, 2, 4, 1), listOf(groups[1], groups[4])), Hint(listOf(5, 0, 8, 2, 7, 6, 4), listOf(groups[1], groups[4])), Hint(listOf(5, 0, 3, 2, 7, 6, 1), listOf(groups[3], groups[5])), Hint(listOf(0, 8, 3, 2, 6, 4, 1), listOf(groups[2], groups[4])), Hint(listOf(5, 0, 2, 7, 6, 4, 1), listOf(groups[2], groups[4])), Hint(listOf(5, 8, 3, 2, 7, 4, 1), listOf(groups[0], groups[3])), Hint(listOf(5, 8, 3, 2, 7, 6, 4), listOf(groups[3], groups[5]))) println("Oma's example:") display(hints.toList(), groups) generate() } // main

hint ch