Tic-Tac-Toe in 1 Line of Python

Feb 8, 2026 4 min read

Building up to tic-tac-toe in one line of purely functional Python.

Haskell Déjà vu

A while back I decided to learn Haskell, since functional programming looked cool. For example, here is Quicksort in Haskell, taken from these fantastic lectures:

1
sort []     = []
2
sort (x:xs) = sort ls ++ [x] ++ sort rs
3
  where
4
    ls      = [ l | l <- xs, l <= x ]
5
    rs      = [ r | r <- xs, x <  r ]

Learning Haskell also gave me a sense of déjà vu back to when I first saw list comprehensions and lambda functions in Python:

1
quicksort = lambda arr:
2
    arr if len(arr) <= 1
3
    else quicksort([x for x in arr[1:] if x <= arr[0]]) + [arr[0]]
4
       + quicksort([x for x in arr[1:] if x > arr[0]])

Sure, the above code used a lot of things a pure lambda calculus would never use. But this got me thinking – just how far can you go with functional Python?

Building up to “Tic-Tac-Toe”

At around the same time, I was taking part in a series of coding challenges. That week’s challenge was to implement tic-tac-toe in Python with one additional feature. I decided to code golf it and implement it in one line of Python.

Setting some ground rules

Originally, I wanted to only use functions, and use encodings like the ones below to get things like if statements:

1
True = lambda x,y: x
2
False = lambda x,y: y
3
Ife = lambda b,x,y: b(x,y)

However, I soon realized just how painful this would be. Indeed, Haskell, which is often referred to as a purely functional language, abstracts these details away. The book A Gentle Introduction to Haskell states

Because Haskell is a purely functional language, all computations are done via the evaluation of expressions (syntactic terms) to yield values (abstract entities that we regard as answers). Examples of expressions include atomic values such as the integer 5, the character ‘a’, and the function \x -> x+1, as well as structured values such as the list [1,2,3] and the pair (‘b’,4).

Thus, I’m going to allow myself usage of atomic types, strings, lists, and tuples, alongside functions. I’ll also allow for if its in the form of a list comprehension.

Evaluating expressions

The biggest hurdle now is that there’s no clear way to run this cursed code. That is, suppose I write in the Python repl

1
>>> lambda _:'Hello World'
2
<function <lambda> at 0x102d1f520>

How can I evaluate such a function? Sure, there’s the obvious

1
>>> a = lambda _:'Hello World'
2
>>> a(_)
3
'Hello World'

But this takes two lines. Instead, we can pass it into another function and call it that way:

1
>>> (lambda _:_(_)) (lambda _:'Hello World')
2
'Hello World'

Let’s take a moment to digest what (lambda _:_(_)) (lambda _:'Hello World') means.

First lambda _:_(_) is a function, that given an input function, will call said input function on itself. So a = lambda _:_(_) is equivalent to

1
def a(f):
2
    return f(f)

I think of this as a baseless, pseudo-recursion. Indeed,

1
>>> a = lambda _:_(_)
2
>>> a(a)
3
Traceback (most recent call last):
4
  File "<stdin>", line 1, in <module>
5
  File "<stdin>", line 1, in <lambda>
6
  File "<stdin>", line 1, in <lambda>
7
  File "<stdin>", line 1, in <lambda>
8
  [Previous line repeated 996 more times]
9
RecursionError: maximum recursion depth exceeded

As such

1
>>> (lambda _:_(_))(print("Hello World"))
2
Hello World
3
Traceback (most recent call last):
4
  File "<stdin>", line 1, in <module>
5
  File "<stdin>", line 1, in <lambda>
6
TypeError: 'NoneType' object is not callable

because print() in Python returns None and you cannot call None(). However

1
>>> (lambda _:_(_))(lambda _:print("Hello World"))
2
Hello World

works without issue. This is because the second lambda is callable and ignores its input, so evaluating it calls print("Hello World") and then stops.

If statements

If statements can be done in one line using and and or. The syntax is roughly

1
(condition) and \
2
    (then statement) \
3
or (else statement)

If (condition) is true, and will attempt to evaluate the (then statement), including executing print().

If (condition) is false, and will short-circuit, skipping (then statement). The and will return false. Afterwards, or will evaluate (else statement).

Variables

Python 3.8 introduces the assignment expression :=. With this, I can define local variables with

1
(var name) := (var value),
2
(expression)

