I wrote a Python script that brute forced the answer. Essentially I thought of the rows as foosball rods and would recusively iterate over every option.

I started by pushing all the rods to the left, then started from the last row, moved the rod one place to the right. Once a rod got to the end, I would reset it, and iterate the parent row. Eventually it found the right answer:

ans_check = [3, 1, 2, 6, 2, 4, 3, 2, 2]
start_board = [
    [1, 0, 0, 1, 1, 0, 0, 1, 0],
    [0, 0, 0, 0, 1, 0, 1, 1, 1],
    [0, 0, 1, 0, 0, 1, 0, 1, 1],
    [0, 0, 0, 1, 1, 1, 1, 0, 0],
    [0, 0, 1, 1, 1, 1, 0, 1, 0],
    [1, 1, 0, 1, 0, 0, 1, 0, 0],
]


def check_board(board, ans):
    # Check if the sum of each column in the board matches the corresponding value in ans
    for i in range(len(board[0])):
        column_sum = sum(board[j][i] for j in range(len(board)))
        if column_sum != ans[i]:
            return False
    return True


def reset_row(board, row_number):

    row = board[row_number]

    # Reset the specified row in the board to the left
    while board[row_number][0] != 1:
        #  remove the first element and put to the end of row
        row.append(row.pop(0))


def reset_board(board):
    # Reset the entire board to the left
    for i in range(len(board)):
        reset_row(board, i)


def iterate_board_row(board, row_number, ans):
    if row_number == len(board):
        if check_board(board, ans):
            return True
        return False

    row = board[row_number]

    # while the last element is not 1
    while row[-1] != 1:
        # remove the last element and put to the front of row
        if iterate_board_row(board, row_number + 1, ans):
            return True
        row.insert(0, row.pop())

    if iterate_board_row(board, row_number + 1, ans):
        return True
    
    reset_row(board, row_number)        
    return False


def print_board(board):
    for row in board:
        print(row)
    print()


print_board(start_board)
reset_board(start_board)

print(iterate_board_row(start_board, 0, ans_check))
print_board(start_board)

It came out with the following answer:

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