Java Bootcamp – Workbooks and Challenges
)}

# Tic Tac Toe -- Part 3

If you made it here, then your game lets a player pick a spot on the board:

It also doesn't let them pick a spot that's already taken.

Onto the most exciting part! You will write code that determines the winner.

## The `checkWin()` function

This function has to check for a win in every row:

every column:

the left diagonal:

and the right diagonal:

## Task 6: Write the function

1. Function name: The name of the function is `checkWin()`. It will determine the winner.

``````/**
* Function name - checkWin <-------
* @param board (char[][])
* @return count (int)
*
* Inside the function:
*   1. Make a count variable that starts at 0.
*   2. Check every row for a straight X/O  (Task 7)
*   3. Check every column for a straight X/O  (Task 8)
*   4. Check the left diagonal for a straight X/O  (Task 9).
*   5. Check the right diagonal for a straight X/O  (Task 10).
*/
``````

2. Parameters: The function takes one parameter: `char[][] board`.

``````/**
* Function name - checkWin
* @param board (char[][]) <--------
* @return count (int)
*
* Inside the function:
*   1. Make a count variable that starts at 0.
*   2. Check every row for a straight X/O  (Task 7)
*   3. Check every column for a straight X/O  (Task 8)
*   4. Check the left diagonal for a straight X/O  (Task 9).
*   5. Check the right diagonal for a straight X/O  (Task 10).
*/
``````

3. Return value: The function returns a count.

``````/**
* Function name - checkWin
* @param board (char[][])
* @return count (int) <----------
*
* Inside the function:
*   1. Make a count variable that starts at 0.
*   2. Check every row for a straight X/O  (Task 7)
*   3. Check every column for a straight X/O  (Task 8)
*   4. Check the left diagonal for a straight X/O  (Task 9).
*   5. Check the right diagonal for a straight X/O  (Task 10).
*/
``````

Inside the function, make a count variable that starts at `0`. This count will determine who won the game.

``````/**
* Function name - checkWin
* @param board (char[][])
* @return count (int)
*
* Inside the function:
*   1. Make a count variable that starts at 0. <-------
*   2. Check every row for a straight X/O  (Task 7)
*   3. Check every column for a straight X/O  (Task 8)
*   4. Check the left diagonal for a straight X/O  (Task 9).
*   5. Check the right diagonal for a straight X/O  (Task 10).
*/
``````

As you write the function, you'll need to call it from your `for` loop in `main`. The loop should break if the returned count is 3 or -3.

``````Task 6 - Call the function﻿.
if (returned count == 3﻿) {
1. print: X wins
2. break the loop
} else if (returned count == -﻿3﻿) {
1. print: O wins
2. break the loop
}``````

In essence, this checks for a winner after every turn.

## Task 7: Checking every row

Everything inside the function is its own task. First, the function will check every row for a straight X or straight O.

``````/**
* Function name - checkWin
* @param board (char[][])
* @return count (int)
*
* Inside the function:
*   1. Make a count variable that starts at 0.
*   2. Check every row for a straight X/O  (Task 7) <-----
*   3. Check every column for a straight X/O  (Task 8)
*   4. Check the left diagonal for a straight X/O  (Task 9).
*   5. Check the right diagonal for a straight X/O  (Task 10).
*/
``````

Your outer loop must run through each row while the inner loop runs through every character in that row.

In each row, add 1 to `count` if there's an X. Subtract 1 if there's an O.

If `count` isn't 3 or -3, reset it and move to the next row.

A count of 3 means X won (conversely, a count of -3 means O won).

If `count` is 3 OR -3, break the `checkWin` function by returning `count`.

Notice that the game stops after a win.

## Task 8: Checking every column

If none of the rows result in a count of 3 or -3, reset the count to 0 (important).

Now, check every column for a count of 3 or -3.

``````/**
* Function name - checkWin
* @param board (char[][])
* @return count (int)
*
* Inside the function:
*   1. Make a count variable that starts at 0.
*   2. Check every row for a straight X/O  (Task 7)
*   3. Check every column for a straight X/O  (Task 8) <------
*   4. Check the left diagonal for a straight X/O  (Task 9).
*   5. Check the right diagonal for a straight X/O  (Task 10).
*/
``````

Hints:

• The outer loop picks a column. The inner loop will index each row for that column.

• When looking at the image below, think of `i` and `j`.

A player wins if one of the columns results in a `count` of 3 or -3:

Test every column before you move to Task 9.

## Task 9: Checking the left diagonal

If none of the rows or columns result in a count of 3 or -3, reset the count to 0.

Now, check the left diagonal for a straight X or O.

``````/**
* Function name - checkWin
* @param board (char[][])
* @return count (int)
*
* Inside the function:
*   1. Make a count variable that starts at 0.
*   2. Check every row for a straight X/O  (Task 7)
*   3. Check every column for a straight X/O  (Task 8)
*   4. Check the left diagonal for a straight X/O  (Task 9). <-------
*   5. Check the right diagonal for a straight X/O  (Task 10).
*/
``````

Hints:

• Do you see a pattern in the indices?

• You don't need a nested loop. Use a single `for` loop.

Output:

## Task 10: Checking the right diagonal

If none of the rows, columns, or left diagonal result in a win, reset the count to 0.

Now, check the right diagonal for a straight X or O.

``````/**
* Function name - checkWin
* @param board (char[][])
* @return count (int)
*
* Inside the function:
*   1. Make a count variable that starts at 0.
*   2. Check every row for a straight X/O  (Task 7)
*   3. Check every column for a straight X/O  (Task 8)
*   4. Check the left diagonal for a straight X/O  (Task 9).
*   5. Check the right diagonal for a straight X/O  (Task 10). <------
*/
``````

Hint:

• You don't need a nested loop. Use a single `for` loop.

• The pattern here is a bit tricky:

• 2 - 0 = 2

• 2 - 1 = 1

• 2 - 2 = 0

Compare the bolded numbers from the hint to the indices below:

Output:

## Task 11: What if it's a tie?

If the game goes all nine turns and nobody wins, print: "it's a tie!".

Test your code for every type of win:

• straight row

• straight column

• left diagonal

• right diagonal.

Test each case for X and O. Also, see if your code works in the event of a tie.

If everything works, you have my sincere congratulations! Tic tac toe is not an easy project, and going through this challenge is a strong testament to your growth.

## Good Luck!

##### Related Course: The Complete Spring Boot Development Bootcamp – Become a Java Web Developer

Feedback Summary
4.7
43 students
5

91%
4

2%
3

0%
2

0%
1

7%
Written Reviews
There are no written reviews yet.