Sudoku Game Python Code Free Download

The Sudoku Game Python Code is one of all time’s most famous puzzle games. The main objective of the project is to fill a 4 range chart (i.e. 4×4 grid) with numbers so that every segment of the row, column, and 2 range contains all the numbers between 1 and 4. 

A Sudoku Game Code in Python is also a great brain game as a logic puzzle. Also, this game helps the players to improve their brain capacity. Some of the AI algorithms also has implemented for solving Sudoku game.

Project Information’s

Project Name:Sudoku Game In Python Source Code
Language/s Used:Python (GUI) Based
Python version (Recommended):2.x or 3.x
Database:None
Type:Python App
Developer:IT SOURCECODE
Updates:0
Sudoku Game – Project Information

This Game Project also includes a downloadable Sudoku Game In Python Source Code for free, just find the downloadable source code below and click to start downloading.

How To Play Sudoku Game In Python?

The goal of the Sudoku is to fill a 4 range chart (i.e. 4×4 grid) with numbers so that every segment of the row, column, and 2 range contains all the numbers between 1 and 4.

Sudoku Game in Python Code | Python...
Sudoku Game in Python Code | Python Projects Free Download with Source Code

4×4 grid will have some of the squares filled in at the beginning of the game. The player’s work is to fill in the missing digits and complete the grid using logic. The moves will be incorrect if:

  • Any row contains more than one of the same number from 1 to 4
  • Whichever column contains more than one of the same number from 1 to 4.
  • Any 2×2 grid contains more than one of the same number from 1 to 4.

To start executing a Sudoku Game Python Code, make sure that you have installed Python 3.9 and PyCharm in your computer.

Sudoku Game Python Code : Steps on how to run the project

Time needed: 5 minutes.

These are the steps on how to run Sudoku Game Python Code

  • Step 1: Download the given source code below.

    First, download the given source code below and unzip the source code.
    sudoku game download source code

  • Step 2: Import the project to your PyCharm IDE.

    Next, import the source code you’ve download to your PyCharm IDE.
    sudoku game open project

  • Step 3: Run the project.

    last, run the project with the command “py main.py”
    sudoku game run project

Install Libraries

import turtle
import random

Complete Source Code

import turtle
import random


# --------------- Made this function to set our coordinates and environment whenever we play ------------- #
def setWorld():
    turtle.setworldcoordinates(-100, -100, 100, 100)
    turtle.hideturtle()
    turtle.pensize(10)
    turtle.speed(0)
    turtle.pu()
    turtle.goto(-75, -75)


# ------------ A function to draw the outer large square ------------- #
def drawGrid():
    for i in range(2):
        turtle.fd(150)
        turtle.lt(90)
        turtle.fd(150)
        turtle.lt(90)


# ------------ A function to draw squares within the grid ---------#
def drawSquare():
    for i in range(2):
        turtle.fd(37.5)
        turtle.lt(90)
        turtle.fd(37.5)
        turtle.lt(90)


# ------------- A function to keep drawing squares and moving forward until it reaches a specific x-coordinate --------#
def move_turtle():
    turtle.pd()
    while not (turtle.xcor() >= 75):
        drawSquare()
        turtle.setx(turtle.xcor() + 37.5)


# ---------------- 'move_turtle()' draws squares in one row.  ---------------------- #
def make_box():
    row_boxes = 0
    turtle.sety(-37.5)
    while row_boxes != 4:
        move_turtle()
        turtle.setx(-75)  # Start making boxes from the left for each row
        turtle.sety(
            turtle.ycor() + 37.5)  # Once boxes are filled in one row, move y coordinate up. E.g (Makes boxes along row 'D', now  move up
        row_boxes += 1  # Do this until boxes are made in all four rows.
    turtle.pu()


# ------------- A function to label the grid -------------- #
def labelGrid():
    rows = ['A', 'B', 'C', 'D']
    cols = ['1', '2', '3', '4']

    for row_name in rows:
        turtle.write(row_name, move=False, align='left', font=('Georgia', 40, 'normal'))
        turtle.sety(turtle.ycor() - 40)

    turtle.goto(-65, 75)
    for col_name in cols:
        turtle.write(col_name, move=False, align='left', font=('Georgia', 40, 'normal'))
        turtle.setx(turtle.xcor() + 40)


# --------------- A function that uses the turtle class as an eraser ---------- #
def eraseEntry(puzzle):
    '''
    Takes in the puzzle
    Asks the user if they want to erase the entry before hand
    '''
    eraser = turtle.Turtle()
    eraser.hideturtle()
    eraser.speed(0)
    eraser.pu()

    ask_user = turtle.textinput('', 'Do you want to erase the previous entry? (y/n)')
    if ask_user in ['y', 'YES', 'yes']:
        eraser.goto(turtle.xcor() + 5,
                    turtle.ycor())  # I had to adjust where the eraser goes accordingly. By trial and error I just had to move it a bit
        eraser.pd()  # to the right.
        eraser.color('white', 'white')
        eraser.begin_fill()
        eraser.circle(10)  # Using a white circle to be my eraser
        eraser.end_fill()


