Hi Mike! Thanks for the great course!

I just discovered that there are solutions for practice and I'm comparing my code with what you created! Thanks, it's interesting to see different approach than mine and other ways to solve things.

It took me whole day (literally) to code the Connect 4 game, but I'm quite pleased with it. I just finished this task so it way busy Sunday for me, but I think it was worth it. I have this first experience along with somewhat better understanding of the matter and also motivation to just try and code some other simple yet tricky stuff. I'm still not sure sometimes why things works or not and how excatly they are resolved, but with various iteration I got it done. The lecture about problem solving (the last one I watched) was really inspiring, and PyCharm is also helpful in finding all those small mistakes and typos.

I decided to write this program so the size of the board and victory condition (how many to connect) can be easy changed, so it was little more challenging and I essentialy had to use everything I learned so far and even research for more answers (I discovered slicing without which I couldn't done it). I couldn't take shortcuts and just list every posibilites or rely only on if elses, but it was fun! I see that you automated output for AI. I didn't think about that, so mine works as two player game.

If you want to review what I come up with, here is my code. I tried it and it works for different outcomes and with changed variables, but I'm not sure how to test it properly. But it's not very big program after all, if it works it works.

    # MAIN FUNCTION
def main():

    # GAME CONDITIONS
    # Names and colors of players can be changed, and also what empty space on the board should look
    players = ['Player', 'AI']
    colors = ['YEL', 'RED']
    empty = '___'
    # Here the victory condition can be changed - essentialy how many pieces need to be connected to win
    victory_condition = 4
    # Here size of the board can be adjusted - the game is impossible if either value is lower than victory condition
    board_height = 7
    board_width = 6
    board = build_board(board_height, board_width)

    # GREETING MESSAGE AND RULES EXPLANATION
    print()
    print('----------------------------------------')
    print('------------   ГРАВИТРИПС   ------------')
    print('----------------------------------------')
    print()
    print(f' FIRST PLAYER TO CONNECT {victory_condition} SPACES WINS! ')
    print()

    # ROUND STRUCTURE
    # Defining variables for functions of the game
    active_number = 0
    player = players[active_number]
    color = colors[active_number]
    # Checking for win condition
    while not check_win(board, color, victory_condition):
    # Determining player and color for the round
        player = players[active_number]
        color = colors[active_number]
    # Displaying board and active player's name
        show(board, empty)
        print()
        print(f"{player}'s turn!")
    # Taking input from the player
        if not take_input(board, color):
            print()
            print(f"Unsuitable number. Choose between 1 and {len(board) + 1}")
            print()
            continue
        print()
    # Changing seats between players before reseting the loop
        active_number = (active_number + 1) % len(players)

    # GAME OVER MESSAGE
    print()
    print(f"Game over, {player} WON!")
    print()
    show(board, empty)
    print()
    print(f"Congratulations, {player}!")

    # BUILDING THE BOARD
    # This creates simple grid filled with Nones based on variables for height and width.
def build_board(height, width):
    board = []
    for row in range(0, height):
        cells = []
        for column in range(0, width):
            cell = None
            cells.append(cell)
        board.append(cells)
    return board

    # VISUALISATION OF THE BOARD
    # The data is stored and added from the top, so the board displayed is actualy upside down!
def show(board, empty):

    for row_idx in reverse_board(board):
        print("|", end=" ")
        for cell in row_idx:
            color = cell if cell is not None else f"{empty}"
            print(color, end=" | ")
        print()

    # PLAYER INPUT
    # Player is only asked about the column so no problems here.
def take_input(board, color):

    # taking actual input
    column = int(input("Choose the column: "))
    column -= 1

    if column < 0 or column > len(board):
        return False

    cell = 0
    for row in board[column]:
        if row == None:
            board[column][cell] = color
            return True
        elif cell == len(reverse_board(board)) and row is not None:
            print("This column is full! Choose another.")
            continue
        else:
            cell += 1

    # CHECKING FOR WIN CONDITION
    # The code just notes each succeeding instance of active player's color in each possible line to check if there are four in a row.
def check_win(board, color, victory):

    color_in_a_line = 1
    orders = get_orders(board)

    for dimension_check in orders:
        for column_check in dimension_check:
            for cell_check in column_check:
                if cell_check is None:
                    color_in_a_line = 1
                    continue
                elif cell_check == color:
                    if color_in_a_line == victory:
                        return True
                    else:
                        color_in_a_line += 1
                        continue
                else:
                    color_in_a_line = 1
                    continue
    return False

    # GETTING POSSIBLE LINES TO CONNECT FOUR PIECES
    # While getting data from columns and rows is simple enough, transfering diagonals to similar format needed some more coding.
def get_orders(board):
    orders = []

    # win by columns
    orders.append(board)

    # win by rows
    orders.append(reverse_board(board))

    # win by diagonals
    diagonals = []
    full_board = [board, reverse_board(board), flip_board(board), reverse_board(flip_board(board)), convert_board(board), reverse_board(convert_board(board)), flip_board(convert_board(board)), reverse_board(flip_board(convert_board(board)))]
    for board_inx in range(0, len(full_board)):
        for diag_inx in range(0,len(full_board[board_inx])):
            diag = []
            for column in range(0,min(len(full_board[board_inx])-diag_inx,len(full_board[board_inx][diag_inx]))):
                cell = full_board[board_inx][column+diag_inx][column]
                diag.append(cell)
            diagonals.append(diag)
    orders.append(diagonals)

    return orders

    # GETTING POSSIBLE BOARD POSITIONS
    # Reason - the code for checking diagonals only goes in one direction and only in descending order. I chose to rotate the board in different ways so each diagonal would be inspected.
    # It's also useful and quicker for checking the rows and displaying the board (the data is stored in other way around to simplify the input).
def reverse_board(board):
    reversed = []
    for row_idx in range(0, len(board[0])):
        row=[]
        for column in range(0, len(board)):
            cell = board[column][row_idx]
            row.append(cell)
        reversed.append(row)
    reversed.reverse()
    return reversed

def flip_board(board):
    flipped = board[::-1]
    return flipped

def convert_board(board):
    converted = []
    for row in range(0, len(board)):
        cell = board[row][::-1]
        converted.append(cell)
    return converted

if __name__ == '__main__':
    main()

Add solutions for practice exercises? #1

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions