Ndtyjky

I can't seem to figure out on how I should get my vertical move to work
My board is a nested list consisting of 6 lists with 6 elements in each.

I've been able to figure out my horizontal as well as my diagonal winning condition. But I can't wrap my head around the vertical one

This is my horizontal condition for example

#the list itself 

    board = [

            [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0],

            [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0],

            [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0],

            ]



def hor_condition(board, player):

    """the hor_condition checks whether the list contains necessary amount of checkers in order to call it a win"""

    for row in board:

        for cell in row:

            if row.index(cell) < 2:

                check_list = [row[row.index(cell)],

                              row[row.index(cell) + 1],

                              row[row.index(cell) + 2],

                              row[row.index(cell) + 3]

                              ]

                if check_list[0] == player and

                        check_list[1] == player and 

                        check_list[2] == player and 

                        check_list[3] == player:

                    return True

This here checks whether there are 4 of the same elements in the same row by a player in order to call it a win.
What I expect the vertical condition to do is to check if there are 4 of the same checkers in the same column

It might be painful to look at, but bear in mind that I've just started with python and I'm beginning to understand the basics.

I do not really ask for black on white code, rather a push in the right direction

I'd be glad to provide any further information if necessary! Thank you in advance!

Edit:
This is a bit late, but I would like to help anyone else who has had the same problem as I did. I eventually fixed my issue with the following:

def vert_condition(board, player):

"""The vert_condition iterates over the board and checks whether 4 vertical slots contain the same player input by

 with the help of a nested loop"""

for row in range(3):

    for col in range(6):

        if (board[row][col] == 

                board[row + 1][col] == 

                board[row + 2][col] == 

                board[row + 3][col] == player):

            return True

You could iterate in afor col in boardkind of way:

for col_index in range(6):

    col = [row[col_index] for row in board]

    for i in range(len(col) - 4 + 1):

        if all(col[i + j] == player for j in range(4)):

            return True

Since you can’t directly iterate over rows, iterate with an index counter - in this case a range(6) - and each time pull out the n-th element of each row to construct the column.

I suggest a small amendment to your code also:

Where you keep writing row.index(cell), this is a heavy computation so calculate it once and store it in a variable so you can re-use the result instead of continuously re-calculating it when you could just as easily store it.

To make it even better, use the all built-in which you provide an iterable and returns true if all elements are true.

In addition, you only need to check 6 - 4 + 1 (=3) times since....

• the first check covers 1st - 4th


• the second checks 2nd - 5th


• the third checks 3rd - 6th

And after that there’s no more as there isn’t a 7th cell in the row (and column). The calculation which I included in my code was:

len(row) - len(what’s being checked) + 1