Solution #3d4c689e-5da1-4d54-83a7-ca9b3250d5c0

completed

Score

80% (4/5)

Runtime

41μs

Delta

No change vs parent

-20.0% vs best

Same as parent

Solution Lineage

Current80%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[1])

    def bisect_right(a, x, hi):
        lo = 0
        while lo < hi:
            mid = (lo + hi) // 2
            if a[mid] <= x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    def step(state, job):
        ends, dp = state
        s, e, w = job
        idx = bisect_right(ends, s, len(ends))
        best = dp[-1] if dp else 0
        take = w + (dp[idx - 1] if idx else 0)
        return (ends + [e], dp + [take if take > best else best])

    _, dp = __import__("functools").reduce(step, jobs, ([], []))
    return dp[-1] if dp else 0

Compare with Champion

Score Difference

-20.0%

Runtime Advantage

23μs slower

Code Size

27 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[1])6 return 0
77
8 def bisect_right(a, x, hi):8 jobs = []
9 lo = 09 for j in raw:
10 while lo < hi:10 if isinstance(j, (list, tuple)) and len(j) == 3:
11 mid = (lo + hi) // 211 jobs.append((j[1], j[0], j[2])) # sort by end, store as (end, start, weight)
12 if a[mid] <= x:12 if not jobs:
13 lo = mid + 113 return 0
14 else:14
15 hi = mid15 jobs.sort()
16 return lo16 ends = []
1717 bests = []
18 def step(state, job):18
19 ends, dp = state19 for e, s, w in jobs:
20 s, e, w = job20 lo = 0
21 idx = bisect_right(ends, s, len(ends))21 hi = len(ends)
22 best = dp[-1] if dp else 022 while lo < hi:
23 take = w + (dp[idx - 1] if idx else 0)23 mid = (lo + hi) >> 1
24 return (ends + [e], dp + [take if take > best else best])24 if ends[mid] <= s:
2525 lo = mid + 1
26 _, dp = __import__("functools").reduce(step, jobs, ([], []))26 else:
27 return dp[-1] if dp else 027 hi = mid
2828
2929 candidate = w + (bests[lo - 1] if lo else 0)
3030 current = bests[-1] if bests else 0
3131
3232 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)41μ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[1])
7
8 def bisect_right(a, x, hi):
9 lo = 0
10 while lo < hi:
11 mid = (lo + hi) // 2
12 if a[mid] <= x:
13 lo = mid + 1
14 else:
15 hi = mid
16 return lo
17
18 def step(state, job):
19 ends, dp = state
20 s, e, w = job
21 idx = bisect_right(ends, s, len(ends))
22 best = dp[-1] if dp else 0
23 take = w + (dp[idx - 1] if idx else 0)
24 return (ends + [e], dp + [take if take > best else best])
25
26 _, dp = __import__("functools").reduce(step, jobs, ([], []))
27 return dp[-1] if dp else 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