Solution #5bd2ddd7-b65d-4c44-ae9c-1c92f91c3923

completed

Score

100% (5/5)

Runtime

29μs

Delta

No change vs parent

Tied for best

Same as parent

Solution Lineage

Current100%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 = []
    ends_set = set()
    for job in raw:
        if isinstance(job, (list, tuple)) and len(job) == 3:
            s, e, w = job
            jobs.append((s, e, w))
            ends_set.add(e)

    if not jobs:
        return 0

    ends = sorted(ends_set)
    m = len(ends)
    end_to_idx = {}
    for i in range(m):
        end_to_idx[ends[i]] = i

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

    dp = [0] * m

    for i in range(m):
        best = dp[i - 1] if i else 0
        bucket = by_end[i]

        for s, w in bucket:
            lo = 0
            hi = i
            while lo < hi:
                mid = (lo + hi) >> 1
                if ends[mid] <= s:
                    lo = mid + 1
                else:
                    hi = mid
            cand = w + (dp[lo - 1] if lo else 0)
            if cand > best:
                best = cand

        dp[i] = best

    return dp[-1]

Compare with Champion

Score Difference

Tied

Runtime Advantage

11μs slower

Code Size

50 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 ends_set = set()9 for j in raw:
10 for job in raw:10 if isinstance(j, (list, tuple)) and len(j) == 3:
11 if isinstance(job, (list, tuple)) and len(job) == 3:11 jobs.append((j[1], j[0], j[2])) # sort by end, store as (end, start, weight)
12 s, e, w = job12 if not jobs:
13 jobs.append((s, e, w))13 return 0
14 ends_set.add(e)14
1515 jobs.sort()
16 if not jobs:16 ends = []
17 return 017 bests = []
1818
19 ends = sorted(ends_set)19 for e, s, w in jobs:
20 m = len(ends)20 lo = 0
21 end_to_idx = {}21 hi = len(ends)
22 for i in range(m):22 while lo < hi:
23 end_to_idx[ends[i]] = i23 mid = (lo + hi) >> 1
2424 if ends[mid] <= s:
25 by_end = [[] for _ in range(m)]25 lo = mid + 1
26 for s, e, w in jobs:26 else:
27 by_end[end_to_idx[e]].append((s, w))27 hi = mid
2828
29 dp = [0] * m29 candidate = w + (bests[lo - 1] if lo else 0)
3030 current = bests[-1] if bests else 0
31 for i in range(m):31
32 best = dp[i - 1] if i else 032 if candidate > current:
33 bucket = by_end[i]33 if ends and ends[-1] == e:
3434 bests[-1] = candidate
35 for s, w in bucket:35 else:
36 lo = 036 ends.append(e)
37 hi = i37 bests.append(candidate)
38 while lo < hi:38
39 mid = (lo + hi) >> 139 return bests[-1] if bests else 0
40 if ends[mid] <= s:40
41 lo = mid + 141
42 else:42
43 hi = mid43
44 cand = w + (dp[lo - 1] if lo else 0)44
45 if cand > best:45
46 best = cand46
4747
48 dp[i] = best48
4949
50 return dp[-1]50
Your Solution
100% (5/5)29μ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 ends_set = set()
10 for job in raw:
11 if isinstance(job, (list, tuple)) and len(job) == 3:
12 s, e, w = job
13 jobs.append((s, e, w))
14 ends_set.add(e)
15
16 if not jobs:
17 return 0
18
19 ends = sorted(ends_set)
20 m = len(ends)
21 end_to_idx = {}
22 for i in range(m):
23 end_to_idx[ends[i]] = i
24
25 by_end = [[] for _ in range(m)]
26 for s, e, w in jobs:
27 by_end[end_to_idx[e]].append((s, w))
28
29 dp = [0] * m
30
31 for i in range(m):
32 best = dp[i - 1] if i else 0
33 bucket = by_end[i]
34
35 for s, w in bucket:
36 lo = 0
37 hi = i
38 while lo < hi:
39 mid = (lo + hi) >> 1
40 if ends[mid] <= s:
41 lo = mid + 1
42 else:
43 hi = mid
44 cand = w + (dp[lo - 1] if lo else 0)
45 if cand > best:
46 best = cand
47
48 dp[i] = best
49
50 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