This thread presents several exercises based around the game of Tic Tac Toe. We will consider that X always go first.
You are free to chose any way you like to represent the board, but for the sake of clarity we will represent by a 9 character string, like this: Each cell in the board is represents an index from 0 to 8 and its value is the corresponding index in the state string.

|---+---+---|
| 0 | 1 | 2 |
|---+---+---|
| 3 | 4 | 5 |
|---+---+---|
| 6 | 7 | 8 |
|---+---+---|

For instance, "XOX-X-OO-" represents the following board:

|---+---+---|
| X | O | X |
|---+---+---|
| - | X | - |
|---+---+---|
| O | O | - |
|---+---+---|

NB: Empty cells are marked "-".

Unlike the usual exercise threads, this time I'll suggest several different (albeit slightly dependent) exercises and you can chose whichever you want to work on.

Easy exercise
Write a program that takes a string representation of the board as an input and prints the matrix representation similar to the above quote. Example:

>>> print_matrix("XXOXOOXOX")
|---+---+---|
| X | X | O |
|---+---+---|
| X | O | O |
|---+---+---|
| X | O | X |
|---+---+---|

You can make this exercise more interesting by coming up with a way that will scale easily to a 1000x1000 matrix.

Math Exercise

Let's formalize the rules of the game. A board position is considered a "valid ending" if:

"X" wins.
"O" wins.
all the pieces of the board have been filled with no-one winning. It's a tie.

The goal of this exercise is to compare the success rate of "X" (first player to play) to the success rate of "O" and determine whether the player who starts has a statistical advantage.
"Success rate" is defined by "the number of total winning positions divided by the total number of valid endings".

Be careful when thinking about the total number of valid endings as certain conditions have to be taken into account. For instance here are examples of invalid endings:

"XXXOXXOOO": you cannot have 2 winners at once.
"XOOXOXOOX": since X starts, you cannot have more Os than Xs.
"XOOX--X-O": if X wins, there must be one X more than there are Os. (Remember X always starts)
...

The list goes on and it's up to you to develop a test to determine what constitutes a valid ending.

Note: If you work on this exercise, and since I don't have the solution (I just made it up), it'd be great if you included a short explanation text along with your code so we can discuss different approaches taken.

UI exercise
Write a simple 2 player Tic Tac Toe game. You have total freedom over the UI of the game. It could be something over the web or a JS script inside your browser or a native GUI app or a command line game or ... you come up with something!

AI exercise
Write a 1 player Tic Tac Toe game where the user plays against the AI.
You are asked to write this AI in such a way that it never loses. Remember that in this game, if both players behave optimally, the game will inevitably end in a draw. So your task is to write an AI that makes "no mistakes".
Your AI should be able to assume both "X" and "O" plays.

Use the UI developed in the above exercise so other players can play against your AI.

Note for devs interested in Functional Programming: This exercise was solved in a famous paper by John Hughes written in 1984. In this paper, titled "Why functional programming matters", the author makes a theoretical presentation of Functional Programming (using Miranda, an old language close to Haskell). The paper ends with the solving of a Tic Tac Toe puzzle. It's a great introduction to the paradigm, I strongly suggest you read it.
Re-implementing Hughes' solution in another language is considered an acceptable solution to this exercise.