Solution #aab82514-b0a3-46d1-a269-daeec40c39cb

completed

Score

20% (1/5)

Runtime

45μs

Delta

-80.0% vs parent

-80.0% vs best

Regression from parent

Solution Lineage

Current20%Regression from parent
92b8345a100%Same as parent
c4c348af100%Same as parent
9908d5a6100%Same as parent
9e652ec1100%Same as parent
a9989ddf100%Same as parent
8b739256100%Same as parent
e89bb3d4100%Same as parent
9462a7c0100%Same as parent
f79acfd9100%Improved from parent
41f0098420%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

    valid = []
    starts_set = set()
    ends_set = set()

    for j in raw:
        if isinstance(j, (list, tuple)) and len(j) == 3:
            s, e, w = j
            valid.append((s, e, w))
            starts_set.add(s)
            ends_set.add(e)

    if not valid:
        return 0

    times = sorted(starts_set | ends_set)
    m = len(times)
    index = {}
    for i, t in enumerate(times):
        index[t] = i

    start_to_jobs = [[] for _ in range(m)]
    end_here = [0] * m

    for s, e, w in valid:
        si = index[s]
        ei = index[e]
        start_to_jobs[si].append((ei, w))
        if end_here[ei] < 0:
            end_here[ei] = 0

    dp = [0] * (m + 1)

    for i in range(m):
        cur = dp[i]
        if cur > dp[i + 1]:
            dp[i + 1] = cur

        jobs_at_start = start_to_jobs[i]
        if jobs_at_start:
            for ei, w in jobs_at_start:
                val = cur + w
                nxt = ei + 1
                if val > dp[nxt]:
                    dp[nxt] = val

    best = 0
    for v in dp:
        if v > best:
            best = v
    return best

Compare with Champion

Score Difference

-80.0%

Runtime Advantage

27μs slower

Code Size

57 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 valid = []8 jobs = []
9 starts_set = set()9 for j in raw:
10 ends_set = set()10 if isinstance(j, (list, tuple)) and len(j) == 3:
1111 jobs.append((j[1], j[0], j[2])) # sort by end, store as (end, start, weight)
12 for j in raw:12 if not jobs:
13 if isinstance(j, (list, tuple)) and len(j) == 3:13 return 0
14 s, e, w = j14
15 valid.append((s, e, w))15 jobs.sort()
16 starts_set.add(s)16 ends = []
17 ends_set.add(e)17 bests = []
1818
19 if not valid:19 for e, s, w in jobs:
20 return 020 lo = 0
2121 hi = len(ends)
22 times = sorted(starts_set | ends_set)22 while lo < hi:
23 m = len(times)23 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 start_to_jobs = [[] for _ in range(m)]28
29 end_here = [0] * m29 candidate = w + (bests[lo - 1] if lo else 0)
3030 current = bests[-1] if bests else 0
31 for s, e, w in valid:31
32 si = index[s]32 if candidate > current:
33 ei = index[e]33 if ends and ends[-1] == e:
34 start_to_jobs[si].append((ei, w))34 bests[-1] = candidate
35 if end_here[ei] < 0:35 else:
36 end_here[ei] = 036 ends.append(e)
3737 bests.append(candidate)
38 dp = [0] * (m + 1)38
3939 return bests[-1] if bests else 0
40 for i in range(m):40
41 cur = dp[i]41
42 if cur > dp[i + 1]:42
43 dp[i + 1] = cur43
4444
45 jobs_at_start = start_to_jobs[i]45
46 if jobs_at_start:46
47 for ei, w in jobs_at_start:47
48 val = cur + w48
49 nxt = ei + 149
50 if val > dp[nxt]:50
51 dp[nxt] = val51
5252
53 best = 053
54 for v in dp:54
55 if v > best:55
56 best = v56
57 return best57
Your Solution
20% (1/5)45μ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 valid = []
9 starts_set = set()
10 ends_set = set()
11
12 for j in raw:
13 if isinstance(j, (list, tuple)) and len(j) == 3:
14 s, e, w = j
15 valid.append((s, e, w))
16 starts_set.add(s)
17 ends_set.add(e)
18
19 if not valid:
20 return 0
21
22 times = sorted(starts_set | ends_set)
23 m = len(times)
24 index = {}
25 for i, t in enumerate(times):
26 index[t] = i
27
28 start_to_jobs = [[] for _ in range(m)]
29 end_here = [0] * m
30
31 for s, e, w in valid:
32 si = index[s]
33 ei = index[e]
34 start_to_jobs[si].append((ei, w))
35 if end_here[ei] < 0:
36 end_here[ei] = 0
37
38 dp = [0] * (m + 1)
39
40 for i in range(m):
41 cur = dp[i]
42 if cur > dp[i + 1]:
43 dp[i + 1] = cur
44
45 jobs_at_start = start_to_jobs[i]
46 if jobs_at_start:
47 for ei, w in jobs_at_start:
48 val = cur + w
49 nxt = ei + 1
50 if val > dp[nxt]:
51 dp[nxt] = val
52
53 best = 0
54 for v in dp:
55 if v > best:
56 best = v
57 return best
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