Solution #8ec51433-637a-4837-ab1e-ee77be84a3b8

completed

Score

80% (4/5)

Runtime

25μs

Delta

No change vs parent

-20.0% vs best

Same as parent

Solution Lineage

Current80%Same as parent
da62d7c880%Same as parent
3d4c689e80%Same as parent
1f2128e780%Improved from parent
92397d700%Regression from parent
7cbd604b80%Improved from parent
fc42ee8d0%Regression from parent
b0db196680%Same as parent
692ab45880%Same as parent
8996709780%Improved from parent
17dd25090%Regression from parent
2524a75f80%Same as parent
e8534c5f80%Same as parent
bc1ec94080%Same as parent
7630bd9e80%Same as parent
ae983b2480%Same as parent
8252644380%Same as parent
9db0fb8580%Improved from parent
df1d6fd340%Regression from parent
ae833bc280%Same as parent
c90b917a80%First in chain

Code

def solve(input):
    jobs = input.get("jobs", []) if isinstance(input, dict) else []
    if not jobs:
        return 0

    jobs = sorted((tuple(job) for job in jobs), key=lambda x: x[0])
    n = len(jobs)

    starts = [s for s, _, _ in jobs]

    def lower_bound(x, lo):
        hi = n
        while lo < hi:
            mid = (lo + hi) // 2
            if starts[mid] < x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    next_idx = [0] * n
    for i, (_, e, _) in enumerate(jobs):
        next_idx[i] = lower_bound(e, i + 1)

    dp = [0] * (n + 1)
    for i in range(n - 1, -1, -1):
        w = jobs[i][2]
        take = w + dp[next_idx[i]]
        skip = dp[i + 1]
        dp[i] = take if take > skip else skip

    return dp[0]

Compare with Champion

Score Difference

-20.0%

Runtime Advantage

7μs slower

Code Size

32 vs 39 lines

#Your Solution#Champion
1def solve(input):1def solve(input):
2 jobs = input.get("jobs", []) if isinstance(input, dict) else []2 if not isinstance(input, dict):
3 if not jobs:3 return 0
4 return 04 raw = input.get("jobs")
55 if not raw:
6 jobs = sorted((tuple(job) for job in jobs), key=lambda x: x[0])6 return 0
7 n = len(jobs)7
88 jobs = []
9 starts = [s for s, _, _ in jobs]9 for j in raw:
1010 if isinstance(j, (list, tuple)) and len(j) == 3:
11 def lower_bound(x, lo):11 jobs.append((j[1], j[0], j[2])) # sort by end, store as (end, start, weight)
12 hi = n12 if not jobs:
13 while lo < hi:13 return 0
14 mid = (lo + hi) // 214
15 if starts[mid] < x:15 jobs.sort()
16 lo = mid + 116 ends = []
17 else:17 bests = []
18 hi = mid18
19 return lo19 for e, s, w in jobs:
2020 lo = 0
21 next_idx = [0] * n21 hi = len(ends)
22 for i, (_, e, _) in enumerate(jobs):22 while lo < hi:
23 next_idx[i] = lower_bound(e, i + 1)23 mid = (lo + hi) >> 1
2424 if ends[mid] <= s:
25 dp = [0] * (n + 1)25 lo = mid + 1
26 for i in range(n - 1, -1, -1):26 else:
27 w = jobs[i][2]27 hi = mid
28 take = w + dp[next_idx[i]]28
29 skip = dp[i + 1]29 candidate = w + (bests[lo - 1] if lo else 0)
30 dp[i] = take if take > skip else skip30 current = bests[-1] if bests else 0
3131
32 return dp[0]32 if candidate > current:
3333 if ends and ends[-1] == e:
3434 bests[-1] = candidate
3535 else:
3636 ends.append(e)
3737 bests.append(candidate)
3838
3939 return bests[-1] if bests else 0
Your Solution
80% (4/5)25μs
1def solve(input):
2 jobs = input.get("jobs", []) if isinstance(input, dict) else []
3 if not jobs:
4 return 0
5
6 jobs = sorted((tuple(job) for job in jobs), key=lambda x: x[0])
7 n = len(jobs)
8
9 starts = [s for s, _, _ in jobs]
10
11 def lower_bound(x, lo):
12 hi = n
13 while lo < hi:
14 mid = (lo + hi) // 2
15 if starts[mid] < x:
16 lo = mid + 1
17 else:
18 hi = mid
19 return lo
20
21 next_idx = [0] * n
22 for i, (_, e, _) in enumerate(jobs):
23 next_idx[i] = lower_bound(e, i + 1)
24
25 dp = [0] * (n + 1)
26 for i in range(n - 1, -1, -1):
27 w = jobs[i][2]
28 take = w + dp[next_idx[i]]
29 skip = dp[i + 1]
30 dp[i] = take if take > skip else skip
31
32 return dp[0]
Champion
100% (5/5)18μs
1def solve(input):
2 if not isinstance(input, dict):
3 return 0
4 raw = input.get("jobs")
5 if not raw:
6 return 0
7
8 jobs = []
9 for j in raw:
10 if isinstance(j, (list, tuple)) and len(j) == 3:
11 jobs.append((j[1], j[0], j[2])) # sort by end, store as (end, start, weight)
12 if not jobs:
13 return 0
14
15 jobs.sort()
16 ends = []
17 bests = []
18
19 for e, s, w in jobs:
20 lo = 0
21 hi = len(ends)
22 while lo < hi:
23 mid = (lo + hi) >> 1
24 if ends[mid] <= s:
25 lo = mid + 1
26 else:
27 hi = mid
28
29 candidate = w + (bests[lo - 1] if lo else 0)
30 current = bests[-1] if bests else 0
31
32 if candidate > current:
33 if ends and ends[-1] == e:
34 bests[-1] = candidate
35 else:
36 ends.append(e)
37 bests.append(candidate)
38
39 return bests[-1] if bests else 0