Orig Description
Score : 1100 points
Problem StatementThere are N strings of lowercase alphabet only. The i-th string is S_i. Every string is unique.
Provide answers for the Q queries below. The i-th query has the following format:
Query: An integer k_i and a string p_{i,1}p_{i,2}...p_{i,26} that results from permuting {a,b,...,z} are given. Output the sequence of the string S_{k_i} among the N strings in lexicographical order when the literal sequence is p_{i,1}
Extracted Specification
An integer N (1 ≤ N ≤ 100000), representing some quantity or size.
A list of N unique strings, each consisting of lowercase alphabet characters.
An integer Q (1 ≤ Q ≤ 100000), representing the number of queries.
Q queries, where each query consists of:
- An integer k (1 ≤ k ≤ N)
- A permutation of the lowercase alphabet (a string of length 26)
### Example Input:
```
5
aa
abbaa
abbba
aaab
aaaaaba
5
1 abcdefghijklmnopqrstuvwxyz
2 bacdefghijklmnopqrstuvwxyz
3 abcdefghijklmnopqrstuvwxyz
4 bacdefghijklmnopqrstuvwxyz
5 abcdefghijklmnopqrstuvwxyz
```
### Function Signature:
Write a function f(N, strings, Q, queries) that takes in the input.
def f(N: int, strings: List[str], Q: int, queries: List[Tuple[int, str]]):
'''
N: an integer
strings: a list of strings
Q: an integer
queries: a list of tuples where each tuple consists of an integer and a string
'''
Test Case Generator
Certainly! Here is a test case generator for the provided problem statement:
```python
import random
import string
def generate_random_string(max_length):
length = random.randint(1, max_length)
return ''.join(random.choice(string.ascii_lowercase) for _ in range(length))
def generate_permutation():
return ''.join(random.sample(string.ascii_lowercase, 26))
def tcgen():
max_total_length = 400000
N = random.randint(1, 100000)
strings = []
total_length = 0
for _ in range(N):
if total_length >= max_total_length:
break
s = generate_random_string(min(max_total_length - total_length, 100))
strings.append(s)
total_length += len(s)
N = len(strings) # In case we had to stop early due to total_length constraint
Q = random.randint(1, 100000)
queries = []
for _ in range(Q):
k = random.randint(1, N)
permutation = generate_permutation()
queries.append((k, permutation))
return N, strings, Q, queries
# Example usage:
N, strings, Q, queries = tcgen()
print(N)
for s in strings:
print(s)
print(Q)
for k, p in queries:
print(k, p)
```
This Python script generates random test cases for the problem described. The `generate_random_string` function creates a random string with a length between 1 and `max_length`. The `generate_permutation` function generates a random permutation of the 26 lowercase English letters.
The `tcgen` function generates the number of strings `N` and the list of unique strings, ensuring that the total length of all strings does not exceed 400,000 characters. It then generates `Q` queries, each consisting of a random integer `k` and a random permutation of the alphabet.
The `Example usage` section demonstrates how to use the `tcgen` function and print the generated test case.
Extract Arguments
def extract_arguments(fh):
N = int(fh.readline().strip())
S = [fh.readline().strip() for _ in range(N)]
Q = int(fh.readline().strip())
queries = []
for _ in range(Q):
line = fh.readline().strip().split()
k_i = int(line[0])
p_i = line[1]
queries.append((k_i, p_i))
return N, S, Q, queries