Alright, have a solution for you/can explain your problem @ShreyashKarnik!

The Problem:

The issue in code comes from the chunk below:

while digit <= n:
    row_count = 0
    col_count = 0
    v = 0
    while v < n:
        x = 0
        while x < n:
            print ("Check")
            if digit == sudo_board[v][x]:
                row_count = row_count + 1
            if digit == sudo_board[x][v]:
                col_count = col_count + 1
            x = x + 1
        v = v + 1
    if col_count != 1 or row_count != 1:
        return False

So what exactly is this code doing? It’s going through every cell in your sudoku board and looking for a digit. For the sake of explanation, let’s say it’s looking for the digit 1. It checks every cell in the entire board, and since 1 appears 4 times total, col_count and row_count will be 4 every time. You can verify this with a print statement if you’d like!

Since your false check is checking against the number 1, it’s going to fail every time. So let’s start looking for a fix!

Making Things Pythonic

"Pythonic means code that doesn't just get the syntax right but that follows the conventions of the Python community". You say you’re new to programming, so learning the proper style of how to write python is important. You have a couple of issues in the code above:

• Confusing variable names
• Using while loops instead of for loops
• Lack of code modularity

Let’s start with the last comment, lack of modularity and fix the other things along the way. Determining if a Sudoku grid is valid is actually surprisingly complex — it has three components.
1. Do all of the rows have the right number of digits?
2. Do all of the columns have the right number of digits?
3. Does the grid as a whole have the right number of digits?

3 is actually a factor of 1 and 2, which you figured out in your code — nice! But it might make things easier to read if we broke the first and second bit of things into their own functions. How might those look? Let’s do rows first. For our function, we’ll check each row and confirm that it has the right number of digits.

Let’s start with the row checker. All we have to do for that is the following:

def has_correct_number_rows(sudo_board):
    # the set we create below is an unordered grouping of the numbers
    # 1-4.
    correct_set = set(range(1, len(sudo_board)))
    for row in sudo_board:
        # this if statement checks if our row contains values 1-4
        if (correct_set != set(row)):
            return False
    return True

This will return True if the rows all contain the correct number of items, otherwise it will give false.

Next, the checking the correct number of columns. This is slightly more complicated, but still fairly simple:

def has_correct_number_cols(sudo_board):
    correct_set = set(range(1, len(sudo_board) + 1))
    for col_num in range(0, len(sudo_board)):
        # col_set creates a set of the elements in a given column
        col_set = set([row[col_num] for row in sudo_board])
        if (correct_set != set(row)):
            return False
    return True

Same return values here.

Putting it all together

Now that you have these two functions, your final check is actually very easy. It’s below:

def sudoku_check_peter(sudo_board):
    correct_rows = has_correct_number_rows(sudo_board)
    correct_cols = has_correct_number_cols(sudo_board)
    # This last line returns True if both are true, otherwise
    # False.
    return correct_rows and correct_cols

This ended up being quite wordy which I apologize for — happy to answer follow up questions or explain anything more! hope this helps.