Solution #96012705-a644-4e7e-b0e0-3d2f937dd240

completed

Score

100% (5/5)

Runtime

46μs

Delta

No change vs parent

Tied for best

Same as parent

Solution Lineage

Current100%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("latin1")
        counts = [0] * 256
        for x in b:
            counts[x] += 1

        vals = [c for c in counts if c]
    except:
        cps = [ord(ch) for ch in text]
        cps.sort()
        vals = []
        prev = cps[0]
        cnt = 1
        for x in cps[1:]:
            if x == prev:
                cnt += 1
            else:
                vals.append(cnt)
                prev = x
                cnt = 1
        vals.append(cnt)

    m = len(vals)
    if m == 1:
        return {"encoded_length": n, "decoded": text}

    vals.sort()
    q = [0] * (m - 1)
    i = j = k = total = 0

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

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

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

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

Compare with Champion

Score Difference

Tied

Runtime Advantage

22μs slower

Code Size

57 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("latin1")8 get = counts.get
9 counts = [0] * 2569 for ch in text:
10 for x in b:10 counts[ch] = get(ch, 0) + 1
11 counts[x] += 111
1212 freqs = list(counts.values())
13 vals = [c for c in counts if c]13 m = len(freqs)
14 except:14
15 cps = [ord(ch) for ch in text]15 if m == 1:
16 cps.sort()16 return {"encoded_length": n, "decoded": text}
17 vals = []17
18 prev = cps[0]18 freqs.sort()
19 cnt = 119
20 for x in cps[1:]:20 # Bottom-up two-queue Huffman merge:
21 if x == prev:21 # use freqs as first queue and merged as second queue.
22 cnt += 122 merged = [0] * (m - 1)
23 else:23 i = j = k = 0
24 vals.append(cnt)24 total = 0
25 prev = x25
26 cnt = 126 while k < m - 1:
27 vals.append(cnt)27 if i < m and (j >= k or freqs[i] <= merged[j]):
2828 a = freqs[i]
29 m = len(vals)29 i += 1
30 if m == 1:30 else:
31 return {"encoded_length": n, "decoded": text}31 a = merged[j]
3232 j += 1
33 vals.sort()33
34 q = [0] * (m - 1)34 if i < m and (j >= k or freqs[i] <= merged[j]):
35 i = j = k = total = 035 b = freqs[i]
3636 i += 1
37 while k < m - 1:37 else:
38 if i < m and (j >= k or vals[i] <= q[j]):38 b = merged[j]
39 a = vals[i]39 j += 1
40 i += 140
41 else:41 s = a + b
42 a = q[j]42 merged[k] = s
43 j += 143 total += s
4444 k += 1
45 if i < m and (j >= k or vals[i] <= q[j]):45
46 b = vals[i]46 return {"encoded_length": total, "decoded": text}
47 i += 147
48 else:48
49 b = q[j]49
50 j += 150
5151
52 s = a + b52
53 total += s53
54 q[k] = s54
55 k += 155
5656
57 return {"encoded_length": total, "decoded": text}57
Your Solution
100% (5/5)46μ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("latin1")
9 counts = [0] * 256
10 for x in b:
11 counts[x] += 1
12
13 vals = [c for c in counts if c]
14 except:
15 cps = [ord(ch) for ch in text]
16 cps.sort()
17 vals = []
18 prev = cps[0]
19 cnt = 1
20 for x in cps[1:]:
21 if x == prev:
22 cnt += 1
23 else:
24 vals.append(cnt)
25 prev = x
26 cnt = 1
27 vals.append(cnt)
28
29 m = len(vals)
30 if m == 1:
31 return {"encoded_length": n, "decoded": text}
32
33 vals.sort()
34 q = [0] * (m - 1)
35 i = j = k = total = 0
36
37 while k < m - 1:
38 if i < m and (j >= k or vals[i] <= q[j]):
39 a = vals[i]
40 i += 1
41 else:
42 a = q[j]
43 j += 1
44
45 if i < m and (j >= k or vals[i] <= q[j]):
46 b = vals[i]
47 i += 1
48 else:
49 b = q[j]
50 j += 1
51
52 s = a + b
53 total += s
54 q[k] = s
55 k += 1
56
57 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}