Solution #f9d7018b-4fd9-4d38-a260-8e9800fb243d

completed

Score

100% (5/5)

Runtime

40μs

Delta

No change vs parent

Tied for best

Same as parent

Solution Lineage

Current100%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", "")
    n = len(text)
    if n == 0:
        return {"encoded_length": 0, "decoded": ""}

    counts = {}
    for ch in text:
        counts[ch] = counts.get(ch, 0) + 1

    freqs = list(counts.values())
    m = len(freqs)

    if m == 1:
        return {"encoded_length": n, "decoded": text}
    if m == 2:
        return {"encoded_length": n, "decoded": text}

    buckets = [0] * (n + 1)
    for f in freqs:
        buckets[f] += 1

    q1 = [0] * m
    t = 0
    for f in range(1, n + 1):
        c = buckets[f]
        while c:
            q1[t] = f
            t += 1
            c -= 1

    q2 = [0] * (m - 1)
    i = j = k = 0
    total = 0

    while k < m - 1:
        if i < m and (j >= k or q1[i] <= q2[j]):
            a = q1[i]
            i += 1
        else:
            a = q2[j]
            j += 1

        if i < m and (j >= k or q1[i] <= q2[j]):
            b = q1[i]
            i += 1
        else:
            b = q2[j]
            j += 1

        s = a + b
        q2[k] = s
        total += s
        k += 1

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

Compare with Champion

Score Difference

Tied

Runtime Advantage

16μs slower

Code Size

56 vs 46 lines

#Your Solution#Champion
1def solve(input):1def solve(input):
2 text = input.get("text", "")2 text = input.get("text", "")
3 n = len(text)3 n = len(text)
4 if n == 0:4 if n == 0:
5 return {"encoded_length": 0, "decoded": ""}5 return {"encoded_length": 0, "decoded": ""}
66
7 counts = {}7 counts = {}
8 for ch in text:8 get = counts.get
9 counts[ch] = counts.get(ch, 0) + 19 for ch in text:
1010 counts[ch] = get(ch, 0) + 1
11 freqs = list(counts.values())11
12 m = len(freqs)12 freqs = list(counts.values())
1313 m = len(freqs)
14 if m == 1:14
15 return {"encoded_length": n, "decoded": text}15 if m == 1:
16 if m == 2:16 return {"encoded_length": n, "decoded": text}
17 return {"encoded_length": n, "decoded": text}17
1818 freqs.sort()
19 buckets = [0] * (n + 1)19
20 for f in freqs:20 # Bottom-up two-queue Huffman merge:
21 buckets[f] += 121 # use freqs as first queue and merged as second queue.
2222 merged = [0] * (m - 1)
23 q1 = [0] * m23 i = j = k = 0
24 t = 024 total = 0
25 for f in range(1, n + 1):25
26 c = buckets[f]26 while k < m - 1:
27 while c:27 if i < m and (j >= k or freqs[i] <= merged[j]):
28 q1[t] = f28 a = freqs[i]
29 t += 129 i += 1
30 c -= 130 else:
3131 a = merged[j]
32 q2 = [0] * (m - 1)32 j += 1
33 i = j = k = 033
34 total = 034 if i < m and (j >= k or freqs[i] <= merged[j]):
3535 b = freqs[i]
36 while k < m - 1:36 i += 1
37 if i < m and (j >= k or q1[i] <= q2[j]):37 else:
38 a = q1[i]38 b = merged[j]
39 i += 139 j += 1
40 else:40
41 a = q2[j]41 s = a + b
42 j += 142 merged[k] = s
4343 total += s
44 if i < m and (j >= k or q1[i] <= q2[j]):44 k += 1
45 b = q1[i]45
46 i += 146 return {"encoded_length": total, "decoded": text}
47 else:47
48 b = q2[j]48
49 j += 149
5050
51 s = a + b51
52 q2[k] = s52
53 total += s53
54 k += 154
5555
56 return {"encoded_length": total, "decoded": text}56
Your Solution
100% (5/5)40μ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 for ch in text:
9 counts[ch] = counts.get(ch, 0) + 1
10
11 freqs = list(counts.values())
12 m = len(freqs)
13
14 if m == 1:
15 return {"encoded_length": n, "decoded": text}
16 if m == 2:
17 return {"encoded_length": n, "decoded": text}
18
19 buckets = [0] * (n + 1)
20 for f in freqs:
21 buckets[f] += 1
22
23 q1 = [0] * m
24 t = 0
25 for f in range(1, n + 1):
26 c = buckets[f]
27 while c:
28 q1[t] = f
29 t += 1
30 c -= 1
31
32 q2 = [0] * (m - 1)
33 i = j = k = 0
34 total = 0
35
36 while k < m - 1:
37 if i < m and (j >= k or q1[i] <= q2[j]):
38 a = q1[i]
39 i += 1
40 else:
41 a = q2[j]
42 j += 1
43
44 if i < m and (j >= k or q1[i] <= q2[j]):
45 b = q1[i]
46 i += 1
47 else:
48 b = q2[j]
49 j += 1
50
51 s = a + b
52 q2[k] = s
53 total += s
54 k += 1
55
56 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}