Example #1
0
def generate_sudoku_table(board, empty_tiles):
    # Copy the given board
    sudoku = [ row[:] for row in  board ]

    # Generate the list of tiles and shuffle it to remove them in a
    # random order
    tiles = [ x for x in xrange(81) ]
    random.shuffle(tiles)

    c = 0
    while empty_tiles > 0:
        # If the generated board removing one random tile has only one
        # possible solution keep removing tiles until we meet the requirements
        # otherwhise re-add the tile to the list of tiles and try with another one
        tile = tiles.pop()
        i,j = get_sudoku_position(tile)
        value = sudoku[i][j]
        sudoku[i][j] = 'x'
        count = 0
        for _ in sudoku_solver(sudoku):
            count += 1
        if count != 1:
            sudoku[i][j] = value
            tiles.append(tile)
            random.shuffle(tiles)
            c += 1
            if c == len(tiles):
                break
        else:
            empty_tiles -= 1
            c = 0

    return sudoku
Example #2
0
        while(1):
            sudoku, l = read_sudoku(input_file)
            lines += l
            # All the lines empty??
            if l == -1: break
            if sudoku == None:
                sys.stderr.write("Error: File: ")
                if args.input_file != None:
                    sys.stderr.write(args.input_file + " at line " + str(lines))
                else:
                    sys.stderr.write("stdin at line " + str(lines))
                sys.stderr.write(": Problem reading the sudoku from file\n")
                sys.exit(0)

            #print sudoku
            try: answer = sudoku_solver(sudoku).next()
            except StopIteration:
                sys.stderr.write("Error: File: ")
                if args.input_file != None:
                    sys.stderr.write(args.input_file + " at line " + str(line))
                else:
                    sys.stderr.write("stdin at line " + str(line))
                sys.stderr.write(": The given sudoku has no answer\n")
                sys.exit(0)
            #print answer

            print_sudokus(sudoku, answer)
        sys.exit(0)


    if args.difficulty:
    original = [row[:] for row in sudoku]
    # Generate the list of tiles and shuffle it to remove them in a
    # random order
    tiles = [x for x in xrange(81)]
    random.shuffle(tiles)
    c = 0
    while empty_tiles > 0:
        # If the generated board removing one random tile has only one
        # possible solution keep removing tiles until we meet the requirements
        # otherwhise re-add the tile to the list of tiles and try with another one
        tile = tiles.pop()
        i, j = get_sudoku_position(tile)
        value = sudoku[i][j]
        sudoku[i][j] = "x"
        count = 0
        for _ in sudoku_solver(sudoku):
            count += 1
        if count != 1:
            sudoku[i][j] = value
            tiles.append(tile)
            random.shuffle(tiles)
            c += 1
            if c == len(tiles):
                break
        else:
            # print "Remaining tiles: ", empty_tiles
            empty_tiles -= 1
            c = 0

    print "Difficulty:", difficulty
    g = sudoku_solver(sudoku)
if __name__ == "__main__":
    for _ in xrange(REPS):
        empty_tiles = EMPTY_TILES
        tiles = [x for x in xrange(81)]
        random.shuffle(tiles)
        c = 0
        count, sudoku = fill_partial_sudoku(generate_partial_sudoku())
        original = [row[:] for row in sudoku]
        while empty_tiles > 0:
            tile = tiles.pop()
            i, j = get_sudoku_position(tile)
            value = sudoku[i][j]
            sudoku[i][j] = "x"
            count = 0

            for _ in sudoku_solver(sudoku):
                count += 1

            if count != 1:
                sudoku[i][j] = value
                tiles.append(tile)
                random.shuffle(tiles)
                c += 1
                if c == len(tiles):
                    break
            else:
                # print "Remaining tiles: ", empty_tiles
                empty_tiles -= 1
                c = 0

        e_t = 0
     if sudoku == None or not is_a_valid_sudoku(sudoku):
         print sudoku
         raise ValueError("Invalid sudoku generated")
     sudokus.append(sudoku)
 end = time.time()
 
 sudokus.sort()
 for x in xrange(reps-1):
     if sudokus[x] == sudokus[x+1]: 
         raise ValueError("Two equal sudokus generated")
 
 print reps, "valid and different sudokus generated in", end - start, "secs using the custom algorithm"
 
 # Using the solver to generate the sudokus
 sudoku = [ ['x' for _ in xrange(9)] for _ in xrange(9)]
 g = sudoku_solver(sudoku)
 start = time.time()
 reps = 50
 sudokus = []
 
 for _ in xrange(reps):
     sudoku = g.next()
     if not is_a_valid_sudoku(sudoku):
         print sudoku
         raise ValueError("Invalid sudoku generated")
     sudokus.append(sudoku)
 end = time.time()
 
 sudokus.sort()
 print reps, "valid sudokus generated in", end - start\
     ,"secs using the sudoku solver", "(", g.__name__, "version)"