Best Sudoku Generator Python Code 2025

Sharing is caring!

Introduction

The goal of this project is to develop a Sudoku generator using Python that generates both the puzzle and its solution, displaying them as images.

By leveraging Python’s robust libraries and incorporating visual elements, we can elevate the classic Sudoku-solving experience.

Whether you’re eager to test your problem-solving abilities or just want to appreciate the game visually, this tool offers a fun and interactive way to engage with Sudoku, making it enjoyable and accessible for everyone.

sudoku generator
solve a sudoku
solve the sudoku
sudoku print
print sudoku
printable sudoku
free printable sudoku
sudoku solver python
sudoku solver in python
solve sudoku python
sudoku solver algorithm python

Python Code for Sudoku Puzzle and Solution Generator

You can adjust the Python code to create both the Sudoku puzzle and its solution by saving a copy of the fully completed board before you start removing numbers to form the puzzle.

This approach ensures that you have easy access to both the solution and the puzzle itself. Here is the code:

import numpy as np
import random

def pattern(r, c):
    return (3 * (r % 3) + r // 3 + c) % 9

def shuffle(s):
    return random.sample(s, len(s))

def generate_sudoku():
    base = 3
    side = base * base

    # Generate a pattern for a baseline valid solution
    rBase = range(base)
    rows = [g * base + r for g in shuffle(rBase) for r in shuffle(rBase)]
    cols = [g * base + c for g in shuffle(rBase) for c in shuffle(rBase)]
    nums = shuffle(range(1, base * base + 1))

    # Produce board using randomized baseline pattern
    board = [[nums[pattern(r, c)] for c in cols] for r in rows]

    return board

def remove_numbers(board, remove_count=30):
    # Create a copy of the board to keep the solution
    puzzle_board = [row[:] for row in board]
    
    # Randomly remove 'remove_count' numbers to create the puzzle
    count = 0
    while count < remove_count:
        row = random.randint(0, 8)
        col = random.randint(0, 8)
        if puzzle_board[row][col] != 0:
            puzzle_board[row][col] = 0
            count += 1
    return puzzle_board

def print_board(board):
    for row in board:
        print(" ".join(str(num) if num != 0 else '.' for num in row))

if __name__ == "__main__":
    sudoku_solution = generate_sudoku()
    sudoku_puzzle = remove_numbers(sudoku_solution, remove_count=40)  # Adjust remove_count for difficulty

    print("Sudoku Puzzle:")
    print_board(sudoku_puzzle)
    print("\nSudoku Solution:")
    print_board(sudoku_solution)

free printable sudoku puzzles
sudoku puzzles printable free
printable sudoku puzzles pdf
generate sudoku
sudoku algorithm python
how to generate sudoku puzzles

Explain the Python Code for Sudoku

pattern Function: Establishes the template for crafting a legitimate Sudoku solution.

shuffle Function: Randomizes the arrangement of rows, columns, and digits to produce various unique Sudoku puzzles.

generate_sudoku Function: Creates a full and valid Sudoku solution by utilizing the pattern and shuffle functions.

remove_numbers Function: Takes a finished Sudoku solution and randomly eliminates a designated number of digits to form the puzzle, ensuring a copy of the board is made to preserve the solution.

print_board Function: Displays the Sudoku board in the console, using dots to indicate empty spaces.

if name == “main”: This section of code kicks off the puzzle generation process and shows both the puzzle and its corresponding solution.

generating sudoku puzzles
sudoku algorithm generator
sudoku generator algorithm
py sudoku
py-sudoku
sudoku in python
sudoku algorithm python
sudoku program in python
how are sudoku puzzles generated
how to generate sudoku puzzle
how to generate a sudoku puzzle

Usage

Execute the code in a Python environment. It will create a Sudoku puzzle and display both the puzzle and its solution.

You can modify the remove_count parameter in the remove_numbers function to change the puzzle’s difficulty. Raising this number will increase the challenge.

Output of Sudoku Generator Python

When you run the code, you will get a Sudoku puzzle with some cells removed and the complete solution. It will look something like this:

Sudoku Puzzle

Sudoku Solution

random sudoku generator
sudoku generator python
python sudoku generator
sudoku generator and solver
sudoku generator solver
sudoku maker and solver
sudoku python solver
sudoku solver generator
sudoku board generator
javascript sudoku
sudoku javascript
sudoku solver python code

Code to Add for Image Generation

To create images of the Sudoku puzzle and its solution, you can use the PIL (Python Imaging Library), also known as Pillow, to generate images with the numbers displayed in a grid format.

First, ensure you have the Pillow library installed. You can install it using pip:

pip install Pillow

Then, add the following code to the existing Sudoku generator script to generate and save the puzzle and solution as images:

from PIL import Image, ImageDraw, ImageFont

def create_sudoku_image(board, filename):
    cell_size = 60  # Size of each cell in the Sudoku grid
    grid_size = cell_size * 9  # Total size of the grid
    line_width = 2  # Thickness of the grid lines

    # Create a new blank image with a white background
    image = Image.new("RGB", (grid_size, grid_size), "white")
    draw = ImageDraw.Draw(image)

    # Load a font
    try:
        font = ImageFont.truetype("arial.ttf", 36)
    except IOError:
        font = ImageFont.load_default()

    # Draw the grid lines
    for i in range(10):
        line_weight = line_width if i % 3 == 0 else 1  # Thicker lines for 3x3 blocks
        # Horizontal line
        draw.line((0, i * cell_size, grid_size, i * cell_size), fill="black", width=line_weight)
        # Vertical line
        draw.line((i * cell_size, 0, i * cell_size, grid_size), fill="black", width=line_weight)

    # Draw the numbers
    for r in range(9):
        for c in range(9):
            num = board[r][c]
            if num != 0:
                x = c * cell_size + cell_size // 3
                y = r * cell_size + cell_size // 6
                draw.text((x, y), str(num), fill="black", font=font)

    # Save the image
    image.save(filename)

if __name__ == "__main__":
    sudoku_solution = generate_sudoku()
    sudoku_puzzle = remove_numbers(sudoku_solution, remove_count=40)

    print("Sudoku Puzzle:")
    print_board(sudoku_puzzle)
    print("\nSudoku Solution:")
    print_board(sudoku_solution)

    # Create images
    create_sudoku_image(sudoku_puzzle, "sudoku_puzzle.png")
    create_sudoku_image(sudoku_solution, "sudoku_solution.png")

    print("Sudoku puzzle and solution images have been saved as 'sudoku_puzzle.png' and 'sudoku_solution.png'.")

sudoku js
python sudoku code
sudoku code in python
sudoku code python
sudoku python code
sudoku generator printable
sudoku maker printable
sudoku solution generator
sudoku answers generator
sudoku generator api
sudoku generator pdf
sudoku solving algorithm python

Explanation of the Added Code

The create_sudoku_image function is designed to take a Sudoku board and a filename as input, generating an image of the Sudoku board and saving it with the specified filename.

It begins by adjusting the size of each cell and the overall grid, ensuring that thicker lines are used for the boundaries of the 3×3 blocks to enhance clarity.

The function then employs the ImageDraw object to draw lines, effectively creating the grid structure on the image. To populate the grid, the function places the numbers from the Sudoku board into their respective cells. Any empty cells are simply left blank, without numbers.

After defining how the grid and numbers are drawn, the create_sudoku_image function is executed twice:

once for the Sudoku puzzle and once for its solution. This results in two separate PNG image files being saved, named sudoku_puzzle.png and sudoku_solution.png.

To use this functionality, you should run the modified script, which will automatically generate and save these image files.

These files will visually represent both the Sudoku puzzle and its corresponding solution. For everything to work smoothly, make sure that the Pillow library is installed and accessible in your Python environment.

By following these steps, you will be able to view visual representations of the Sudoku puzzle and its solution as image files.

Usage

Run the modified script. It will generate and save two image files: sudoku_puzzle.png and sudoku_solution.png, which contain the visual representations of the puzzle and its solution.

Ensure that you have the Pillow library installed and accessible from your Python environment.

This will give you visual representations of both the Sudoku puzzle and its solution, which can be viewed as image files.

sudoku pdf generator
sudoku grid generator
sudoku generator javascript
javascript sudoku generator
javascript sudoku solver
sudoku solver javascript
sudoku solver js
sudoku online generator
online sudoku generator
python sudoku solver

Sudoku Solver Algorithm Python

Here’s a Python implementation of a Sudoku solver using the backtracking algorithm. This algorithm is a common method for solving Sudoku puzzles and works by trying to fill in the empty cells one at a time and backtracking when it encounters a conflict.

Python Code for Sudoku Solver

def is_valid(board, row, col, num):
    # Check if the number is not repeated in the row
    for x in range(9):
        if board[row][x] == num:
            return False

    # Check if the number is not repeated in the column
    for x in range(9):
        if board[x][col] == num:
            return False

    # Check if the number is not repeated in the 3x3 sub-grid
    start_row = row - row % 3
    start_col = col - col % 3
    for i in range(3):
        for j in range(3):
            if board[i + start_row][j + start_col] == num:
                return False

    return True

def solve_sudoku(board):
    empty = find_empty_location(board)
    if not empty:
        return True  # Puzzle solved

    row, col = empty

    for num in range(1, 10):
        if is_valid(board, row, col, num):
            board[row][col] = num

            if solve_sudoku(board):
                return True

            # If placing num doesn't lead to a solution, reset and backtrack
            board[row][col] = 0

    return False

def find_empty_location(board):
    for i in range(9):
        for j in range(9):
            if board[i][j] == 0:
                return (i, j)
    return None

def print_board(board):
    for row in board:
        print(" ".join(str(num) if num != 0 else '.' for num in row))

# Example Sudoku puzzle (0 represents empty cells)
sudoku_board = [
    [5, 3, 0, 0, 7, 0, 0, 0, 0],
    [6, 0, 0, 1, 9, 5, 0, 0, 0],
    [0, 9, 8, 0, 0, 0, 0, 6, 0],
    [8, 0, 0, 0, 6, 0, 0, 0, 3],
    [4, 0, 0, 8, 0, 3, 0, 0, 1],
    [7, 0, 0, 0, 2, 0, 0, 0, 6],
    [0, 6, 0, 0, 0, 0, 2, 8, 0],
    [0, 0, 0, 4, 1, 9, 0, 0, 5],
    [0, 0, 0, 0, 8, 0, 0, 7, 9]
]

if solve_sudoku(sudoku_board):
    print("Sudoku solved successfully!")
    print_board(sudoku_board)
else:
    print("No solution exists.")

is_valid(board, row, col, num): This function checks whether it’s permissible to place a number in a given cell. It verifies that the number does not already exist in the same row, column, or 3×3 sub-grid.

solve_sudoku(board): This function employs a backtracking approach to resolve the Sudoku puzzle. It attempts to fill in numbers in the vacant cells and retraces its steps if it runs into any issues.

find_empty_location(board): This function locates an empty cell on the Sudoku board. It returns the position of the empty cell or None if all cells are filled.

print_board(board): This function displays the Sudoku board in a clear format, substituting 0 with a dot to indicate empty cells.

Usage: Substitute sudoku_board with your Sudoku puzzle, using 0 to indicate empty cells. When you run the script, it will try to solve the puzzle and display the completed board if a solution is found.

Conclusion

To sum up, the improved Python code for generating Sudoku puzzles does more than just create the puzzles and their solutions; it also transforms them into visual formats using images.

By utilizing the Pillow library, we can design the Sudoku grid, fill it with numbers, and save it as image files. This method offers a straightforward and engaging way to engage with Sudoku puzzles, making them easy to share and visually attractive.

With both the puzzle and its solution presented as images, users can fully enjoy an interactive Sudoku experience.

Frequently Asked Questions (FAQ)

What is this Sudoku generator?

This Sudoku generator not only creates puzzles but also provides their solutions, displaying them as images. It utilizes Python to generate a valid Sudoku puzzle, removes certain numbers to form the challenge, and then transforms both the puzzle and its solution into PNG image files.

How does the Sudoku generator work?

The generator produces a full Sudoku solution by following a specific pattern and applying random shuffling. After that, it eliminates a certain number of cells to create the puzzle. Utilizing the Pillow library, the code illustrates the Sudoku grid and its numbers on an image, ultimately saving the finished product as PNG files.

What are the requirements to run this code?

To get started, make sure you have Python installed on your computer, along with the Pillow library. You can easily install Pillow by running the command pip install Pillow in your terminal. Just double-check that your environment is ready for image processing tasks!

How do I adjust the difficulty of the Sudoku puzzle?

The level of difficulty in Sudoku is determined by how many cells are taken out from the finished solution. You can adjust the remove_count parameter in the remove_numbers function to change the number of cells that get cleared, making the puzzle either simpler or more difficult.

Can I customize the appearance of the Sudoku images?

Yes! You have the option to personalize the look by modifying settings like cell size, font size, and line thickness within the create_sudoku_image function. Plus, you can select various fonts or colors to match your style.

Where can I find the generated images?

The images created are stored as sudoku_puzzle.png and sudoku_solution.png in the same folder where you executed the script. You can view these files using any image viewer to see how the puzzle and its solution look.

How can I modify the script for different Sudoku board sizes?

The existing script is tailored for traditional 9×9 Sudoku puzzles. To modify it for various sizes, you’ll need to change the grid dimensions, cell sizes, and the logic for generating patterns to fit the new board dimensions.

Can this code be used to solve Sudoku puzzles?

The existing setup is centered around creating puzzles and their solutions. To tackle Sudoku puzzles, you would need to develop a Sudoku solver algorithm, which involves a different approach that includes methods such as backtracking or constraint propagation.

Can AI play Sudoku?

Yes, AI is capable of playing Sudoku! It utilizes various algorithms, such as constraint satisfaction and backtracking, along with more sophisticated methods like machine learning, to solve Sudoku puzzles effectively. Additionally, AI can be designed to either tackle existing puzzles or create new ones.

How do Sudoku generators work?

Sudoku generators start by crafting a complete and valid solution through a unique pattern and shuffling technique. To form the actual puzzle, they eliminate a specific number of cells from this solution, making sure that the puzzle can still be solved. Finally, the outcome is presented as an image.

How to create Sudoku?

To make a Sudoku puzzle, begin by crafting a fully filled and valid Sudoku grid. This means populating the board while adhering to the rules of Sudoku. Once you have your complete grid, take out a few numbers to create the puzzle, making sure it stays solvable and has a unique solution. If you like, you can also visualize and save the puzzle as an image.