def take_input(puzzle):
    grid_rows = ['A', 'B', 'C', 'D']
    grid_cols = ['1', '2', '3', '4']

    col_increment_size = [-60, -30, 10, 50]
    row_increment_size = [50, 10, -30, -60]

    user_input = turtle.textinput('', 'Enter Row and Column (e.g B4)')

    x_cor = 0
    y_cor = 0

    for r in range(0, len(grid_rows)):
        if grid_rows[r] == user_input[0]:  # First 'element' of the user's input will be the row. E.g B1
            y_cor = row_increment_size[r]

    for c in range(0, len(grid_cols)):
        if grid_cols[c] == user_input[1]:  # Second 'element' of the user's input will be the column.
            x_cor = col_increment_size[c]

    turtle.goto(x_cor, y_cor)

    # Appending the puzzle (which is a nested list)

    get_input = turtle.textinput('', 'Enter a number and make your move!')

    for i in range(0, len(grid_rows)):
        if user_input[0] == grid_rows[i]:
            for j in range(0, len(grid_cols)):
                if user_input[1] == grid_cols[j]:
                    if puzzle[i][j] != 0:  # Call the eraseEntry function and ask
                        eraseEntry(puzzle)  # Ask the user if they want to erase the entry where there isn't a zero
                    puzzle[i][j] = int(get_input)
                    make_move = turtle.write(get_input, move=False, align='left', font=('Arial', 35, 'normal'))

    return puzzle


def populatePuzzle(puzzle):
    '''
    Takes in a puzzle (which is a nested list)
    Returns the grid with the initial numbers inside
    '''

    col_increment_size = [-60, -30, 10, 50]  # Starts at A1 (-60,50), A2 (-30,50), A3 (10,50) .... D4 (50,-60)
    row_increment_size = [50, 10, -30, -60]

    for row in range(0, len(puzzle)):  # Enter the row
        for col in range(0, len(puzzle[row])):  # Enter the the row and which column the element belongs to
            if puzzle[row][col] != 0:  # If the initial base is not 0, populate the grid
                turtle.goto(col_increment_size[col], row_increment_size[row])
                turtle.write(puzzle[row][col], move=False, align='left', font=('Arial', 35, 'normal'))


def row_check(puzzle):
    '''
    Assumes that puzzle is a nested list
    Returns True if every element in the row is unique
    '''

    check = 0
    for row in range(0, len(puzzle)):
        if len(puzzle[row]) == len(set(puzzle[row])) and 0 not in puzzle[
            row]:  # Using the notion of sets, we look at the length of each row
            check += 1  # Check keeps track of how many rows (same for columns and box)
            # are unique. If all 4 are unique, return True.
    if check == 4:
        return True

    else:
        return 'Keep trying!'


def col_check(puzzle):
    '''
    Assumes that puzzle is a nested list
    Returns True if every element in the column is unique
    '''

    col_1 = [s[0] for s in puzzle]  # Turns each 'row' of the puzzle into a column. Kind of how you invert a matrice
    col_2 = [s[1] for s in puzzle]  # so for example. col_1 = [A1, B1, C1, D1], col_2 = [A2, B2, C2, D2] and so on.
    col_3 = [s[2] for s in puzzle]  # After the transformation is done, it applies the checker. The checker looks
    col_4 = [s[3] for s in puzzle]  # at the length of each column. If every number is unique len(set(col_1)) = 4 and
    all_col = [col_1, col_2, col_3, col_4]  # if that matches with our actual column return True.

    check = 0
    for col in range(0, len(all_col)):
        if len(all_col[col]) == len(set(puzzle[col])) and 0 not in all_col:
            check += 1

    if check == 4:  # 4 because 4 columns
        return True

    else:
        return 'Keep trying!'


def box_check(puzzle):
    '''
    Assumes that puzzle is a nested list
    Rearragnes the puzzle so that each 'row' is a box.
    '''

    box_1 = [s[0:2] for s in
             puzzle[0:2]]  # Transforming each row of the puzzle so that all elements are rearranged as boxes
    box_2 = [s[2:] for s in puzzle[0:2]]  # so for example, box_1 = [A1,A2,B1,B2], box_2 = [A3,A4,B3,B4] and so on
    box_3 = [s[0:2] for s in puzzle[2:]]
    box_4 = [s[2:] for s in puzzle[2:]]

    all_box = [box_1, box_2, box_3, box_4]

    check = 0

    for box in all_box:
        if len(box[0] + box[1]) == len(set(box[0] + box[1])) and 0 not in box[0] + box[1]:
            check += 1

    if check == 4:
        return True


    else:
        return 'Keep trying!'


