Solution #eef58d00-d96c-4441-9077-ef477d9f9264

completed

Score

100% (5/5)

Runtime

25μs

Delta

+400.0% vs parent

Tied for best

Improved from parent

Solution Lineage

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

    if not jobs:
        return 0

    jobs.sort(key=lambda x: (x[1], x[0], x[2]))

    states_end = [float("-inf")]
    states_val = [0]

    for s, e, w in jobs:
        lo, hi = 0, len(states_end)
        while lo < hi:
            mid = (lo + hi) // 2
            if states_end[mid] <= s:
                lo = mid + 1
            else:
                hi = mid
        base = states_val[lo - 1]
        cand = base + w

        if cand <= states_val[-1]:
            continue

        if e == states_end[-1]:
            states_val[-1] = cand
            continue

        states_end.append(e)
        states_val.append(cand)

    return states_val[-1]

Compare with Champion

Score Difference

Tied

Runtime Advantage

7μs slower

Code Size

43 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 job in raw:9 for j in raw:
10 if isinstance(job, (list, tuple)) and len(job) == 3:10 if isinstance(j, (list, tuple)) and len(j) == 3:
11 s, e, w = job11 jobs.append((j[1], j[0], j[2])) # sort by end, store as (end, start, weight)
12 jobs.append((s, e, w))12 if not jobs:
1313 return 0
14 if not jobs:14
15 return 015 jobs.sort()
1616 ends = []
17 jobs.sort(key=lambda x: (x[1], x[0], x[2]))17 bests = []
1818
19 states_end = [float("-inf")]19 for e, s, w in jobs:
20 states_val = [0]20 lo = 0
2121 hi = len(ends)
22 for s, e, w in jobs:22 while lo < hi:
23 lo, hi = 0, len(states_end)23 mid = (lo + hi) >> 1
24 while lo < hi:24 if ends[mid] <= s:
25 mid = (lo + hi) // 225 lo = mid + 1
26 if states_end[mid] <= s:26 else:
27 lo = mid + 127 hi = mid
28 else:28
29 hi = mid29 candidate = w + (bests[lo - 1] if lo else 0)
30 base = states_val[lo - 1]30 current = bests[-1] if bests else 0
31 cand = base + w31
3232 if candidate > current:
33 if cand <= states_val[-1]:33 if ends and ends[-1] == e:
34 continue34 bests[-1] = candidate
3535 else:
36 if e == states_end[-1]:36 ends.append(e)
37 states_val[-1] = cand37 bests.append(candidate)
38 continue38
3939 return bests[-1] if bests else 0
40 states_end.append(e)40
41 states_val.append(cand)41
4242
43 return states_val[-1]43
Your Solution
100% (5/5)25μ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 job in raw:
10 if isinstance(job, (list, tuple)) and len(job) == 3:
11 s, e, w = job
12 jobs.append((s, e, w))
13
14 if not jobs:
15 return 0
16
17 jobs.sort(key=lambda x: (x[1], x[0], x[2]))
18
19 states_end = [float("-inf")]
20 states_val = [0]
21
22 for s, e, w in jobs:
23 lo, hi = 0, len(states_end)
24 while lo < hi:
25 mid = (lo + hi) // 2
26 if states_end[mid] <= s:
27 lo = mid + 1
28 else:
29 hi = mid
30 base = states_val[lo - 1]
31 cand = base + w
32
33 if cand <= states_val[-1]:
34 continue
35
36 if e == states_end[-1]:
37 states_val[-1] = cand
38 continue
39
40 states_end.append(e)
41 states_val.append(cand)
42
43 return states_val[-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