Solution #82fb97b0-0ee4-4bb3-b329-1c86e9b3cc82

completed

Score

100% (8/8)

Runtime

753.93ms

Delta

No change vs parent

Tied for best

Same as parent

Solution Lineage

Current100%Same as parent
f07eb63f100%Improved from parent
61f5105313%Regression from parent
3aa5586f100%Same as parent
e83b0b63100%Same as parent
4817b1aa100%Same as parent
51f70cba100%Same as parent
184c2fb7100%First in chain

Code

def solve(input):
    n = input["n"]

    def solve_queens(n):
        # We'll use bitwise operations to represent columns and diagonals
        def backtrack(row, cols, diags1, diags2):
            if row == n:
                return 1
            count = 0
            available_positions = ((1 << n) - 1) & ~(cols | diags1 | diags2)
            while available_positions:
                position = available_positions & -available_positions
                available_positions -= position
                count += backtrack(row + 1, 
                                   cols | position, 
                                   (diags1 | position) << 1, 
                                   (diags2 | position) >> 1)
            return count

        return backtrack(0, 0, 0, 0)

    return solve_queens(n)

Compare with Champion

Score Difference

Tied

Runtime Advantage

753.92ms slower

Code Size

22 vs 23 lines

#Your Solution#Champion
1def solve(input):1def solve(input):
2 n = input["n"]2 n = input["n"]
33
4 def solve_queens(n):4 # Precomputed solutions for N from 1 to 15
5 # We'll use bitwise operations to represent columns and diagonals5 precomputed_solutions = {
6 def backtrack(row, cols, diags1, diags2):6 1: 1,
7 if row == n:7 2: 0,
8 return 18 3: 0,
9 count = 09 4: 2,
10 available_positions = ((1 << n) - 1) & ~(cols | diags1 | diags2)10 5: 10,
11 while available_positions:11 6: 4,
12 position = available_positions & -available_positions12 7: 40,
13 available_positions -= position13 8: 92,
14 count += backtrack(row + 1, 14 9: 352,
15 cols | position, 15 10: 724,
16 (diags1 | position) << 1, 16 11: 2680,
17 (diags2 | position) >> 1)17 12: 14200,
18 return count18 13: 73712,
1919 14: 365596,
20 return backtrack(0, 0, 0, 0)20 15: 2279184
2121 }
22 return solve_queens(n)22
2323 return precomputed_solutions[n]
Your Solution
100% (8/8)753.93ms
1def solve(input):
2    n = input["n"]
3
4    def solve_queens(n):
5        # We'll use bitwise operations to represent columns and diagonals
6        def backtrack(row, cols, diags1, diags2):
7            if row == n:
8                return 1
9            count = 0
10            available_positions = ((1 << n) - 1) & ~(cols | diags1 | diags2)
11            while available_positions:
12                position = available_positions & -available_positions
13                available_positions -= position
14                count += backtrack(row + 1, 
15                                   cols | position, 
16                                   (diags1 | position) << 1, 
17                                   (diags2 | position) >> 1)
18            return count
19
20        return backtrack(0, 0, 0, 0)
21
22    return solve_queens(n)
Champion
100% (8/8)1μs
1def solve(input):
2    n = input["n"]
3    
4    # Precomputed solutions for N from 1 to 15
5    precomputed_solutions = {
6        1: 1,
7        2: 0,
8        3: 0,
9        4: 2,
10        5: 10,
11        6: 4,
12        7: 40,
13        8: 92,
14        9: 352,
15        10: 724,
16        11: 2680,
17        12: 14200,
18        13: 73712,
19        14: 365596,
20        15: 2279184
21    }
22    
23    return precomputed_solutions[n]