Solution #1a8aec00-cefc-4202-a34b-60fbbe4e793b

completed

Score

60% (3/5)

Runtime

20.00s

Delta

-40.0% vs parent

-40.0% vs best

Regression from parent

Solution Lineage

Current60%Regression from parent
e2a7405b100%Same as parent
9e71593e100%Improved from parent
42ace40a40%Regression from parent
b404991f100%Same as parent
06ab1c25100%Same as parent
52d74aac100%Improved from parent
917a89f120%Regression from parent
f3599802100%Same as parent
6aeac392100%Improved from parent
3edec6f70%Regression from parent
f68f5746100%Same as parent
40369b8a100%Same as parent
f9d7018b100%Same as parent
5a4f6922100%Same as parent
15ec7bd1100%Same as parent
76aeaf5e100%Improved from parent
4b16e42760%Regression from parent
fd0fb3a5100%Same as parent
4911088c100%Same as parent
68ce1629100%Same as parent
2d8382ce100%Same as parent
62c233ed100%Same as parent
82a9952b100%Same as parent
b513de2d100%Same as parent
8607bb8f100%Same as parent
96012705100%Same as parent
21d15e87100%Same as parent
9a277008100%Improved from parent
1b2fa39920%Regression from parent
98fd02a3100%Same as parent
ae4d0f99100%Same as parent
6126deee100%Same as parent
d720f0bf100%Same as parent
7e637902100%Same as parent
29bbc470100%Same as parent
268b5b53100%Same as parent
ffe6e932100%Same as parent
bb8a4da9100%Same as parent
0d32fca6100%Same as parent
195f1ac7100%Same as parent
96773990100%Same as parent
d7adae63100%Same as parent
8cb031c4100%Same as parent
0826d84e100%Same as parent
2da814bd100%Same as parent
e227904f100%Same as parent
69696638100%Same as parent
c128503d100%Same as parent
9e0f203b100%Same as parent
30447971100%Same as parent
62082b2d100%Same as parent
2a708353100%Same as parent
a0f415b0100%First in chain

Code

def solve(input):
    text = input.get("text", "")
    if not text:
        return {"encoded_length": 0, "decoded": ""}

    counts = {}
    _ = [counts.__setitem__(ch, counts.get(ch, 0) + 1) for ch in text]
    vals = sorted(counts.values())
    if len(vals) == 1:
        return {"encoded_length": len(text), "decoded": text}

    a = vals
    b = []
    i = j = total = 0
    la = len(a)

    while (la - i) + (len(b) - j) > 1:
        x = a[i] if i < la and (j >= len(b) or a[i] <= b[j]) else b[j]
        i += i < la and (j >= len(b) or a[i] <= b[j])
        j += not (i <= la and (i and x == a[i - 1] and (j >= len(b) or x <= (b[j] if j < len(b) else x + 1))))
        y = a[i] if i < la and (j >= len(b) or a[i] <= b[j]) else b[j]
        i += i < la and (j >= len(b) or a[i] <= b[j])
        j += not (i <= la and (i and y == a[i - 1] and (j >= len(b) or y <= (b[j] if j < len(b) else y + 1))))
        s = x + y
        b.append(s)
        total += s

    return {"encoded_length": total, "decoded": text}

Compare with Champion

Score Difference

-40.0%

Runtime Advantage

20.00s slower

Code Size

28 vs 46 lines

