Solution #e2c97ff1-a738-403d-b602-ec4f83c422fc

completed

Score

100% (5/5)

Runtime

41μs

Delta

No change vs parent

Tied for best

Same as parent

Solution Lineage

Current100%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 = []
    for j in raw:
        if isinstance(j, (list, tuple)) and len(j) == 3:
            jobs.append((j[0], j[1], j[2]))
    if not jobs:
        return 0

    import bisect

    times = []
    by_end = {}
    for s, e, w in jobs:
        times.append(s)
        times.append(e)
        lst = by_end.get(e)
        if lst is None:
            by_end[e] = [(s, w)]
        else:
            lst.append((s, w))

    times = sorted(set(times))
    m = len(times)
    dp = [0] * m

    for i, t in enumerate(times):
        if i:
            dp[i] = dp[i - 1]
        lst = by_end.get(t)
        if lst:
            best = dp[i]
            for s, w in lst:
                j = bisect.bisect_right(times, s, 0, i) - 1
                cand = (dp[j] if j >= 0 else 0) + w
                if cand > best:
                    best = cand
            dp[i] = best

    return dp[-1]

Compare with Champion

Score Difference

Tied

Runtime Advantage

23μs slower

Code Size

45 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 for j in raw:9 for j in raw:
10 if isinstance(j, (list, tuple)) and len(j) == 3:10 if isinstance(j, (list, tuple)) and len(j) == 3:
11 jobs.append((j[0], j[1], j[2]))11 jobs.append((j[1], j[0], j[2])) # sort by end, store as (end, start, weight)
12 if not jobs:12 if not jobs:
13 return 013 return 0
1414
15 import bisect15 jobs.sort()
1616 ends = []
17 times = []17 bests = []
18 by_end = {}18
19 for s, e, w in jobs:19 for e, s, w in jobs:
20 times.append(s)20 lo = 0
21 times.append(e)21 hi = len(ends)
22 lst = by_end.get(e)22 while lo < hi:
23 if lst is None:23 mid = (lo + hi) >> 1
24 by_end[e] = [(s, w)]24 if ends[mid] <= s:
25 else:25 lo = mid + 1
26 lst.append((s, w))26 else:
2727 hi = mid
28 times = sorted(set(times))28
29 m = len(times)29 candidate = w + (bests[lo - 1] if lo else 0)
30 dp = [0] * m30 current = bests[-1] if bests else 0
3131
32 for i, t in enumerate(times):32 if candidate > current:
33 if i:33 if ends and ends[-1] == e:
34 dp[i] = dp[i - 1]34 bests[-1] = candidate
35 lst = by_end.get(t)35 else:
36 if lst:36 ends.append(e)
37 best = dp[i]37 bests.append(candidate)
38 for s, w in lst:38
39 j = bisect.bisect_right(times, s, 0, i) - 139 return bests[-1] if bests else 0
40 cand = (dp[j] if j >= 0 else 0) + w40
41 if cand > best:41
42 best = cand42
43 dp[i] = best43
4444
45 return dp[-1]45
Your Solution
100% (5/5)41μ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[0], j[1], j[2]))
12 if not jobs:
13 return 0
14
15 import bisect
16
17 times = []
18 by_end = {}
19 for s, e, w in jobs:
20 times.append(s)
21 times.append(e)
22 lst = by_end.get(e)
23 if lst is None:
24 by_end[e] = [(s, w)]
25 else:
26 lst.append((s, w))
27
28 times = sorted(set(times))
29 m = len(times)
30 dp = [0] * m
31
32 for i, t in enumerate(times):
33 if i:
34 dp[i] = dp[i - 1]
35 lst = by_end.get(t)
36 if lst:
37 best = dp[i]
38 for s, w in lst:
39 j = bisect.bisect_right(times, s, 0, i) - 1
40 cand = (dp[j] if j >= 0 else 0) + w
41 if cand > best:
42 best = cand
43 dp[i] = best
44
45 return dp[-1]
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