Solution #41f00984-0a11-4e61-8f6d-d1a04b53429c

completed

Score

20% (1/5)

Runtime

43μs

Delta

-80.0% vs parent

-80.0% vs best

Regression from parent

Solution Lineage

Current20%Regression from parent
e2c97ff1100%Same as parent
b9b05796100%Same as parent
a6d53a91100%Same as parent
f23f1e97100%Same as parent
2c1ef298100%Same as parent
807bffb4100%Same as parent
14fae373100%Improved from parent
dbb1f88620%Regression from parent
1c204190100%Same as parent
37d6e851100%Same as parent
58b73178100%Same as parent
66b5ba20100%Same as parent
6773a310100%Improved from parent
530effa860%Regression from parent
5bd2ddd7100%Same as parent
eef58d00100%Improved from parent
0c1780d720%Regression from parent
2db3327f100%Improved from parent
3ae0505880%Same as parent
2baa50c180%Same as parent
ce0d4fdb80%Same as parent
ad9ca75f80%Same as parent
3277469d80%Improved from parent
f050941640%Regression from parent
8ec5143380%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):
    if not isinstance(input, dict):
        return 0
    raw = input.get("jobs")
    if not raw:
        return 0

    jobs = []
    starts = []
    ends = []
    for j in raw:
        if isinstance(j, (list, tuple)) and len(j) == 3:
            s, e, w = j[0], j[1], j[2]
            jobs.append((s, e, w))
            starts.append(s)
            ends.append(e)

    if not jobs:
        return 0

    times = sorted(set(starts + ends))
    m = len(times)

    index = {}
    for i, t in enumerate(times):
        index[t] = i

    best_start = [0] * m
    for i, t in enumerate(times):
        if t in index:
            best_start[i] = index[t]

    prefix_lookup = [0] * m
    if m:
        prefix_lookup[0] = 0
        for i in range(1, m):
            prefix_lookup[i] = i - 1

    by_end = [[] for _ in range(m)]
    for s, e, w in jobs:
        by_end[index[e]].append((index[s], w))

    dp = [0] * m
    for ei in range(m):
        best = dp[ei - 1] if ei else 0
        bucket = by_end[ei]
        for si, w in bucket:
            prev = dp[prefix_lookup[si]] if si > 0 else 0
            cand = prev + w
            if cand > best:
                best = cand
        dp[ei] = best

    return dp[-1] if dp else 0

Compare with Champion

Score Difference

-80.0%

Runtime Advantage

25μs slower

Code Size

54 vs 39 lines

#Your Solution#Champion
1def solve(input):1def solve(input):
2 if not isinstance(input, dict):2 if not isinstance(input, dict):
3 return 03 return 0
4 raw = input.get("jobs")4 raw = input.get("jobs")
5 if not raw:5 if not raw:
6 return 06 return 0
77
8 jobs = []8 jobs = []
9 starts = []9 for j in raw:
10 ends = []10 if isinstance(j, (list, tuple)) and len(j) == 3:
11 for j in raw:11 jobs.append((j[1], j[0], j[2])) # sort by end, store as (end, start, weight)
12 if isinstance(j, (list, tuple)) and len(j) == 3:12 if not jobs:
13 s, e, w = j[0], j[1], j[2]13 return 0
14 jobs.append((s, e, w))14
15 starts.append(s)15 jobs.sort()
16 ends.append(e)16 ends = []
1717 bests = []
18 if not jobs:18
19 return 019 for e, s, w in jobs:
2020 lo = 0
21 times = sorted(set(starts + ends))21 hi = len(ends)
22 m = len(times)22 while lo < hi:
2323 mid = (lo + hi) >> 1
24 index = {}24 if ends[mid] <= s:
25 for i, t in enumerate(times):25 lo = mid + 1
26 index[t] = i26 else:
2727 hi = mid
28 best_start = [0] * m28
29 for i, t in enumerate(times):29 candidate = w + (bests[lo - 1] if lo else 0)
30 if t in index:30 current = bests[-1] if bests else 0
31 best_start[i] = index[t]31
3232 if candidate > current:
33 prefix_lookup = [0] * m33 if ends and ends[-1] == e:
34 if m:34 bests[-1] = candidate
35 prefix_lookup[0] = 035 else:
36 for i in range(1, m):36 ends.append(e)
37 prefix_lookup[i] = i - 137 bests.append(candidate)
3838
39 by_end = [[] for _ in range(m)]39 return bests[-1] if bests else 0
40 for s, e, w in jobs:40
41 by_end[index[e]].append((index[s], w))41
4242
43 dp = [0] * m43
44 for ei in range(m):44
45 best = dp[ei - 1] if ei else 045
46 bucket = by_end[ei]46
47 for si, w in bucket:47
48 prev = dp[prefix_lookup[si]] if si > 0 else 048
49 cand = prev + w49
50 if cand > best:50
51 best = cand51
52 dp[ei] = best52
5353
54 return dp[-1] if dp else 054
Your Solution
20% (1/5)43μ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 starts = []
10 ends = []
11 for j in raw:
12 if isinstance(j, (list, tuple)) and len(j) == 3:
13 s, e, w = j[0], j[1], j[2]
14 jobs.append((s, e, w))
15 starts.append(s)
16 ends.append(e)
17
18 if not jobs:
19 return 0
20
21 times = sorted(set(starts + ends))
22 m = len(times)
23
24 index = {}
25 for i, t in enumerate(times):
26 index[t] = i
27
28 best_start = [0] * m
29 for i, t in enumerate(times):
30 if t in index:
31 best_start[i] = index[t]
32
33 prefix_lookup = [0] * m
34 if m:
35 prefix_lookup[0] = 0
36 for i in range(1, m):
37 prefix_lookup[i] = i - 1
38
39 by_end = [[] for _ in range(m)]
40 for s, e, w in jobs:
41 by_end[index[e]].append((index[s], w))
42
43 dp = [0] * m
44 for ei in range(m):
45 best = dp[ei - 1] if ei else 0
46 bucket = by_end[ei]
47 for si, w in bucket:
48 prev = dp[prefix_lookup[si]] if si > 0 else 0
49 cand = prev + w
50 if cand > best:
51 best = cand
52 dp[ei] = best
53
54 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