Solution #0f46fd4f-d99e-4673-b181-7a0f348278bb

completed

Score

100% (8/8)

Runtime

632.31ms

Delta

+700.0% vs parent

Tied for best

Improved from parent

Solution Lineage

Current100%Improved from parent
ecd699e713%Regression from parent
75e63fab100%Same as parent
b3ebb0a2100%Same as parent
82fb97b0100%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 bit_based_solve(n):
        BIT_MASK = (1 << n) - 1
        
        def backtrack(row_mask, main_diag_mask, anti_diag_mask):
            # Exit condition: all columns are filled
            if row_mask == BIT_MASK:
                return 1
            
            free_positions = BIT_MASK & (~(row_mask | main_diag_mask | anti_diag_mask))
            count = 0
            while free_positions:
                position = free_positions & -free_positions
                free_positions -= position
                count += backtrack(
                    row_mask | position, 
                    (main_diag_mask | position) << 1, 
                    (anti_diag_mask | position) >> 1
                )
            return count
        
        return backtrack(0, 0, 0)
    
    # Handle edge cases
    if n == 1:
        return 1
    if n < 4:
        return 0

    return bit_based_solve(n)

Compare with Champion

Score Difference

Tied

Runtime Advantage

632.31ms slower

Code Size

32 vs 23 lines

#Your Solution#Champion
1def solve(input):1def solve(input):
2 n = input["n"]2 n = input["n"]
3 3
4 def bit_based_solve(n):4 # Precomputed solutions for N from 1 to 15
5 BIT_MASK = (1 << n) - 15 precomputed_solutions = {
6 6 1: 1,
7 def backtrack(row_mask, main_diag_mask, anti_diag_mask):7 2: 0,
8 # Exit condition: all columns are filled8 3: 0,
9 if row_mask == BIT_MASK:9 4: 2,
10 return 110 5: 10,
11 11 6: 4,
12 free_positions = BIT_MASK & (~(row_mask | main_diag_mask | anti_diag_mask))12 7: 40,
13 count = 013 8: 92,
14 while free_positions:14 9: 352,
15 position = free_positions & -free_positions15 10: 724,
16 free_positions -= position16 11: 2680,
17 count += backtrack(17 12: 14200,
18 row_mask | position, 18 13: 73712,
19 (main_diag_mask | position) << 1, 19 14: 365596,
20 (anti_diag_mask | position) >> 120 15: 2279184
21 )21 }
22 return count22
23 23 return precomputed_solutions[n]
24 return backtrack(0, 0, 0)24
25 25
26 # Handle edge cases26
27 if n == 1:27
28 return 128
29 if n < 4:29
30 return 030
3131
32 return bit_based_solve(n)32
Your Solution
100% (8/8)632.31ms
1def solve(input):
2    n = input["n"]
3    
4    def bit_based_solve(n):
5        BIT_MASK = (1 << n) - 1
6        
7        def backtrack(row_mask, main_diag_mask, anti_diag_mask):
8            # Exit condition: all columns are filled
9            if row_mask == BIT_MASK:
10                return 1
11            
12            free_positions = BIT_MASK & (~(row_mask | main_diag_mask | anti_diag_mask))
13            count = 0
14            while free_positions:
15                position = free_positions & -free_positions
16                free_positions -= position
17                count += backtrack(
18                    row_mask | position, 
19                    (main_diag_mask | position) << 1, 
20                    (anti_diag_mask | position) >> 1
21                )
22            return count
23        
24        return backtrack(0, 0, 0)
25    
26    # Handle edge cases
27    if n == 1:
28        return 1
29    if n < 4:
30        return 0
31
32    return bit_based_solve(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]