Tasks Details
hard
1.
LetterCover
Given two strings P and Q, find the minimum number of distinct letters in a string constructed by selecting, for each position, a letter from either P or Q.
Task Score
100%
Correctness
100%
Performance
100%
We are given two strings P and Q, each consisting of N lowercase English letters. For each position in the strings, we have to choose one letter from either P or Q, in order to construct a new string S, such that the number of distinct letters in S is minimal. Our task is to find the number of distinct letters in the resulting string S.
For example, if P = "ca" and Q = "ab", S can be equal to: "ca", "cb", "aa" or "ab". String "aa" has only one distinct letter ('a'), so the answer is 1 (which is minimal among those strings).
Write a function:
def solution(P, Q)
that, given two strings P and Q, both of length N, returns the minimum number of distinct letters of a string S, that can be constructed from P and Q as described above.
Examples:
1. Given P = "abc", Q = "bcd", your function should return 2. All possible strings S that can be constructed are: "abc", "abd", "acc", "acd", "bbc", "bbd", "bcc", "bcd". The minimum number of distinct letters is 2, which be obtained by constructing the following strings: "acc", "bbc", "bbd", "bcc".
2. Given P = "axxz", Q = "yzwy", your function should return 2. String S must consist of at least two distinct letters in this case. We can construct S = "yxxy", where the number of distinct letters is equal to 2, and this is the only optimal solution.
3. Given P = "bacad", Q = "abada", your function should return 1. We can choose the letter 'a' in each position, so S can be equal to "aaaaa".
4. Given P = "amz", Q = "amz", your function should return 3. The input strings are identical, so the only possible S that can be constructed is "amz", and its number of distinct letters is 3.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..200,000];
- strings P and Q are both of length N;
- strings P and Q are made only of lowercase letters (a−z);
- strings P and Q contain a total of at most 20 distinct letters.
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Python
Time spent on task 14 minutes
Notes
not defined yet
Code: 14:21:23 UTC,
java,
autosave
Code: 14:25:22 UTC,
py,
autosave
Code: 14:25:32 UTC,
py,
autosave
Code: 14:25:39 UTC,
py,
verify,
result: Failed
Analysis
expand all
Example tests
1.
0.012 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 113, in <module>
main()
File "exec.py", line 89, in main
result = solution( P, Q )
File "/tmp/exec_user_xxjz2p7f/solution.py", line 12, in solution
return ans
NameError: name 'ans' is not defined
1.
0.012 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 113, in <module>
main()
File "exec.py", line 89, in main
result = solution( P, Q )
File "/tmp/exec_user_xxjz2p7f/solution.py", line 12, in solution
return ans
NameError: name 'ans' is not defined
1.
0.012 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 113, in <module>
main()
File "exec.py", line 89, in main
result = solution( P, Q )
File "/tmp/exec_user_xxjz2p7f/solution.py", line 12, in solution
return ans
NameError: name 'ans' is not defined
1.
0.012 s
RUNTIME ERROR,
tested program terminated with exit code 1
stderr:
Traceback (most recent call last):
File "exec.py", line 113, in <module>
main()
File "exec.py", line 89, in main
result = solution( P, Q )
File "/tmp/exec_user_xxjz2p7f/solution.py", line 12, in solution
return ans
NameError: name 'ans' is not defined
Code: 14:26:06 UTC,
py,
autosave
Code: 14:27:49 UTC,
py,
autosave
Code: 14:28:01 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
Code: 14:28:15 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
Code: 14:28:30 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
# compute
Code: 14:28:55 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
# compute
# Update the character counts in array 'a' based on the characters in strings 'P' and 'Q'
for i in range(n):
a[ord(P[i]) - ord('a')] = a[ord(Q[i]) - ord('a')] = 1
# Calculate cumulative sums in array 'a'
for i in range(1, 26):
a[i] += a[i-1]
b1 = [0] * 20 # Reset array 'b1' to zeros
b2 = [[0] * 20 for _ in range(20)] # Reset array 'b2' to zeros
Code: 14:32:21 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
# compute
# Update the character counts in array 'a' based on the characters in strings 'P' and 'Q'
for i in range(n):
a[ord(P[i]) - ord('a')] = a[ord(Q[i]) - ord('a')] = 1
# Calculate cumulative sums in array 'a'
for i in range(1, 26):
a[i] += a[i-1]
b1 = [0] * 20 # Reset array 'b1' to zeros
b2 = [[0] * 20 for _ in range(20)] # Reset array 'b2' to zeros
# Perform calculations for 'b1' and 'b2'
for i in range(n):
if P[i] == Q[i]:
b1[a[ord(P[i]) - ord('a')]] += 1
else:
b1[a[ord(P[i]) - ord('a')]] += 1
b1[a[ord(Q[i]) - ord('a')]] += 1
b2[a[ord(P[i]) - ord('a')]][a[ord(Q[i]) - ord('a')]] -= 1
b2[a[ord(Q[i]) - ord('a')]][a[ord(P[i]) - ord('a')]] -= 1
Code: 14:32:35 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
# compute
# Update the character counts in array 'a' based on the characters in strings 'P' and 'Q'
for i in range(n):
a[ord(P[i]) - ord('a')] = a[ord(Q[i]) - ord('a')] = 1
# Calculate cumulative sums in array 'a'
for i in range(1, 26):
a[i] += a[i-1]
b1 = [0] * 20 # Reset array 'b1' to zeros
b2 = [[0] * 20 for _ in range(20)] # Reset array 'b2' to zeros
# Perform calculations for 'b1' and 'b2'
for i in range(n):
if P[i] == Q[i]:
b1[a[ord(P[i]) - ord('a')]] += 1
else:
b1[a[ord(P[i]) - ord('a')]] += 1
b1[a[ord(Q[i]) - ord('a')]] += 1
b2[a[ord(P[i]) - ord('a')]][a[ord(Q[i]) - ord('a')]] -= 1
b2[a[ord(Q[i]) - ord('a')]][a[ord(P[i]) - ord('a')]] -= 1
Code: 14:33:05 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
# compute
# Update the character counts in array 'a' based on the characters in strings 'P' and 'Q'
for i in range(n):
a[ord(P[i]) - ord('a')] = a[ord(Q[i]) - ord('a')] = 1
# Calculate cumulative sums in array 'a'
for i in range(1, 26):
a[i] += a[i-1]
b1 = [0] * 20 # Reset array 'b1' to zeros
b2 = [[0] * 20 for _ in range(20)] # Reset array 'b2' to zeros
# Perform calculations for 'b1' and 'b2'
for i in range(n):
if P[i] == Q[i]:
b1[a[ord(P[i]) - ord('a')]] += 1
else:
b1[a[ord(P[i]) - ord('a')]] += 1
b1[a[ord(Q[i]) - ord('a')]] += 1
b2[a[ord(P[i]) - ord('a')]][a[ord(Q[i]) - ord('a')]] -= 1
b2[a[ord(Q[i]) - ord('a')]][a[ord(P[i]) - ord('a')]] -= 1
Code: 14:33:23 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
# compute
# Update the character counts in array 'a' based on the characters in strings 'P' and 'Q'
for i in range(n):
a[ord(P[i]) - ord('a')] = a[ord(Q[i]) - ord('a')] = 1
# Calculate cumulative sums in array 'a'
for i in range(1, 26):
a[i] += a[i-1]
b1 = [0] * 20 # Reset array 'b1' to zeros
b2 = [[0] * 20 for _ in range(20)] # Reset array 'b2' to zeros
# Perform calculations for 'b1' and 'b2'
for i in range(n):
if P[i] == Q[i]:
b1[a[ord(P[i]) - ord('a')]] += 1
else:
b1[a[ord(P[i]) - ord('a')]] += 1
b1[a[ord(Q[i]) - ord('a')]] += 1
b2[a[ord(P[i]) - ord('a')]][a[ord(Q[i]) - ord('a')]] -= 1
b2[a[ord(Q[i]) - ord('a')]][a[ord(P[i]) - ord('a')]] -= 1
m = a[25] + 1 # Determine the number of distinct characters
ans = m # Set 'ans' as the maximum possible value, worst case
Code: 14:33:39 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
# compute
# Update the character counts in array 'a' based on the characters in strings 'P' and 'Q'
for i in range(n):
a[ord(P[i]) - ord('a')] = a[ord(Q[i]) - ord('a')] = 1
# Calculate cumulative sums in array 'a'
for i in range(1, 26):
a[i] += a[i-1]
b1 = [0] * 20 # Reset array 'b1' to zeros
b2 = [[0] * 20 for _ in range(20)] # Reset array 'b2' to zeros
# Perform calculations for 'b1' and 'b2'
for i in range(n):
if P[i] == Q[i]:
b1[a[ord(P[i]) - ord('a')]] += 1
else:
b1[a[ord(P[i]) - ord('a')]] += 1
b1[a[ord(Q[i]) - ord('a')]] += 1
b2[a[ord(P[i]) - ord('a')]][a[ord(Q[i]) - ord('a')]] -= 1
b2[a[ord(Q[i]) - ord('a')]][a[ord(P[i]) - ord('a')]] -= 1
m = a[25] + 1 # Determine the number of distinct characters
ans = m # Set 'ans' as the maximum possible value, worst case
o = [0] * (1 << m) # Create a list to store intermediate calculations
s = [0] * (1 << m) # Create a list to store intermediate calculations
Code: 14:33:55 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
# compute
# Update the character counts in array 'a' based on the characters in strings 'P' and 'Q'
for i in range(n):
a[ord(P[i]) - ord('a')] = a[ord(Q[i]) - ord('a')] = 1
# Calculate cumulative sums in array 'a'
for i in range(1, 26):
a[i] += a[i-1]
b1 = [0] * 20 # Reset array 'b1' to zeros
b2 = [[0] * 20 for _ in range(20)] # Reset array 'b2' to zeros
# Perform calculations for 'b1' and 'b2'
for i in range(n):
if P[i] == Q[i]:
b1[a[ord(P[i]) - ord('a')]] += 1
else:
b1[a[ord(P[i]) - ord('a')]] += 1
b1[a[ord(Q[i]) - ord('a')]] += 1
b2[a[ord(P[i]) - ord('a')]][a[ord(Q[i]) - ord('a')]] -= 1
b2[a[ord(Q[i]) - ord('a')]][a[ord(P[i]) - ord('a')]] -= 1
m = a[25] + 1 # Determine the number of distinct characters
ans = m # Set 'ans' as the maximum possible value, worst case
o = [0] * (1 << m) # Create a list to store intermediate calculations
s = [0] * (1 << m) # Create a list to store intermediate calculations
return ans
Code: 14:34:21 UTC,
py,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
# compute
# Update the character counts in array 'a' based on the characters in strings 'P' and 'Q'
for i in range(n):
a[ord(P[i]) - ord('a')] = a[ord(Q[i]) - ord('a')] = 1
# Calculate cumulative sums in array 'a'
for i in range(1, 26):
a[i] += a[i-1]
b1 = [0] * 20 # Reset array 'b1' to zeros
b2 = [[0] * 20 for _ in range(20)] # Reset array 'b2' to zeros
# Perform calculations for 'b1' and 'b2'
for i in range(n):
if P[i] == Q[i]:
b1[a[ord(P[i]) - ord('a')]] += 1
else:
b1[a[ord(P[i]) - ord('a')]] += 1
b1[a[ord(Q[i]) - ord('a')]] += 1
b2[a[ord(P[i]) - ord('a')]][a[ord(Q[i]) - ord('a')]] -= 1
b2[a[ord(Q[i]) - ord('a')]][a[ord(P[i]) - ord('a')]] -= 1
m = a[25] + 1 # Determine the number of distinct characters
ans = m # Set 'ans' as the maximum possible value, worst case
o = [0] * (1 << m) # Create a list to store intermediate calculations
s = [0] * (1 << m) # Create a list to store intermediate calculations
# Perform calculations using bitwise operations
for i in range(1, 1 << m):
j = 0
k = i & -i
# Find the rightmost bit that is set to 1
while not (k >> j) & 1:
j += 1
# Update intermediate calculations for 'o' and 's'
o[i] = o[i >> 1] + (i & 1)
s[i] = s[i ^ k] + b1[j]
# Perform additional calculations for 's' based on 'b2'
for k in range(j + 1, m):
if (i >> k) & 1:
s[i] += b2[j][k]
# Check if 's' is equal to 'n' and update 'ans' accordingly
if s[i] == n:
ans = min(ans, o[i])
return ans
Code: 14:34:36 UTC,
py,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
# compute
# Update the character counts in array 'a' based on the characters in strings 'P' and 'Q'
for i in range(n):
a[ord(P[i]) - ord('a')] = a[ord(Q[i]) - ord('a')] = 1
# Calculate cumulative sums in array 'a'
for i in range(1, 26):
a[i] += a[i-1]
b1 = [0] * 20 # Reset array 'b1' to zeros
b2 = [[0] * 20 for _ in range(20)] # Reset array 'b2' to zeros
# Perform calculations for 'b1' and 'b2'
for i in range(n):
if P[i] == Q[i]:
b1[a[ord(P[i]) - ord('a')]] += 1
else:
b1[a[ord(P[i]) - ord('a')]] += 1
b1[a[ord(Q[i]) - ord('a')]] += 1
b2[a[ord(P[i]) - ord('a')]][a[ord(Q[i]) - ord('a')]] -= 1
b2[a[ord(Q[i]) - ord('a')]][a[ord(P[i]) - ord('a')]] -= 1
m = a[25] + 1 # Determine the number of distinct characters
ans = m # Set 'ans' as the maximum possible value, worst case
o = [0] * (1 << m) # Create a list to store intermediate calculations
s = [0] * (1 << m) # Create a list to store intermediate calculations
# Perform calculations using bitwise operations
for i in range(1, 1 << m):
j = 0
k = i & -i
# Find the rightmost bit that is set to 1
while not (k >> j) & 1:
j += 1
# Update intermediate calculations for 'o' and 's'
o[i] = o[i >> 1] + (i & 1)
s[i] = s[i ^ k] + b1[j]
# Perform additional calculations for 's' based on 'b2'
for k in range(j + 1, m):
if (i >> k) & 1:
s[i] += b2[j][k]
# Check if 's' is equal to 'n' and update 'ans' accordingly
if s[i] == n:
ans = min(ans, o[i])
return ans
Analysis
Code: 14:34:51 UTC,
py,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
# compute
# Update the character counts in array 'a' based on the characters in strings 'P' and 'Q'
for i in range(n):
a[ord(P[i]) - ord('a')] = a[ord(Q[i]) - ord('a')] = 1
# Calculate cumulative sums in array 'a'
for i in range(1, 26):
a[i] += a[i-1]
b1 = [0] * 20 # Reset array 'b1' to zeros
b2 = [[0] * 20 for _ in range(20)] # Reset array 'b2' to zeros
# Perform calculations for 'b1' and 'b2'
for i in range(n):
if P[i] == Q[i]:
b1[a[ord(P[i]) - ord('a')]] += 1
else:
b1[a[ord(P[i]) - ord('a')]] += 1
b1[a[ord(Q[i]) - ord('a')]] += 1
b2[a[ord(P[i]) - ord('a')]][a[ord(Q[i]) - ord('a')]] -= 1
b2[a[ord(Q[i]) - ord('a')]][a[ord(P[i]) - ord('a')]] -= 1
m = a[25] + 1 # Determine the number of distinct characters
ans = m # Set 'ans' as the maximum possible value, worst case
o = [0] * (1 << m) # Create a list to store intermediate calculations
s = [0] * (1 << m) # Create a list to store intermediate calculations
# Perform calculations using bitwise operations
for i in range(1, 1 << m):
j = 0
k = i & -i
# Find the rightmost bit that is set to 1
while not (k >> j) & 1:
j += 1
# Update intermediate calculations for 'o' and 's'
o[i] = o[i >> 1] + (i & 1)
s[i] = s[i ^ k] + b1[j]
# Perform additional calculations for 's' based on 'b2'
for k in range(j + 1, m):
if (i >> k) & 1:
s[i] += b2[j][k]
# Check if 's' is equal to 'n' and update 'ans' accordingly
if s[i] == n:
ans = min(ans, o[i])
return ans
Analysis
Code: 14:34:56 UTC,
py,
final,
score:
100
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(P, Q):
# setup
a = [0] * 26 # Initialize an array to keep track of character counts
b1 = [0] * 20 # Initialize an array to store intermediate calculations
b2 = [[0] * 20 for _ in range(20)] # Initialize a 2D array to store additional calculations
n = len(P) # Determine the size of the input strings
# compute
# Update the character counts in array 'a' based on the characters in strings 'P' and 'Q'
for i in range(n):
a[ord(P[i]) - ord('a')] = a[ord(Q[i]) - ord('a')] = 1
# Calculate cumulative sums in array 'a'
for i in range(1, 26):
a[i] += a[i-1]
b1 = [0] * 20 # Reset array 'b1' to zeros
b2 = [[0] * 20 for _ in range(20)] # Reset array 'b2' to zeros
# Perform calculations for 'b1' and 'b2'
for i in range(n):
if P[i] == Q[i]:
b1[a[ord(P[i]) - ord('a')]] += 1
else:
b1[a[ord(P[i]) - ord('a')]] += 1
b1[a[ord(Q[i]) - ord('a')]] += 1
b2[a[ord(P[i]) - ord('a')]][a[ord(Q[i]) - ord('a')]] -= 1
b2[a[ord(Q[i]) - ord('a')]][a[ord(P[i]) - ord('a')]] -= 1
m = a[25] + 1 # Determine the number of distinct characters
ans = m # Set 'ans' as the maximum possible value, worst case
o = [0] * (1 << m) # Create a list to store intermediate calculations
s = [0] * (1 << m) # Create a list to store intermediate calculations
# Perform calculations using bitwise operations
for i in range(1, 1 << m):
j = 0
k = i & -i
# Find the rightmost bit that is set to 1
while not (k >> j) & 1:
j += 1
# Update intermediate calculations for 'o' and 's'
o[i] = o[i >> 1] + (i & 1)
s[i] = s[i ^ k] + b1[j]
# Perform additional calculations for 's' based on 'b2'
for k in range(j + 1, m):
if (i >> k) & 1:
s[i] += b2[j][k]
# Check if 's' is equal to 'n' and update 'ans' accordingly
if s[i] == n:
ans = min(ans, o[i])
return ans
Analysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(2**A * A**2 + N) or O(2**A * A**2 + N * A**2)
Time complexity parameters:
A - size of the alphabet
A - size of the alphabet
expand all
Correctness tests
1.
0.012 s
OK
2.
0.012 s
OK
3.
0.012 s
OK
4.
0.012 s
OK
5.
0.012 s
OK
6.
0.012 s
OK
7.
0.012 s
OK
1.
0.012 s
OK
2.
0.012 s
OK
3.
0.012 s
OK
4.
0.012 s
OK
5.
0.012 s
OK
6.
0.012 s
OK
7.
0.012 s
OK
8.
0.012 s
OK
9.
0.012 s
OK
10.
0.012 s
OK
1.
0.012 s
OK
2.
0.012 s
OK
3.
0.012 s
OK
4.
0.012 s
OK
5.
0.012 s
OK
6.
0.012 s
OK
7.
0.012 s
OK
small_freq
Small tests where some letters have big but similar frequencies, N <= 17, A <= 12.
Small tests where some letters have big but similar frequencies, N <= 17, A <= 12.
✔
OK
1.
0.016 s
OK
2.
0.012 s
OK
3.
0.016 s
OK
4.
0.012 s
OK
5.
0.036 s
OK
6.
0.016 s
OK
7.
0.012 s
OK
8.
0.020 s
OK
expand all
Correctness/performance tests
1.
0.012 s
OK
2.
0.012 s
OK
3.
0.012 s
OK
1.
0.352 s
OK
2.
0.352 s
OK
3.
0.352 s
OK
4.
0.352 s
OK
5.
0.172 s
OK
6.
0.172 s
OK
1.
1.496 s
OK
2.
1.492 s
OK
3.
0.348 s
OK
4.
0.724 s
OK
5.
0.720 s
OK
expand all
Performance tests
1.
0.172 s
OK
2.
0.172 s
OK
3.
0.728 s
OK
1.
0.448 s
OK
2.
0.616 s
OK
3.
0.620 s
OK
1.
1.732 s
OK
2.
0.616 s
OK
3.
2.984 s
OK
4.
3.144 s
OK