Solution #58b73178-c67d-47f9-bd28-6d8c33fe6b26

completed

Score

100% (5/5)

Runtime

54μs

Delta

No change vs parent

Tied for best

Same as parent

Solution Lineage

Current100%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 = tuple(filter(lambda j: isinstance(j, (list, tuple)) and len(j) == 3, raw))
    if not jobs:
        return 0

    items = tuple(sorted(map(lambda j: (j[1], j[0], j[2]), jobs)))
    ends = tuple(map(lambda x: x[0], items))

    try:
        from bisect import bisect_right
    except Exception:
        def bisect_right(a, x, lo=0, hi=None):
            if hi is None:
                hi = len(a)
            while lo < hi:
                mid = (lo + hi) >> 1
                if x < a[mid]:
                    hi = mid
                else:
                    lo = mid + 1
            return lo

    def rec(i, memo={}):
        if i <= 0:
            return 0
        if i in memo:
            return memo[i]
        e, s, w = items[i - 1]
        j = bisect_right(ends, s, 0, i - 1)
        a = rec(i - 1, memo)
        b = w + rec(j, memo)
        memo[i] = a if a > b else b
        return memo[i]

    return rec(len(items), {})

Compare with Champion

Score Difference

Tied

Runtime Advantage

36μs slower

Code Size

41 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 = tuple(filter(lambda j: isinstance(j, (list, tuple)) and len(j) == 3, raw))8 jobs = []
9 if not jobs:9 for j in raw:
10 return 010 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 items = tuple(sorted(map(lambda j: (j[1], j[0], j[2]), jobs)))12 if not jobs:
13 ends = tuple(map(lambda x: x[0], items))13 return 0
1414
15 try:15 jobs.sort()
16 from bisect import bisect_right16 ends = []
17 except Exception:17 bests = []
18 def bisect_right(a, x, lo=0, hi=None):18
19 if hi is None:19 for e, s, w in jobs:
20 hi = len(a)20 lo = 0
21 while lo < hi:21 hi = len(ends)
22 mid = (lo + hi) >> 122 while lo < hi:
23 if x < a[mid]:23 mid = (lo + hi) >> 1
24 hi = mid24 if ends[mid] <= s:
25 else:25 lo = mid + 1
26 lo = mid + 126 else:
27 return lo27 hi = mid
2828
29 def rec(i, memo={}):29 candidate = w + (bests[lo - 1] if lo else 0)
30 if i <= 0:30 current = bests[-1] if bests else 0
31 return 031
32 if i in memo:32 if candidate > current:
33 return memo[i]33 if ends and ends[-1] == e:
34 e, s, w = items[i - 1]34 bests[-1] = candidate
35 j = bisect_right(ends, s, 0, i - 1)35 else:
36 a = rec(i - 1, memo)36 ends.append(e)
37 b = w + rec(j, memo)37 bests.append(candidate)
38 memo[i] = a if a > b else b38
39 return memo[i]39 return bests[-1] if bests else 0
4040
41 return rec(len(items), {})41
Your Solution
100% (5/5)54μ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 = tuple(filter(lambda j: isinstance(j, (list, tuple)) and len(j) == 3, raw))
9 if not jobs:
10 return 0
11
12 items = tuple(sorted(map(lambda j: (j[1], j[0], j[2]), jobs)))
13 ends = tuple(map(lambda x: x[0], items))
14
15 try:
16 from bisect import bisect_right
17 except Exception:
18 def bisect_right(a, x, lo=0, hi=None):
19 if hi is None:
20 hi = len(a)
21 while lo < hi:
22 mid = (lo + hi) >> 1
23 if x < a[mid]:
24 hi = mid
25 else:
26 lo = mid + 1
27 return lo
28
29 def rec(i, memo={}):
30 if i <= 0:
31 return 0
32 if i in memo:
33 return memo[i]
34 e, s, w = items[i - 1]
35 j = bisect_right(ends, s, 0, i - 1)
36 a = rec(i - 1, memo)
37 b = w + rec(j, memo)
38 memo[i] = a if a > b else b
39 return memo[i]
40
41 return rec(len(items), {})
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