Solution #9e71593e-ad2f-44f6-9247-8066511ef4ef

completed

Score

100% (5/5)

Runtime

57μs

Delta

+150.0% vs parent

Tied for best

Improved from parent

Solution Lineage

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

    try:
        b = text.encode("utf-32-le")
        counts = {}
        get = counts.get
        for i in range(0, len(b), 4):
            cp = b[i] | (b[i + 1] << 8) | (b[i + 2] << 16) | (b[i + 3] << 24)
            counts[cp] = get(cp, 0) + 1
    except Exception:
        counts = {}
        get = counts.get
        for ch in text:
            counts[ch] = get(ch, 0) + 1

    vals = list(counts.values())
    if len(vals) == 1:
        return {"encoded_length": n, "decoded": text}

    vals.sort()
    m = len(vals)
    q = vals + [0] * (m - 1)
    i = 0
    j = m
    end = m

    total = 0
    for _ in range(m - 1):
        if i < m and (j >= end or q[i] <= q[j]):
            a = q[i]
            i += 1
        else:
            a = q[j]
            j += 1

        if i < m and (j >= end or q[i] <= q[j]):
            b = q[i]
            i += 1
        else:
            b = q[j]
            j += 1

        s = a + b
        q[end] = s
        end += 1
        total += s

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

Compare with Champion

Score Difference

Tied

Runtime Advantage

33μs slower

Code Size

52 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 try:7 counts = {}
8 b = text.encode("utf-32-le")8 get = counts.get
9 counts = {}9 for ch in text:
10 get = counts.get10 counts[ch] = get(ch, 0) + 1
11 for i in range(0, len(b), 4):11
12 cp = b[i] | (b[i + 1] << 8) | (b[i + 2] << 16) | (b[i + 3] << 24)12 freqs = list(counts.values())
13 counts[cp] = get(cp, 0) + 113 m = len(freqs)
14 except Exception:14
15 counts = {}15 if m == 1:
16 get = counts.get16 return {"encoded_length": n, "decoded": text}
17 for ch in text:17
18 counts[ch] = get(ch, 0) + 118 freqs.sort()
1919
20 vals = list(counts.values())20 # Bottom-up two-queue Huffman merge:
21 if len(vals) == 1:21 # use freqs as first queue and merged as second queue.
22 return {"encoded_length": n, "decoded": text}22 merged = [0] * (m - 1)
2323 i = j = k = 0
24 vals.sort()24 total = 0
25 m = len(vals)25
26 q = vals + [0] * (m - 1)26 while k < m - 1:
27 i = 027 if i < m and (j >= k or freqs[i] <= merged[j]):
28 j = m28 a = freqs[i]
29 end = m29 i += 1
3030 else:
31 total = 031 a = merged[j]
32 for _ in range(m - 1):32 j += 1
33 if i < m and (j >= end or q[i] <= q[j]):33
34 a = q[i]34 if i < m and (j >= k or freqs[i] <= merged[j]):
35 i += 135 b = freqs[i]
36 else:36 i += 1
37 a = q[j]37 else:
38 j += 138 b = merged[j]
3939 j += 1
40 if i < m and (j >= end or q[i] <= q[j]):40
41 b = q[i]41 s = a + b
42 i += 142 merged[k] = s
43 else:43 total += s
44 b = q[j]44 k += 1
45 j += 145
4646 return {"encoded_length": total, "decoded": text}
47 s = a + b47
48 q[end] = s48
49 end += 149
50 total += s50
5151
52 return {"encoded_length": total, "decoded": text}52
Your Solution
100% (5/5)57μ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 try:
8 b = text.encode("utf-32-le")
9 counts = {}
10 get = counts.get
11 for i in range(0, len(b), 4):
12 cp = b[i] | (b[i + 1] << 8) | (b[i + 2] << 16) | (b[i + 3] << 24)
13 counts[cp] = get(cp, 0) + 1
14 except Exception:
15 counts = {}
16 get = counts.get
17 for ch in text:
18 counts[ch] = get(ch, 0) + 1
19
20 vals = list(counts.values())
21 if len(vals) == 1:
22 return {"encoded_length": n, "decoded": text}
23
24 vals.sort()
25 m = len(vals)
26 q = vals + [0] * (m - 1)
27 i = 0
28 j = m
29 end = m
30
31 total = 0
32 for _ in range(m - 1):
33 if i < m and (j >= end or q[i] <= q[j]):
34 a = q[i]
35 i += 1
36 else:
37 a = q[j]
38 j += 1
39
40 if i < m and (j >= end or q[i] <= q[j]):
41 b = q[i]
42 i += 1
43 else:
44 b = q[j]
45 j += 1
46
47 s = a + b
48 q[end] = s
49 end += 1
50 total += s
51
52 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}