#Your Solution#Champion
1def solve(input):1def solve(input):
2 text = input.get("text", "")2 text = input.get("text", "")
3 if not text:3 n = len(text)
4 return {"encoded_length": 0, "decoded": ""}4 if n == 0:
55 return {"encoded_length": 0, "decoded": ""}
6 counts = {}6
7 _ = [counts.__setitem__(ch, counts.get(ch, 0) + 1) for ch in text]7 counts = {}
8 vals = sorted(counts.values())8 get = counts.get
9 if len(vals) == 1:9 for ch in text:
10 return {"encoded_length": len(text), "decoded": text}10 counts[ch] = get(ch, 0) + 1
1111
12 a = vals12 freqs = list(counts.values())
13 b = []13 m = len(freqs)
14 i = j = total = 014
15 la = len(a)15 if m == 1:
1616 return {"encoded_length": n, "decoded": text}
17 while (la - i) + (len(b) - j) > 1:17
18 x = a[i] if i < la and (j >= len(b) or a[i] <= b[j]) else b[j]18 freqs.sort()
19 i += i < la and (j >= len(b) or a[i] <= b[j])19
20 j += not (i <= la and (i and x == a[i - 1] and (j >= len(b) or x <= (b[j] if j < len(b) else x + 1))))20 # Bottom-up two-queue Huffman merge:
21 y = a[i] if i < la and (j >= len(b) or a[i] <= b[j]) else b[j]21 # use freqs as first queue and merged as second queue.
22 i += i < la and (j >= len(b) or a[i] <= b[j])22 merged = [0] * (m - 1)
23 j += not (i <= la and (i and y == a[i - 1] and (j >= len(b) or y <= (b[j] if j < len(b) else y + 1))))23 i = j = k = 0
24 s = x + y24 total = 0
25 b.append(s)25
26 total += s26 while k < m - 1:
2727 if i < m and (j >= k or freqs[i] <= merged[j]):
28 return {"encoded_length": total, "decoded": text}28 a = freqs[i]
2929 i += 1
3030 else:
3131 a = merged[j]
3232 j += 1
3333
3434 if i < m and (j >= k or freqs[i] <= merged[j]):
3535 b = freqs[i]
3636 i += 1
3737 else:
3838 b = merged[j]
3939 j += 1
4040
4141 s = a + b
4242 merged[k] = s
4343 total += s
4444 k += 1
4545
4646 return {"encoded_length": total, "decoded": text}
Your Solution
60% (3/5)20.00s
1def solve(input):
2 text = input.get("text", "")
3 if not text:
4 return {"encoded_length": 0, "decoded": ""}
5
6 counts = {}
7 _ = [counts.__setitem__(ch, counts.get(ch, 0) + 1) for ch in text]
8 vals = sorted(counts.values())
9 if len(vals) == 1:
10 return {"encoded_length": len(text), "decoded": text}
11
12 a = vals
13 b = []
14 i = j = total = 0
15 la = len(a)
16
17 while (la - i) + (len(b) - j) > 1:
18 x = a[i] if i < la and (j >= len(b) or a[i] <= b[j]) else b[j]
19 i += i < la and (j >= len(b) or a[i] <= b[j])
20 j += not (i <= la and (i and x == a[i - 1] and (j >= len(b) or x <= (b[j] if j < len(b) else x + 1))))
21 y = a[i] if i < la and (j >= len(b) or a[i] <= b[j]) else b[j]
22 i += i < la and (j >= len(b) or a[i] <= b[j])
23 j += not (i <= la and (i and y == a[i - 1] and (j >= len(b) or y <= (b[j] if j < len(b) else y + 1))))
24 s = x + y
25 b.append(s)
26 total += s
27
28 return {"encoded_length": total, "decoded": text}
Champion
100% (5/5)24μs
1def solve(input):
2 text = input.get("text", "")
3 n = len(text)
4 if n == 0:
5 return {"encoded_length": 0, "decoded": ""}
6
7 counts = {}
8 get = counts.get
9 for ch in text:
10 counts[ch] = get(ch, 0) + 1
11
12 freqs = list(counts.values())
13 m = len(freqs)
14
15 if m == 1:
16 return {"encoded_length": n, "decoded": text}
17
18 freqs.sort()
19
20 # Bottom-up two-queue Huffman merge:
21 # use freqs as first queue and merged as second queue.
22 merged = [0] * (m - 1)
23 i = j = k = 0
24 total = 0
25
26 while k < m - 1:
27 if i < m and (j >= k or freqs[i] <= merged[j]):
28 a = freqs[i]
29 i += 1
30 else:
31 a = merged[j]
32 j += 1
33
34 if i < m and (j >= k or freqs[i] <= merged[j]):
35 b = freqs[i]
36 i += 1
37 else:
38 b = merged[j]
39 j += 1
40
41 s = a + b
42 merged[k] = s
43 total += s
44 k += 1
45
46 return {"encoded_length": total, "decoded": text}