// Input: nothing for default test cases or // one or more lines of one or more // characters each being either a space or // #. // Created for this challenge: // https://www.sololearn.com/post/147407 // 2D and 3D Maze Conversion // I was thinking about doing the code golf // challenge listed below, but SoloLearn // won't let me input that much data to // test it so I decided maybe I should // write code to go both ways. Given that, // I figured a few of you might like to // play too. // Create two functions: one takes a 2D // maze and returns the equivalent 3D maze. // The second takes the 3D maze and returns // the 2D equivalent. The main program or // function should call both functions, // display both mazes, and verify the // original 2D matches the final 2D. // The 2D maze is made up of two characters: // space and # (pound). Space is the open // area you can travel. Pound is the closed // area you can not access. The maze is // allowed to be entered with variable width // and height. Missing elements are filled // with pound so an input of three lines: // "# " (1 space), " #" (3 spaces), and // " " (1 space) becomes a 3x4 fixed size // maze of "# ##", " #", and " ###". // The 3D maze is made up of five characters: // space, + (plus), - (dash), | (line), and // \ (slash). A single pound is displayed // with height of 3, width of 7, and depth of // 4 characters like shown in the picture. // +-----+ // |\ \ // + \ \ // \ +-----+ // \| | // +-----+ // Two ajacent pounds characters lose their // joining lines so this 2x2 maze "##" and // "# " (1 space) would become as shown in // the picture. // +-----------+ // |\ \ // + \ \ // \ \ +-----+ // \ \ \ | // \ \ \---+ // \ +-----+ // \| | // +-----+ // This 2x2 maze " #" (1 space) and "##" // would become as shown in the picture. // +-----+ // |\ \ // + \ \ // +-----+ \ // |\ \ // + \ \ // \ +-----------+ // \| | // +-----------+ // The final picture shows a 3x3 all closed // maze. // Trailing whitespace beyond the last maze // element is optional so the returned 3D // maze could be variable with the first // line of an area being three shorter than // it's sixth. The maze to be processed is // always fixed in size so use the last // line width to calculate the 2D width. // Idea based on this code golf challenge: // https://codegolf.stackexchange.com/q/191262 // Function to process our challenge for a // single maze. fun process(maze: List>) { // Function to convert a 2D maze into a // 3D maze. fun convert2To3(maze: List>): List> { // Figure out the size needed to hold // our output matrix based on our 2D // input and allocate it. Use an array // for now so we can modify it. val lines = maze.size*3+3 val columns = maze[0].size*6+maze.size*3+1 val matrix = List(lines) { Array(columns) { ' ' } } // Function to test if a location is // within the 2D maze and it is a closed // area. Everything outside the maze is // assumed open. fun test(line: Int, column: Int) = line in maze.indices && column in maze[0].indices && maze[line][column] == '#' // Function to place a closed area of // the 2D maze into the equivalent spot // in the 3D maze. fun place(line: Int, column: Int) { // Given the 2D maze location, // calculate the corresponding 3D // location top left corner. Declare // a list of our closed pattern. val top = line*3 val left = column*6+line*3 val cube = listOf("+-----+", "|\\ \\", "+ \\ \\", " \\ +-----+", " \\| |", " +-----+") // For each element in the maze, // figure out what needs to be placed // and store it. Basically, we have // many exceptions to handle, plus // our default pattern. for (row in cube.indices) for (element in cube[row].indices) matrix[top+row][left+element] = when { // The plus at the end of // our first line becomes // a space, when the other // three locations sharing // that spot are all closed. test(line-1, column) && test(line-1, column+1) && test(line, column+1) && row == 0 && element == cube[row].length-1 -> ' ' // The plus at the end of // our first line becomes // a slash, when the previous // row was also closed and // both the next column // locations sharing that // spot are opened. test(line-1, column) && !test(line-1, column+1) && !test(line, column+1) && row == 0 && element == cube[row].length-1 -> '\\' // The plus at the end of // our first line becomes // a dash, when the next // column was also closed // and both the previous // row locations sharing // that spot are opened. !test(line-1, column) && !test(line-1, column+1) && test(line, column+1) && row == 0 && element == cube[row].length-1 -> '-' // The dashes in our first // line become spaces, when // the previous row was also // closed. test(line-1, column) && row == 0 && element in 1..cube[0].length-2 -> ' ' // The plus at the start of // our first line becomes // a slash, when the previous // row was also closed. test(line-1, column) && !test(line-1, column-1) && row == 0 && element == 0 -> '\\' // The line at the beginning // of the second line becomes // a space, when the previous // row was also closed. test(line-1, column) && !test(line-1, column-1) && row == 1 && element == 0 -> ' ' // The plus at the beginning // of the third line becomes // a slash, when the previous // row was also closed. test(line-1, column) && !test(line-1, column-1) && row == 2 && element == 0 -> '\\' // The slash at the end of // the second and third line // becomes a space, when the // next column was also // closed. test(line, column+1) && row in 1..2 && element == cube[row].length-1 -> ' ' // The line at the end of // the fifth line becomes a // space, when the next // column was also closed. test(line, column+1) && row == 4 && element == cube[row].length-1 -> ' ' // The plus at the end of // the fourth and sixth // line becomes a dash, // when the next column // was also closed. test(line, column+1) && row in listOf(3, 5) && element == cube[row].length-1 -> '-' // Otherwise, no exception // was found so use the // character from our pattern. else -> cube[row][element] } // when } // place // For each element in our maze, if it // is closed, place it into our result. for (line in maze.indices) for (column in maze[line].size-1 downTo 0) if (maze[line][column] == '#') place(line, column) // Convert our result maze into lists and // return it. return List(matrix.size) { matrix[it].toList() } } // convert2To3 // Function to convert a 3D maze into a // 2D maze. fun convert3To2(maze: List>): List> { // Figure out the size needed to hold // our output matrix based on our 3D // input and allocate it. Use an array // for now so we can modify it. val lines = (maze.size-3)/3 val columns = (maze[0].size-1-lines*3)/6 val matrix = List(lines) { Array(columns) { ' ' } } // Function to test if a location is // within the 2D maze and it is a closed // area. Everything outside the maze is // assumed open. fun check(line: Int, column: Int) = line in matrix.indices && column in matrix[0].indices && matrix[line][column] == '#' // For each element in our maze, store // it's type. If it has a space and the // previous element was closed, this one // is closed. Otherwise, if it wasn't a // space and the previous element was // opened, this one is closed. Otherwise, // this element should be opened. for (row in 0 until lines) for (element in 0 until columns) matrix[row][element] = if (maze[row*3+1][element*6+1+ row*3] == ' ' && check(row, element-1)) '#' else if (maze[row*3+1][ element*6+1+row*3] != ' ' && !check(row, element-1)) '#' else ' ' // Convert our result maze into lists and // return it. return List(matrix.size) { matrix[it].toList() } } // convert2To3 // Function to verify the original and // final mazes match. fun verify(original: List>, final: List>): Boolean { // If the two mazes have different number // of rows, return failure. if (original.size != final.size) return false // For each row in the mazes, check the // columns. for (line in original.indices) { // If the rows have different number // of columns, return failure. if (original[line].size != final[line].size) return false // For each column in the rows, if // they have different values, return // failure. for (column in original[line].indices) if (original[line][column] != final[line][column]) return false } // for // Having got here we know the mazes // match so return success. return true } // verify // Display the original maze. println("Input:") for (line in maze) println(line.joinToString("")) println() // Convert to 3D and display it. val maze3D = convert2To3(maze) println("3D:") for (line in maze3D) println(line.joinToString("")) println() // Convert to 2D and display it. val maze2D = convert3To2(maze3D) println("2D:") for (line in maze2D) println(line.joinToString("")) println() // Verify the original matches our new // 2D version and display our status. if (verify(maze, maze2D)) println("Verify succeed.") else println("Verify failed!") println() } // process // Main function for this challenge. fun main(args: Array) { // Try reading an user specified 2D maze. try { // Default our list to empty and maximum // row length to zero. While there are // input lines, add them to our list and, // if the line is our longest yet, // remember it's length. Break out of // the loop on end of file or zero length // line. val list = MutableList(0) { "" } var maximum = 0 while (true) { val input = readLine() ?: break if (input.length == 0) break list.add(input) if (input.length > maximum) maximum = input.length } // while // Cause an exception, if there was no // maze or it contains illegal characters. // The check for characters tests each row // and column. if (list.size == 0) throw IllegalArgumentException( "Bad input!") for (element in list) for (character in element) if (character !in listOf(' ', '#')) throw IllegalArgumentException( "Bad character!") // Convert our input maze into fixed // size lists. Fill in missing columns // with closed areas. The existing // columns keep their values. Once // done, process the result. process(List(list.size) { row -> List(maximum) { column -> if (column < list[row].length) list[row][column] else '#' } }) // On exception, complain and process our // test cases. } catch (error: Throwable) { println("Bad input usings defaults!") for (test in listOf(listOf(listOf('#')), listOf(listOf('#', '#'), listOf('#', ' ')), listOf(listOf(' ', '#'), listOf('#', '#')), listOf(listOf('#', '#', '#'), listOf('#', '#', '#'), listOf('#', '#', '#')), listOf( listOf(' ', '#', ' ', '#'), listOf( '#', ' ', '#', ' '), listOf(' ', '#', ' ', '#'), listOf('#', ' ', '#', ' ')))) process(test) } // try } // main

mazes ch