Solution #0c1780d7-4f16-42d9-a01f-06a9db8131f4

completed

Score

20% (1/5)

Runtime

24μs

Delta

-80.0% vs parent

-80.0% vs best

Regression from parent

Solution Lineage

Current20%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
    jobs = input.get("jobs")
    if not jobs:
        return 0

    n = len(jobs)
    m = 0
    for i in range(n):
        job = jobs[i]
        if isinstance(job, (list, tuple)) and len(job) == 3:
            jobs[m] = job
            m += 1
    if m == 0:
        return 0
    if m != n:
        del jobs[m:]

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

    ends = [0] * m
    for i in range(m):
        ends[i] = jobs[i][1]

    dp = [0] * (m + 1)

    for i in range(1, m + 1):
        s, e, w = jobs[i - 1]

        lo = 0
        hi = i - 1
        while lo < hi:
            mid = (lo + hi) >> 1
            if ends[mid] <= s:
                lo = mid + 1
            else:
                hi = mid
        j = lo
        if j and ends[j - 1] > s:
            j -= 1
        if ends[j] <= s:
            j += 1
        else:
            j = 0

        take = dp[j] + w
        skip = dp[i - 1]
        dp[i] = take if take > skip else skip

    return dp[m]

Compare with Champion

Score Difference

-80.0%

Runtime Advantage

6μs slower

Code Size

51 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 jobs = input.get("jobs")4 raw = input.get("jobs")
5 if not jobs:5 if not raw:
6 return 06 return 0
77
8 n = len(jobs)8 jobs = []
9 m = 09 for j in raw:
10 for i in range(n):10 if isinstance(j, (list, tuple)) and len(j) == 3:
11 job = jobs[i]11 jobs.append((j[1], j[0], j[2])) # sort by end, store as (end, start, weight)
12 if isinstance(job, (list, tuple)) and len(job) == 3:12 if not jobs:
13 jobs[m] = job13 return 0
14 m += 114
15 if m == 0:15 jobs.sort()
16 return 016 ends = []
17 if m != n:17 bests = []
18 del jobs[m:]18
1919 for e, s, w in jobs:
20 jobs.sort(key=lambda x: x[1])20 lo = 0
2121 hi = len(ends)
22 ends = [0] * m22 while lo < hi:
23 for i in range(m):23 mid = (lo + hi) >> 1
24 ends[i] = jobs[i][1]24 if ends[mid] <= s:
2525 lo = mid + 1
26 dp = [0] * (m + 1)26 else:
2727 hi = mid
28 for i in range(1, m + 1):28
29 s, e, w = jobs[i - 1]29 candidate = w + (bests[lo - 1] if lo else 0)
3030 current = bests[-1] if bests else 0
31 lo = 031
32 hi = i - 132 if candidate > current:
33 while lo < hi:33 if ends and ends[-1] == e:
34 mid = (lo + hi) >> 134 bests[-1] = candidate
35 if ends[mid] <= s:35 else:
36 lo = mid + 136 ends.append(e)
37 else:37 bests.append(candidate)
38 hi = mid38
39 j = lo39 return bests[-1] if bests else 0
40 if j and ends[j - 1] > s:40
41 j -= 141
42 if ends[j] <= s:42
43 j += 143
44 else:44
45 j = 045
4646
47 take = dp[j] + w47
48 skip = dp[i - 1]48
49 dp[i] = take if take > skip else skip49
5050
51 return dp[m]51
Your Solution
20% (1/5)24μs
1def solve(input):
2    if not isinstance(input, dict):
3        return 0
4    jobs = input.get("jobs")
5    if not jobs:
6        return 0
7
8    n = len(jobs)
9    m = 0
10    for i in range(n):
11        job = jobs[i]
12        if isinstance(job, (list, tuple)) and len(job) == 3:
13            jobs[m] = job
14            m += 1
15    if m == 0:
16        return 0
17    if m != n:
18        del jobs[m:]
19
20    jobs.sort(key=lambda x: x[1])
21
22    ends = [0] * m
23    for i in range(m):
24        ends[i] = jobs[i][1]
25
26    dp = [0] * (m + 1)
27
28    for i in range(1, m + 1):
29        s, e, w = jobs[i - 1]
30
31        lo = 0
32        hi = i - 1
33        while lo < hi:
34            mid = (lo + hi) >> 1
35            if ends[mid] <= s:
36                lo = mid + 1
37            else:
38                hi = mid
39        j = lo
40        if j and ends[j - 1] > s:
41            j -= 1
42        if ends[j] <= s:
43            j += 1
44        else:
45            j = 0
46
47        take = dp[j] + w
48        skip = dp[i - 1]
49        dp[i] = take if take > skip else skip
50
51    return dp[m]
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