Connect Four is a game in which two players, Black and Green, alternate placing

Question

Connect Four
is a game in which two players, Black and Green, alternate placing
chips in one of seven columns. Each column can contain up to six chips. The chips,
inserted at the top of a column, slide down the column and come to rest above the
last chip placed in that column. A player wins the game when there are four chips in
a row vertically, horizontally, or diagonally, of his color.

a.

A conifi guration of the game is a 6 *7 integer array, board, such that
i. board[i][j] 1 indicates that a green chip occupies position ( i,j );
ii. board[i][j] 2 indicate that a black chip occupies position ( i,j ); and
iii. board[i][j] 0 indicates that position( i,j ) is empty.
The conifiguration that models the picture of Figure 7.44 is
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 2 0 0 0 0
0 2 2 1 0 2 0
0 1 2 1 1 1 0

using java
Write a method that accepts a game conifi guration and determines whether or
not a player has won, returning ‘G’ for green, ‘B’ for black, or ‘N’ for neither.
Test your method in a program that reads a board conifiguration and reports the
winner, if there is one.

Explanation / Answer

import java.util.*;

public class ConnectFour {

// This method attempts to put the disk of the given color in the given column.
// It returns true if successful and false if the column is filled and we cannot
// put a disk.
public static boolean putDisk(char[][] field, int column, char color) {
// If the first disk is there, the column is filled, returning false.
if (field[0][column] != ' ')
return false;

// Check all elements in the column.
for (int row = 0; row < 6; ++row) {
// If we found something, which means if the character is not
// zero character
if (field[row][column] != ' ') {
// Put the disk on top of the current one.
field[row-1][column] = color;
return true;
}
}
// If no other disks found, we place this diak at the bottom.
field[5][column] = color;
return true;
}

// Check rows, if there are 4 or more disks of the same color - return winner color
private static char getWinnerInRows(char[][] field) {
// Check rows and see if there are 4 disks of the same color
for (int row = 0; row < 6; ++row) {
int count = 0;
// We will compare current element with the previous
for (int column = 1; column < 7; ++column) {
if (field[row][column] != ' ' &&
field[row][column] == field[row][column-1])
++count;
else
count = 1;

// Check if there are 4 in a row.
if (count >= 4) {
// Return color of the winner
return field[row][column];
}
}
}
// Otherwise return character, which means nobody win in rows.
return ' ';
}

// Check columns, if there are 4 or more disks of the same color - return winner color
private static char getWinnerInColumns(char[][] field) {
// Check rows and see if there are 4 disks of the same color
for (int column = 0; column < 7; ++column) {
int count = 0;
// We will compare current element with the previous
for (int row = 1; row < 6; ++row) {
if (field[row][column] != ' ' &&
field[row][column] == field[row-1][column])
++count;
else
count = 1;

// Check if there are 4 in a row.
if (count >= 4) {
// Return color of the winner
return field[row][column];
}
}
}
// Otherwise return character, which means nobody win in rows.
return ' ';
}

// Check diagonals, if there are 4 or more disks of the same color - return winner color
private static char getWinnerInDiagonals(char[][] field) {
// There are 2 kinds of diagonals, let's check those that go from top-left to bottom right

// There are diagonals, that starts on top of each column, let's check them
for (int column = 0; column < 7; ++column) {
int count = 0;
// Traverse diagonal that starts at [0][column], we start with the first row,
// because we will compare elements with the previous one, similar to how
// we did this for rows and columns
for (int row = 1; row < 6; ++row) {
// Coordinates an the diagonal change as [row + i][column + i],
// so we stop when column can get outside of the range
if (column + row >= 7) break;
if (field[row][column+row] != ' ' &&
field[row-1][column + row - 1] == field[row][column+row])
++count;
else
count = 1;
if (count >= 4) return field[row][column+row];
}
}

// There are diagonals, that starts on left of each row, let's check them
for (int row = 0; row < 6; ++row) {
int count = 0;
// Traverse diagonal that starts at [row][0], we start with the first column,
// because we will compare elements with the previous one, similar to how
// we did this for rows and columns
for (int column = 1; column < 7; ++column) {
// Coordinates an the diagonal change as [row + i][column + i],
// so we stop when column can get outside of the range
if (column + row >= 6) break;
if (field[row + column][column] != ' ' &&
field[row+column - 1][column - 1] == field[row + column][column])
++count;
else
count = 1;
if (count >= 4) return field[row + column][column];
}
}

// Now we need to do the same for diagonals that go from top-right to bottom-left
// There are diagonals, that starts on top of each column, let's check them
for (int column = 0; column < 7; ++column) {
int count = 0;
// Traverse diagonal that starts at [0][column], we start with the first row,
// because we will compare elements with the previous one, similar to how
// we did this for rows and columns
for (int row = 1; row < 6; ++row) {
// Coordinates an the diagonal change as [row + i][column + i],
// so we stop when column can get outside of the range
if (column - row < 0) break;
if (field[row][column-row] != ' ' &&
field[row - 1][column - row + 1] == field[row][column-row])
++count;
else
count = 1;
if (count >= 4) return field[row][column-row];
}
}

// There are diagonals, that starts on left of each row, let's check them
for (int row = 0; row < 6; ++row) {
int count = 0;
// Traverse diagonal that starts at [row][0], we start with the first column,
// because we will compare elements with the previous one, similar to how
// we did this for rows and columns
for (int column = 5; column >= 0; --column) {
// Coordinates an the diagonal change as [row + i][column + i],
// so we stop when column can get outside of the range
if (column - row < 0) break;
if (field[column - row][column] != ' ' &&
field[column - row - 1][column + 1] == field[column - row][column])
++count;
else
count = 1;
if (count >= 4) return field[column - row][column];
}
}

// Otherwise return character, which means nobody win in rows.
return ' ';
}

public static char getWinner(char[][] field) {
char winner = getWinnerInRows(field);
if (winner != ' ') return winner;
winner = getWinnerInColumns(field);
if (winner != ' ') return winner;
winner = getWinnerInDiagonals(field);
if (winner != ' ') return winner;

// Now we need to check if there are empty positions, otherwise it is a draw
for (int i = 0; i < field.length; ++i)
for (int j = 0; j < field[i].length; ++j)
if (field[i][j] == ' ') return ' ';

return 'D';
}

public static void printField(char[][] field) {
for (int row = 0; row < 6; ++row) {
System.out.print("| ");
for (int col = 0; col < 7; ++col)
System.out.print(field[row][col] + "| ");
System.out.println();
}

// Print bottom line
for (int col = 0; col < 7; ++col)
System.out.print("---");
System.out.println();
}

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// Declare field 2D array.
char[][] field = new char[6][7];

// Initialize with spaces
for (int i = 0; i < 6; ++i)
for (int j = 0; j < 7; ++j)
field[i][j] = ' ';
  
printField(field);

// This variable will alternate and mean whose turn is it. It is Red's turn now.
boolean isRed = true;
while (true) {
if (isRed)
System.out.println("Green's turn!");
else
System.out.println("Black's turn!");
System.out.print("Choose column (1-7) for a disk:");
// Read the position of turn and check if value is correct.
int column = input.nextInt();
if (column < 1 || column > 7) {
System.out.println("Column should be from 1 to 7");
continue;
}
// Try to put disk in a column, method returns false if the columns
// is filled and you cannot put a disk there.
if (!putDisk(field, column - 1, isRed ? '1' : '2')) {
System.out.println("This column is filled! Choose another one.");
continue;
}

printField(field);

// Get winner, this method returns 1 if Green win, 2 if Black wins, D
// if it is a draw and space character if we need to continue the game.
char result = getWinner(field);
if (result == 'D') {
System.out.println("It is a draw!");
break;
}
else if (result == '1') {
System.out.println("Green win!");
break;
}
else if (result == '2') {
System.out.println("Black win!");
break;
}
// Otherwise we just proceed to the next turn, we need to invert isRed
// to alternate turns.
isRed = !isRed;
}
}
}

Related Questions

Navigate

• Browse (All)
• Browse C
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.