# ----------------- A function to see if the board is filled ----------------- #
def isboardfilled(puzzle):
    '''
    Assumes puzzle is a nested list
    Returns True if the number of 'non_zero' elements match the puzzle
    '''

    non_zero = []
    for row in range(len(puzzle)):
        for el in range(len(puzzle[row])):
            if puzzle[row][el] != 0:
                non_zero.append(puzzle[row][el])
                if len(non_zero) == len(puzzle[row]) * len(
                        puzzle):  # len(puzzle[row]) -> Number of elements in each row
                    return True  # len(puzzle) -> Number of rows.
                    # Therefore total numbers = len(puzzle[row])* len(puzzle)


def replay():
    return turtle.textinput('', "Do you want to play again? (y/n)") in ['yes', 'y', "YES"]


# ------------------- Pick one of these random puzzles to start the game --------------------------- #

puzzle_1 = [[3, 4, 1, 2], [0, 0, 0, 0], [0, 0, 0, 0],
            [4, 2, 3, 1]]  # Solution: [[3,4,1,2],[2,1,4,3],[1,3,2,4],[4,2,3,1]]
puzzle_2 = [[4, 0, 0, 1], [0, 1, 3, 0], [0, 4, 1, 0],
            [1, 0, 0, 3]]  # Solution: [[4,3,2,1],[2,1,3,4],[3,4,1,2],[1,2,4,3]]
puzzle_3 = [[0, 0, 0, 0], [2, 3, 4, 1], [3, 4, 1, 2],
            [0, 0, 0, 0]]  # Solution: [[4,1,2,3],[2,3,4,1],[3,4,1,2],[1,2,3,4]]
puzzle_4 = [[0, 2, 4, 0], [1, 0, 0, 3], [4, 0, 0, 2],
            [0, 1, 3, 0]]  # Solution: [[3,2,4,1],[1,4,2,3],[4,3,1,2],[2,1,3,4]]
puzzle_5 = [[0, 4, 2, 0], [2, 0, 0, 0], [0, 0, 0, 3],
            [0, 3, 1, 0]]  # Solution: [[3,4,2,1],[2,1,3,4],[1,2,4,3],[4,3,1,2]]

all_puzzles = [puzzle_1, puzzle_2, puzzle_3, puzzle_4, puzzle_5]

# ---------------------------------------------   Start the game   ---------------------------------------------------------- #

while True:
    turtle.reset()  # Start with a clean canvas in case user wants to replay
    setWorld()
    game_won = False
    turtle.pd()
    drawGrid()

    # --------- Draw the lines in bold, across and down -------- #
    turtle.pu()
    turtle.goto(-75, 0)
    turtle.pd()
    turtle.fd(150)
    turtle.pu()
    turtle.goto(0, 75)
    turtle.lt(270)
    turtle.pd()
    turtle.fd(150)
    turtle.pu()

    # -------- Make the turtle go to the left ------------- #
    turtle.goto(-75, -75)

    turtle.pensize(2)
    make_box()
    turtle.goto(-95, 45)  # Start by going to the left top of the grid (Labeling starts with 'A', 'B'... etc)
    labelGrid()
    game_puzzle = all_puzzles[random.randint(0, 4)]  # Pick a random puzzle to start the game
    populatePuzzle(game_puzzle)

    while game_won != True:
        take_input(game_puzzle)

        if isboardfilled(game_puzzle):
            confirm_sol = turtle.textinput('', 'Are you sure you want to submit this solution? (y/n)')
            if confirm_sol in ['yes', 'y', 'YES']:
                if row_check(game_puzzle) == col_check(game_puzzle) == box_check(game_puzzle) == True:
                    turtle.textinput('', 'Congratulations you have won! (Press any key to continue)')
                    game_won = True
                else:
                    turtle.textinput('', "Your solution is incorrect. Keep trying! (Press any key to continue)")

    if not replay():
        break

turtle.done()

Download Source Code below

Summary

Sudoku Game is one of all time’s most famous puzzle games. The main objective of the Sudoku is to fill a 4 range chart (i.e. 4×4 grid) with numbers so that every segment of the row, column, and 2 range contains all the numbers between 1 and 4.

This game is also a great brain game as a logic puzzle. This system is a web-based application that is built in python. Besides, players will quickly begin to see improvements in their concentration and general brainpower if they are able to play Sudoku regularly (i.e. daily).

Inquiries

If you have any questions or suggestions about Sudoku Game Python Code, please feel free to leave a comment below.

Leave a Comment