Modifying data structures

Given a list lst, we can change the value of index i by creating a new list:

1
lst[:i] + [(new value)] + lst[i+1:]

This new list can be named as a variable or passed into another function. Unfortunately, this does allocate a whole new list in memory.

Tic-Tac-Toe in one line

As the previous lambda _:_(_) also functions as a loop, we actually have everything we need to assemble tic-tac-toe in one line of Python:

(lambda f: f(f))(lambda f, w=int(input("Input the size of the board: ")):(lambda game:game(game, ['   '] * (w * w), 0))(lambda game, b, t: (print('\n' + '\n'.join(['|' + '|'.join(b[i * w:(i + 1) * w]) + '|' for i in range(w)]) + '\n'), (any([all(s == b[i * w] != '   ' for s in b[i * w:(i + 1) * w]) for i in range(w)] + [all(s == b[i] != '   ' for s in b[i::w]) for i in range(w)] + [all(b[i * (w + 1)] == b[0] != '   ' for i in range(w))] + [all(b[(i + 1) * (w - 1)] == b[w - 1] != '   ' for i in range(w))]) and (print(f"Player {['X', 'O'][(t - 1) % 2]} wins!") or 1)) or (t == w * w and (print("It's a tie!") or 1)) or ((p := [' X ', ' O '][t % 2], i := int(input(f'Player {p}, choose 0-{w * w - 1}: ')), b[i] == '   ' and game(game, b[:i] + [p] + b[i + 1:], t + 1)) or (print('Invalid move!'), game(game, b, t))))))

Here’s the code with indents, comments, and escape characters:

1
# Self-application trick from above
2
(lambda f: f(f)\
3
# Read board size and create recursive board function
4
)(lambda f, w=int(input("Input the size of the board: ")):\
5
    # Define a game loop and call it with an empty w*w board and t=0 turns.
6
    (lambda game:game(game, ['   '] * (w * w), 0))\
7
    # The recursive game loop
8
    (lambda game, b, t: \
9
        # Print the board as w rows, with columns separated by "|"
10
        (print(\
11
            '\n' \
12
            + '\n'.join(['|' + '|'.join(b[i * w:(i + 1) * w]) \
13
            + '|' for i in range(w)]) \
14
            + '\n'), \
15
        (\
16
            # Check the win condition
17
            any(\
18
                # Check if any row is not empty and all equal
19
                [all(s == b[i * w] != '   ' for s in b[i * w:(i + 1) * w]) for i in range(w)] \
20
                # Check if any column is not empty and all equal
21
                + [all(s == b[i] != '   ' for s in b[i::w]) for i in range(w)] \
22
                # Check if the diagonal is not empty and all equal
23
                + [all(b[i * (w + 1)] == b[0] != '   ' for i in range(w))] \
24
                # Check if the anti-diagonal is not empty and all equal
25
                + [all(b[(i + 1) * (w - 1)] == b[w - 1] != '   ' for i in range(w))] \
26
            # If any win condition above is true,
27
            #   then evaluate the print below
28
            #   else continue and do not evaluate the print
29
            ) and (\
30
                print(f"Player {['X', 'O'][(t - 1) % 2]} wins!") or 1 \
31
            )\
32
        )\
33
        # If no win, check for tie:
34
        or (\
35
            # If t turns have passed
36
            t == w * w \
37
            # then evaluate the print expression
38
            and (print("It's a tie!") \
39
            # else evaluate true and move on
40
            or 1) \
41
        )\
42
        # If no win nor tie, take a move
43
        or (
44
            (\
45
            # Define p as current player's mark
46
            p := [' X ', ' O '][t % 2], \
47
            # Define i as the index player wants to write to
48
            i := int(input(f'Player {p}, choose 0-{w * w - 1}: ')), \
49
            # If the input is valid and cell is empty
50
            0 <= i < w*w and b[i] == '   ' \
51
            #   then recurse with the updated board
52
            and game(game, b[:i] + [p] + b[i + 1:], t + 1) \
53
            )\
54
            #   else print error and recurse without changing state
55
            or (print('Invalid move!'), game(game, b, t) \
56
        )))\
57
    )\
58
)

Reflections

Honestly, outside of challenges, no one should implement recursion, expressions, if statements, and variables in the way we have done above, both for its bad (memory) performance and readability reasons.

That said, I had fun putting together the above game. I hope you enjoyed this little code golfing journey too.