// Input: nothing for default test cases or // an integer between three and twenty. // Created for this challenge: // https://www.sololearn.com/post/393289 // Magic square of odd order // A magic square of n order is a nxn square // filled with distinct positive numbers in // range 1 to n^2 such that each cell // contains a different integer and the sum // of each row, column and diagonal is equal. // The sum is called magic sum and has // n(n^2+1)/2 value. // My pattern 01 can help you to create // magic square of odd order by Siamese // method. // Enter an odd No.: 7 // +---+---+---+---+---+---+---+ // | 4| 29| 12| 37| 20| 45| 28| // +---+---+---+---+---+---+---+ // | 35| 11| 36| 19| 44| 27| 3| // +---+---+---+---+---+---+---+ // | 10| 42| 18| 43| 26| 2| 34| // +---+---+---+---+---+---+---+ // | 41| 17| 49| 25| 1| 33| 9| // +---+---+---+---+---+---+---+ // | 16| 48| 24| 7| 32| 8| 40| // +---+---+---+---+---+---+---+ // | 37| 23| 6| 31| 14| 39| 15| // +---+---+---+---+---+---+---+ // | 22| 5| 30| 13| 38| 21| 46| // +---+---+---+---+---+---+---+ // Magic sum: 175 // Magic square code based on algorithms // from the following - Odd N: // https://www.geeksforgeeks.org/magic-square/amp/ // Even N (modulo four of zero): // https://www.geeksforgeeks.org/magic-square-even-order/ // Even N (modulo four of two): // http://www.math.wichita.edu/~richardson/mathematics/magic%20squares/even-ordermagicsquares.html // Function to display the outputs for our // challenge. fun display(size: Int) { val matrix = process(size) val separator = "+"+"---+".repeat(size)+"\n" println(matrix.joinToString(separator, separator, separator, transform = { it.joinToString("|", "|", "|\n", transform = { "%3d".format(it) }) })) verify(matrix) } // display // Function to generate the matrix using the // double even algorithm from here: // https://www.geeksforgeeks.org/magic-square-even-order/ // Works for any size where its modulo by four // results in zero. The corners and center get // flipped with the original matrix filled // with element count. fun double(size: Int): List> { // Allocate the matrix with its element // count. Calculate the maximum to // subtract the count from to do the // flipping. val matrix = List(size) { row -> Array(size) { column -> row*size+column+1 } } var max = size*size+1 // Flip the four corners: top-left, bottom- // left, top-right, and bottom-right. The // corner is a quarter of the matrix square. for (row in 0 until (size/4)) for (column in 0 until (size/4)) { matrix[row][column] = max-matrix[row][column] matrix[size-row-1][column] = max-matrix[size-row-1][column] matrix[row][size-column-1] = max-matrix[row][size-column-1] matrix[size-row-1][size-column-1] = max-matrix[size-row-1][size-column-1] } // for // Flip the center. The center is the middle // half that was not touched by the corners. for (row in (size/4) until (3*size/4)) for (column in (size/4) until (3*size/4)) matrix[row][column] = max-matrix[row][column] // Convert the matrix to list for return. return List(size) { matrix[it].toList() } } // double // Function to generate the matrix using the // even algorithm from here: // http://www.math.wichita.edu/~richardson/mathematics/magic%20squares/even-ordermagicsquares.html // Should work for any size where its modulo // by four results in two. But, I hard coded // the handling of six, which is the only // supported size. fun even(size: Int): List> { // Allocate the matrix with zero. Calculate // the corner size. Get the odd result for // our corner. val matrix = List(size) { Array(size) { 0 } } val offset = size/2 val odd = odd(offset) // Place our odd result into all four // corners incrementing the values as // required. for (row in odd.indices) for (column in odd[row].indices) { matrix[row][column] = odd[row][column] matrix[row+offset][column+offset] = odd[row][column]+offset*offset matrix[row][column+offset] = odd[row][column]+2*offset*offset matrix[row+offset][column] = odd[row][column]+3*offset*offset } // for // Our columns sum correctly, but the // top half rows are low and our bottom // half rows are high. Calculate the // center of the top-left corner. For // the first half of the square rows, // for the columns prior to the left // corner center and the right corner // center plus two columns to the end, // if the column is one short of the // left center, we do not want to swap // the center row. For all others, // swap the top row and column with // the bottom one. val k = size/4 for (row in 0 until offset) for (column in (0 until k).toList()+ (size-k+1..size-1).toList()) if (column == k-1 && row != k || column != k-1) matrix[row+offset][column] = matrix[row][column].also { matrix[row][column] = matrix[row+offset][column] } // Finish by swapping the top left and // bottom left centers. matrix[size/4+offset][size/4] = matrix[size/4][size/4].also { matrix[size/4][size/4] = matrix[size/4+offset][size/4] } // Convert the matrix to list for return. return List(size) { matrix[it].toList() } } // even // Function to generate the matrix using the // odd algorithm from here: // https://www.geeksforgeeks.org/magic-square/amp/ // Works for all odd sizes. fun odd(size: Int): List> { // Allocate the matrix with zero. val matrix = List(size) { Array(size) { 0 } } // Pick our starting element. For each // number to place, do so. var row = size/2 var column = size-1 for (number in 1..(size*size)) { // Handle third condition where both // indices are outside the matrix by // putting them both to our new starting // point. if (row < 0 && column == size) { column = size-2 row = 0 // Otherwise, see if our first condition // needs handling. If either index is // outside the matrix, wrap it back in. } else { if (column == size) column = 0 if (row < 0) row = size-1 } // if // Handle our second condition. If the // element we planned to update is in // use already, reposition. if (matrix[row][column] != 0) { column -= 2 row++ } // if // Store our number in the matrix and // adjust to our next element diagonally // up and right. matrix[row--][column++] = number } // for // Convert the matrix to list for return. return List(size) { matrix[it].toList() } } // odd // Function to process our challenge. Display // our pattern. fun process(size: Int) = when { size%2 == 1 -> odd(size) size%4 == 0 -> double(size) else -> even(size) } // when // Function to verify the matrix is valid // and display its sum. fun verify(matrix: List>) { // Calculate our expected sum. Default // our matrix to good. For each row, // sum it and, if bad, note that fact. val expected = matrix.size*(matrix.size* matrix.size+1)/2 var good = true for (row in matrix.indices) if (matrix[row].sum() != expected) { good = false println("R $row ${matrix[row].sum()}") } // For each column, sum its elements. If // that sum is bad, note that fact. for (column in matrix[0].indices) { var sum = 0 for (row in matrix.indices) sum += matrix[row][column] if (sum != expected) { good = false println("C $column $sum") } } // for // Check diagonal sum from top-left to // bottom-right. var sum = 0 for (diagonal in matrix.indices) sum += matrix[diagonal][diagonal] if (sum != expected) { good = false println("\\ $sum") } // Check diagonal sum from bottom-left to // top-right. sum = 0 for (diagonal in matrix.indices) sum += matrix[matrix.size-diagonal-1][ diagonal] if (sum != expected) { good = false println("/ $sum") } // Display our sum. Mark bad squares with // a question mark. println("Magic sum: $expected"+( if (good) "" else "?")+"\n") } // verify // Main function created for this challenge. fun main(args: Array) { // Try reading the user's integer. Cause an // exception on end of file, non integer, or // out of our supported range. Otherwise, // process it. try { val test = readLine()!!.toInt() if (test !in 3..20) throw IllegalArgumentException( "Bad input!") display(test) // On exception, complain and process our // test cases. } catch (error: Throwable) { println("Bad input using defaults!") for (test in listOf(6, 7, 8)) display(test) } // try } // main

Magic ch