Solution #d720f0bf-a6c8-49aa-aae0-4cb9c0718e07

completed

Score

100% (5/5)

Runtime

87μs

Delta

No change vs parent

Tied for best

Same as parent

Solution Lineage

Current100%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": ""}

    from array import array

    try:
        counts = array('I', [0]) * 256
        for ch in text:
            counts[ord(ch)] += 1

        freqs = array('I')
        for c in counts:
            if c:
                freqs.append(c)
    except:
        d = {}
        for ch in text:
            d[ch] = d.get(ch, 0) + 1
        freqs = array('I', d.values())

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

    freqs = array('I', sorted(freqs))
    merged = array('I', [0]) * (m - 1)

    i = 0
    j = 0
    total = 0

    for k in range(m - 1):
        if i < m and (j >= k or freqs[i] <= merged[j]):
            a = freqs[i]
            i += 1
        else:
            a = merged[j]
            j += 1

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

        s = a + b
        merged[k] = s
        total += s

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

Compare with Champion

Score Difference

Tied

Runtime Advantage

63μs slower

Code Size

54 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 from array import array7 counts = {}
88 get = counts.get
9 try:9 for ch in text:
10 counts = array('I', [0]) * 25610 counts[ch] = get(ch, 0) + 1
11 for ch in text:11
12 counts[ord(ch)] += 112 freqs = list(counts.values())
1313 m = len(freqs)
14 freqs = array('I')14
15 for c in counts:15 if m == 1:
16 if c:16 return {"encoded_length": n, "decoded": text}
17 freqs.append(c)17
18 except:18 freqs.sort()
19 d = {}19
20 for ch in text:20 # Bottom-up two-queue Huffman merge:
21 d[ch] = d.get(ch, 0) + 121 # use freqs as first queue and merged as second queue.
22 freqs = array('I', d.values())22 merged = [0] * (m - 1)
2323 i = j = k = 0
24 m = len(freqs)24 total = 0
25 if m == 1:25
26 return {"encoded_length": n, "decoded": text}26 while k < m - 1:
2727 if i < m and (j >= k or freqs[i] <= merged[j]):
28 freqs = array('I', sorted(freqs))28 a = freqs[i]
29 merged = array('I', [0]) * (m - 1)29 i += 1
3030 else:
31 i = 031 a = merged[j]
32 j = 032 j += 1
33 total = 033
3434 if i < m and (j >= k or freqs[i] <= merged[j]):
35 for k in range(m - 1):35 b = freqs[i]
36 if i < m and (j >= k or freqs[i] <= merged[j]):36 i += 1
37 a = freqs[i]37 else:
38 i += 138 b = merged[j]
39 else:39 j += 1
40 a = merged[j]40
41 j += 141 s = a + b
4242 merged[k] = s
43 if i < m and (j >= k or freqs[i] <= merged[j]):43 total += s
44 b = freqs[i]44 k += 1
45 i += 145
46 else:46 return {"encoded_length": total, "decoded": text}
47 b = merged[j]47
48 j += 148
4949
50 s = a + b50
51 merged[k] = s51
52 total += s52
5353
54 return {"encoded_length": total, "decoded": text}54
Your Solution
100% (5/5)87μ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 from array import array
8
9 try:
10 counts = array('I', [0]) * 256
11 for ch in text:
12 counts[ord(ch)] += 1
13
14 freqs = array('I')
15 for c in counts:
16 if c:
17 freqs.append(c)
18 except:
19 d = {}
20 for ch in text:
21 d[ch] = d.get(ch, 0) + 1
22 freqs = array('I', d.values())
23
24 m = len(freqs)
25 if m == 1:
26 return {"encoded_length": n, "decoded": text}
27
28 freqs = array('I', sorted(freqs))
29 merged = array('I', [0]) * (m - 1)
30
31 i = 0
32 j = 0
33 total = 0
34
35 for k in range(m - 1):
36 if i < m and (j >= k or freqs[i] <= merged[j]):
37 a = freqs[i]
38 i += 1
39 else:
40 a = merged[j]
41 j += 1
42
43 if i < m and (j >= k or freqs[i] <= merged[j]):
44 b = freqs[i]
45 i += 1
46 else:
47 b = merged[j]
48 j += 1
49
50 s = a + b
51 merged[k] = s
52 total += s
53
54 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}