// Input: nothing for a last couple moves by // two computer players, one of my existing // comment test cases, or a state with an // optional move separated by a space. States // are eleven character strings each // character holds the state of four // positions. Characters are '#' to 's'. // Leading '#' can be dropped. Moves are a // single digit zero to six. State '$' is // human first requiring a move. State '%' is // computer first no move allowed. State '#' // is two computer players no move allowed. // Other states are displayed by previous run. // No moves allowed for two computers playing // states. Moves are required for all human // playing states. Second and beyond lines // are the following moves to use for each // human turn. // Created for this challenge: // https://www.sololearn.com/post/182752 // Play Connect Four // Make a connect four game. It can be played // by two computer players or one human // against a computer player. The initial // input states two computers, computer goes // first, or the player makes a move to go // first. The code can allow multiple moves // to support playing elsewhere interactively // with the user. It should also support // playing in SoloLearn one move at a time. // The input should support specifying a // starting state with the next human move. // Enumerate class for board state: empty // or available, first player with white, // and second player with black. Also, used // for which players turn and the type of // game being played (two computer players, // human first, and human second.) enum class State { EMPTY, WHITE, BLACK; // Class method to convert an index into // an instance. companion object { fun lookup(index: Int) = values()[index] } // object // Method to convert an instance into an // index. fun index() = values().indexOf(this) // Method to swap the turn of the players. fun next() = if (this == State.WHITE) State.BLACK else State.WHITE } // State // Class for the connect four board game. // Properties are the type of player playing // the game, the matrix holding our board, // the player who makes the next move, the // number of turns taken, whether the game // is over, and whether to display a computer // move details. class Board(state: String) { val player = find(43, state) val matrix = List(6) { row -> Array(7) { column -> find(row*7+column+1, state) } } var turn = State.WHITE var number = 0 var won = false var debug = false // Constructor to verify the state was // valid. The first two properties are // filled out prior to this running. We // update the next three as needed, after // checking things. init { // Count the plays made and check for // gaps in the columns. Default our // counts to zeroes and for each column // in our matrix, for each row in the // column, process the element. var white = 0 var black = 0 for (column in matrix[0].indices) for (row in matrix.indices) // When the element is white, count // it. when (matrix[row][column]) { State.WHITE -> white++ // When the element is black, count // it. State.BLACK -> black++ // When the element is empty, make // sure the one above it is also // empty. Cause an exception when // an used element is above an // empty one, after displaying // the matrix. else -> if (row > 0 && matrix[row][column] == State.EMPTY && matrix[row-1][column] != State.EMPTY) { println(this) throw IllegalStateException( "Invalid gap in column!") } // if } // when // Set the player that made the last move // and complain when there is an issue. // If the counts are equal, our second // player just went. If our white is // one more than black, our first player // just went. Otherwise, display our // matrix and cause an exception because // a valid game must match the above // conditions. turn = if (white == black) State.BLACK else if (white-1 == black) State.WHITE else { println(this) throw IllegalStateException( "Invalid turns taken!") } // if // See if the game was won. Note the // game is won, display our matrix, and // cause an exception, if so. if (check()) { won = true println(this) throw IllegalStateException( "Game already won!") } // if // See if the game was a draw. If all // elements are colored, note the game // is won, display our matrix, and cause // an exception. if (white+black == 42) { won = true println(this) throw IllegalStateException( "Game was a draw!") } // if // Finish setting up by updating our // turn to the next player, our number // of turns, and display our initial // position. turn = turn.next() number = black+1 println("Initial position:") println(this) } // init // Method to convert the 43 data elements // stored in the starting state string to // the one being looked for. Extend the // string to our needed 11 length. Get // the character our element is in. // Make it a zero based integer using the // pouble sign as zero. Split the integer // into the four elements it contains // placing them into a list. Index the // list to get the element we wanted and // return it. private fun find(index: Int, start: String): State { val value = ("###########"+start). takeLast(11)[index/4]-'#' return State.lookup(listOf(value/27%3, value/9%3, value/3%3, value%3)[ index%4]) } // find // Method to get integer value of the // element we want out of our matrix, our // player, or zero. Since 43 is not a // multiple of four, we add a zero to the // beginning. The player goes last. The // matrix does the columns of the top row // first ending with the columns of the // bottom row. private fun lookup(index: Int) = if (index == 43) player.index() else if (index < 1) 0 else matrix[(index-1)/7][(index-1)%7]. index() // Method to convert the state elements // from 44 integers between zero and two // to 11 characters holding a group of // four of those integers. Get the integers // and default our result to empty. For // each group of four, combine them into // an integer, add our pound sign offset, // convert to a character, and append it // to our result. Return the finished // result. private fun state(): String { val data = List(44) { lookup(it) } var result = "" for (index in 0..40 step 4) result += (data[index+3]+ data[index+2]*3+data[index+1]*9+ data[index]*27+35).toChar() return result } // state // Method to check if our last player won. private fun check(): Boolean { // Function to check all right diagonals. fun right(): Boolean { // For all the columns that have four // or more elements on the right // diagonal, check it. for (column in -2..3) { // Zero our count and start our // position as our column. For each // row in our board, check the // corresponding column. var count = 0 var position = column for (row in 0..5) { // If our position is within our // matrix and it matches our // current player, increment our // count. If there are at least // four, return true. Otherwise, // we are outside the matrix or // got a different player so // reset our count to zero. Before // continuing our next loop, // increment our position for it. if (position in 0..6 && matrix[row][position] == turn) { if (++count >= 4) return true } else count = 0 position++ } // for } // for // If we got here, no win exists so // return false. return false } // right // Function to check all left diagonals. fun left(): Boolean { // For all the columns that have four // or more elements on the left // diagonal, check it. for (column in 3..8) { // Zero our count and start our // position as our column. For each // row in our board, check the // corresponding column. var count = 0 var position = column for (row in 0..5) { // If our position is within our // matrix and it matches our // current player, increment our // count. If there are at least // four, return true. Otherwise, // we are outside the matrix or // got a different player so // reset our count to zero. Before // continuing our next loop, // decrement our position for it. if (position in 0..6 && matrix[row][position] == turn) { if (++count >= 4) return true } else count = 0 position-- } // for } // for // If we got here, no win exists so // return false. return false } // left // Function to check all horizontals. fun horizontal(): Boolean { // For each row in the matrix, check // it. for (row in matrix.indices) { // Zero our count and for each // column in the row, check the // elements. var count = 0 for (column in matrix[row].indices) // If our element matches our // current player, increment our // count. If there are at least // four, return true. Otherwise, // we got a different player so // reset our count to zero. if (matrix[row][column] == turn) { if (++count >= 4) return true } else count = 0 } // for // If we got here, no win exists so // return false. return false } // horizontal // Function to check all verticals. fun vertical(): Boolean { // For each column in the matrix, check // it. for (column in matrix[0].indices) { // Zero our count and for each // row in the column, check the // elements. var count = 0 for (row in matrix.indices) // If our element matches our // current player, increment our // count. If there are at least // four, return true. Otherwise, // we got a different player so // reset our count to zero. if (matrix[row][column] == turn) { if (++count >= 4) return true } else count = 0 } // for // If we got here, no win exists so // return false. return false } // vertical // If a win was found, return it. return right() || left() || vertical() || horizontal() } // check // Method to find the last empty row of // our column. Default our row to the top // and while we haven't gone past our // bottom & this element is empty, // increment to the next. On exit, we // have the first non empty row with // beyond the bottom treated as used. // Therefore, return the previous row // as empty. private fun empty(column: Int): Int { var row = 0 while (row < 6 && matrix[row][column] == State.EMPTY) row++ return row-1 } // empty // Method to make a single move. private fun move(column: Int) { // Get the last row that is empty. If // there wasn't one, cause an exception. val row = empty(column) if (row < 0) throw IllegalStateException( "Column $column is full!") // Set the element for this player // and if the player won, state // that. matrix[row][column] = turn if (check()) { won = true println("*** $turn won! ***\n") // Otherwise, if there are no empty // elements in the top row, it is a // draw so state it. } else if (matrix[0].count { it == State.EMPTY } == 0) { won = true println("*** Game is a draw! ***\n") } // if // Switch players and if it is white's // turn, increment the turn number. turn = turn.next() if (turn == State.WHITE) number++ } // move // Method to select the computer's best // move. The following are the values // to use for our one turn look ahead: // 1500 for our win // 800 for blocking our opponent // 600 for 3rd in row with 2 wins choices // 400 for 3rd in row with 1 win choice // 300 for blocking opponent's 3rd in row // 100 for 2nd in row leading to 2 wins // 80 for block 2nd in row leading 2 wins // 60 for 2nd leading win // 40 keeping column odd/even // 20 playing in column 3 // 10 playing in column 2 & 4 // 5 playing in column 1 & 5 // 1 playing in column 0 & 6 // -50 for play that allows 2nd in row // -150 for play that allows 3rd in row // -700 for play that allows win fun pick(): Int { // Default the best column maximum, the // column that gave it, and the current // column calculation. var maximum = -1000 var picked = -1 var data = 0 // Function to check the horizontal // if we placed the color in the // location. fun horizontal(row: Int, column: Int, state: State, blocked: Boolean) { // Default our counts and go left // counting each color match. var color = 1 var left = 0 var right = 0 var index = column-1 while (index >= 0 && matrix[row][index] == state) { index-- color++ } // while // Continue left counting the empties. while (index >= 0 && matrix[row][index] == State.EMPTY) { index-- left++ } // while // Go right counting each color match. index = column+1 while (index <= 6 && matrix[row][index] == state) { index++ color++ } // while // Continue right counting the empties. while (index <= 6 && matrix[row][index] == State.EMPTY) { index++ right++ } // while // If we might manage a winning result, // figure out the advantage. if (left+right+color >= 4) // When we don't have enough to care, // do nothing. when (color) { 0, 1 -> {} // When we have two in a row, we // care so add our advantage in // to our column's calculation. // If we are checking for ourself // and both sides can be used, we // get our best score, else a // lower one. If we are checking // our opponent, we get extra for // blocking them and less for // helping them. 2 -> data += if (state == turn) if (left > 0 && right > 0) 100 else 60 else if (blocked) 80 else -50 // When we have three in a row, we // care so add our advantage in // to our column's calculation. // If we are checking for ourself // and both sides can be used, we // get our best score, else a // lower one. If we are checking // our opponent, we get extra for // blocking them and less for // helping them. 3 -> data += if (state == turn) if (left > 0 && right > 0) 600 else 400 else if (blocked) 300 else -150 // When we have four or more in a // row, we care so add our // advantage in to our column's // calculation. If we are checking // for ourself, we get our best // score. If we are checking our // opponent, we get extra for // blocking them and less for // helping them. else -> data += if (state == turn) 1500 else if (blocked) 800 else -700 } // when // If we are debugging this pick, // display this line's results. if (debug) println("H [$row, $column]: $data"+ " ($color, $left, $right)") } // horizontal // Function to check the vertical // if we placed the color in the // location. fun vertical(row: Int, column: Int, state: State, blocked: Boolean) { // Default our counts and go down // counting each color match. var color = 1 var index = row+1 while (index <= 5 && matrix[index][column] == state) { index++ color++ } // while // If we might manage a winning result, // figure out the advantage. if (row+color >= 4) // When we don't have enough to care, // do nothing. when (color) { 0, 1 -> {} // When we have two in a row, we // care so add our advantage in // to our column's calculation. // If we are checking for ourself // we get our lower score. If we // are checking our opponent, we // get extra for blocking them and // less for helping them. 2 -> data += if (state == turn) 60 else if (blocked) 40 else -50 // When we have three in a row, we // care so add our advantage in // to our column's calculation. // If we are checking for ourself // we get our lower score. If we // are checking our opponent, we // get extra for blocking them and // less for helping them. 3 -> data += if (state == turn) 400 else if (blocked) 300 else -150 // When we have four or more in // a row, we care so add our // advantage in to our column's // calculation. If we are checking // for ourself, we get our best // score. If we are checking our // opponent, we get extra for // blocking them and less for // helping them. else -> data += if (state == turn) 1500 else if (blocked) 800 else -700 } // when // If we are debugging this pick, // display this line's results. if (debug) println("V [$row, $column]: $data"+ " ($color, $row)") } // vertical // Function to check the right diagonal // if we placed the color in the // location. fun right(row: Int, column: Int, state: State, blocked: Boolean) { // Default our counts and go left & // up counting each color match. var color = 1 var left = 0 var empty = 0 var index = column-1 var line = row-1 while (index >= 0 && line >= 0 && matrix[line][index] == state) { index-- line-- color++ } // while // Continue left & up counting the // empties. while (index >= 0 && line >= 0 && matrix[line][index] == State.EMPTY) { index-- line-- left++ } // while // Go right & down counting each // color match. index = column+1 line = row+1 while (index <= 6 && line <= 5 && matrix[line][index] == state) { index++ line++ color++ } // while // Continue right & down counting the // empties. while (index <= 6 && line <= 5 && matrix[line][index] == State.EMPTY) { index++ line++ empty++ } // while // If we might manage a winning result, // figure out the advantage. if (left+empty+color >= 4) // When we don't have enough to care, // do nothing. when (color) { 0, 1 -> {} // When we have two in a row, we // care so add our advantage in // to our column's calculation. // If we are checking for ourself // and both sides can be used, we // get our best score, else a // lower one. If we are checking // our opponent, we get extra for // blocking them and less for // helping them. 2 -> data += if (state == turn) if (left > 0 && empty > 0) 100 else 60 else if (blocked) 80 else -50 // When we have three in a row, we // care so add our advantage in // to our column's calculation. // If we are checking for ourself // and both sides can be used, we // get our best score, else a // lower one. If we are checking // our opponent, we get extra for // blocking them and less for // helping them. 3 -> data += if (state == turn) if (left > 0 && empty > 0) 600 else 300 else if (blocked) 200 else -150 // When we have four or more in a // row, we care so add our // advantage in to our column's // calculation. If we are // checking for ourself and both // sides can be used, we get our // best score, else a lower one. // If we are checking our // opponent, we get extra for // blocking them and less for // helping them. else -> data += if (state == turn) 1500 else if (blocked) 800 else -700 } // when // If we are debugging this pick, // display this line's results. if (debug) println("R [$row, $column]: $data"+ " ($color, $left, $empty)") } // right // Function to check the left diagonal // if we placed the color in the // location. fun left(row: Int, column: Int, state: State, blocked: Boolean) { // Default our counts and go left & // down counting each color match. var color = 1 var right = 0 var empty = 0 var index = column-1 var line = row+1 while (index >= 0 && line <= 5 && matrix[line][index] == state) { index-- line++ color++ } // while // Continue left & down counting the // empties. while (index >= 0 && line <= 5 && matrix[line][index] == State.EMPTY) { index-- line++ empty++ } // while // Go right & up counting each color // match. index = column+1 line = row-1 while (index <= 6 && line >= 0 && matrix[line][index] == state) { index++ line-- color++ } // while // Continue right & up counting the // empties. while (index <= 6 && line >= 0 && matrix[line][index] == State.EMPTY) { index++ line-- right++ } // while // If we might manage a winning result, // figure out the advantage. if (right+empty+color >= 4) // When we don't have enough to care, // do nothing. when (color) { 0, 1 -> {} // When we have two in a row, we // care so add our advantage in // to our column's calculation. // If we are checking for ourself // and both sides can be used, we // get our best score, else a // lower one. If we are checking // our opponent, we get extra for // blocking them and less for // helping them. 2 -> data += if (state == turn) if (right > 0 && empty > 0) 100 else 60 else if (blocked) 80 else -50 // When we have three in a row, we // care so add our advantage in // to our column's calculation. // If we are checking for ourself // and both sides can be used, we // get our best score, else a // lower one. If we are checking // our opponent, we get extra for // blocking them and less for // helping them. 3 -> data += if (state == turn) if (right > 0 && empty > 0) 600 else 400 else if (blocked) 300 else -150 // When we have four or more in a // row, we care so add our // advantage in to our column's // calculation. If we are checking // for ourself and both sides can // be used, we get our best score, // else a lower one. If we are // checking our opponent, we get // extra for blocking them and // less for helping them. else -> data += if (state == turn) 1500 else if (blocked) 800 else -700 } // when // If we are debugging this pick, // display this line's results. if (debug) println("L [$row, $column]: $data"+ " ($color, $empty, $right)") } // left // For every column, calculate it's // score and select the maximum one. for (column in matrix[0].indices) { // Get the last empty row for this // column. If we found one, test // it. val row = empty(column) if (row >= 0) { // Start with the advantage for // the column. data = when (column) { 0, 6 -> 1 1, 5 -> 5 2, 4 -> 10 else -> 20 } // when // First player gets an advantage // with odd rows. Second with even // rows. if (row%2 == turn.index()%2) data += 40 // Test each line to see if this // gives us an advantage. horizontal(row, column, turn, false) vertical(row, column, turn, false) right(row, column, turn, false) left(row, column, turn, false) // If we are not the top row, // test the lines above to see // if we'd be giving our opponent // an advantage. if (row > 0) { horizontal(row-1, column, turn.next(), false) vertical(row-1, column, turn.next(), false) right(row-1, column, turn.next(), false) left(row-1, column, turn.next(), false) } // if // Test each line to see if it // blocks our opponent. horizontal(row, column, turn.next(), true) vertical(row, column, turn.next(), true) right(row, column, turn.next(), true) left(row, column, turn.next(), true) // If this column is the new maximum, // save it. if (data > maximum) { maximum = data picked = column } // if } // if // If we are debugging this pick, // display this columns results. if (debug) println("Column $column: $data") } // for // Return the best column. return picked } // pick // Method to play the computer's turn. fun computer() { // If we want debugging, we turn it on // here. Pick the turn number and player // to update this. In any case, pick // our column to use and make sure the // debugging is off. if (number == 0 && turn == State.BLACK) debug = true val data = pick() debug = false // If we failed to pick a column, the // game must be a draw. if (data == -1) { println("*** Draw ***") won = true // Otherwise, make the move, and // display the board. } else { move(data) println(this) } // if } // computer // Method to play the human's turn // followed by the computer's. Make the // move and display the updated board. // If the game is not over, let the // computer take their turn. fun human(column: Int) { move(column) println(this) if (!won) computer() } // computer // Method to generate the display string // the class. It includes the turn number // for white moves, which player made the // move, the type of game, the board, and // the state of the board. override fun toString() = (when (player.index()) { 0 -> "Two computers\n" 1 -> "Person first\n" else -> "Computer first\n" })+ (if (turn.next() == State.WHITE) "($number) " else "")+"${turn.next()} move:\n"+ matrix.joinToString("\n", transform = { it.joinToString(" ", transform = { when (it) { State.EMPTY -> "O" State.WHITE -> "W" else -> "B" } }) })+"\nState: "+ state()+"\n" } // Board // Main function for this challenge. fun main(args: Array) { // Try reading the user's input. try { // Read the first input line and split // into list of fields. If the first // field is empty or there are more // than two fields, cause an exception. val input = readLine()!!.split(" ") if (input[0].isEmpty() || input.size > 2) throw IllegalArgumentException( "Bad input!") // Setup the board based on the first // field (our state). This will cause // an illegal state exception on // issues. If we have a human player // and it is their turn, there must // be a valid move in the second // field. Cause an illegal state // exception on issues. val board = Board(input[0]) if (board.player == board.turn && (input.size != 2 || input[1].toIntOrNull() == null || input[1].toInt() !in 0..6)) throw IllegalStateException( "Player move required!") // If we have a human player and it is // not their turn, there can't be a // second field. Cause an illegal state // exception on issues. if (board.player == board.turn.next() && input.size != 1) throw IllegalStateException( "Computer move specified!") // If two computer players were // requested, have them play until // the game is over or we reached // our stopping point (avoiding // timeout.) if (board.player.index() == 0) while (!board.won) { board.computer() if (board.number%10 == 0 && board.turn == State.WHITE) break } // while // Otherwise, we have a human player // so play as long as we get moves // from them. else { // If we have a move, play our // human's move plus the following // computer move. Otherwise, just // play the computer move. if (input.size == 2) board.human(input[1].toInt()) else board.computer() // While the game is not over, try // reading the next human move, on // failure exit the loop, play the // move, and computer response to it. while (!board.won) { val data = readLine() ?: break if (data.toIntOrNull() == null) break board.human(data.toInt()) } // while } // if // On illegal state exception, display // the message. } catch (error: IllegalStateException) { println(error.message) // On all other exceptions, complain and // process the last few moves of a two // computer game. } catch (error: Throwable) { println("Bad input using default!") val board = Board("%Y'#") while (!board.won) board.computer() } // try } // main

connect4 ch