text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer — the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 → 111001 → 11101 → 1111 → ∅.
In the second example the optimal sequence of erasings is: 10101 → 1001 → 11 → ∅.
Submitted Solution:
```
def rlist(): return list(map(int, input().split()))
def rdi(): return int(input())
def f(q, p):
if q == p:
if string[q] == '0':
return [(1, 0), (0, dp[0])]
else:
return [(0, dp[0]), (1, 0)]
ll = q
rr = p
while ll < rr and (string[ll] == string[q] or string[rr] == string[p]):
if string[ll] == string[q]:
ll += 1
if string[rr] == string[p]:
rr -= 1
if ll > rr and string[q] == string[p]:
if string[q] == '0':
return [(q - p + 1, 0), (0, dp[q - p])]
else:
return [(0, dp[q - p]), (q - p + 1, 0)]
elif ll > rr:
if string[q] == 0:
return [(ll - q, dp[p - rr - 1]), (p - rr, dp[ll - q - 1])]
else:
return [(p - rr, dp[ll - q - 1]), (ll - q, dp[p - rr - 1])]
else:
dp_ans = f(ll, rr)
if string[q] == string[p] == '0':
return [(ll - q + p - rr + dp_ans[0][0], dp_ans[0][1]), (dp_ans[1][0], dp_ans[1][1] + dp[ll - q - 1] + dp[p - rr - 1])]
elif string[q] == string[p] == '1':
return [(dp_ans[0][0], dp_ans[0][1] + dp[ll - q - 1] + dp[p - rr - 1]), (ll - q + p - rr + dp_ans[1][0], dp_ans[1][1])]
elif string[q] == '0':
return [(ll - q + dp_ans[0][0], dp_ans[0][1] + dp[p - rr - 1]), (p - rr + dp_ans[1][0], dp_ans[1][1] + dp[ll - q - 1])]
else:
return [(p - rr + dp_ans[0][0], dp_ans[0][1] + dp[ll - q - 1]), (ll - q + dp_ans[1][0], dp_ans[1][1] + dp[p - rr - 1])]
n = rdi()
string = input()
line = rlist()
dp = [0] * (n + 1)
for i in range(n):
for j in range(0, i + 1):
dp[i] = max(dp[i], dp[i - j - 1] + line[j])
ans = f(0, n - 1)
print(max(dp[ans[0][0] - 1] + ans[0][1], dp[ans[1][0] - 1] + ans[1][1]))
```
No
| 2,500 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer — the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 → 111001 → 11101 → 1111 → ∅.
In the second example the optimal sequence of erasings is: 10101 → 1001 → 11 → ∅.
Submitted Solution:
```
n = int(input())
s = input()
ai = list(map(int,input().split()))
ar = [ai[i] for i in range(n)]
for i in range(1,n):
num = 0
for j in range(1,(i+1) // 2 + 1):
num += ar[j-1] + ar[i-j]
ar[i] = max(num,ar[i])
ar2 = []
num = 1
for i in range(1,n):
if s[i] == s[i-1]:
num += 1
else:
ar2 += [num]
num = 1
ar2 += [num]
n2 = len(ar2)
ar = [0] + ar
ar3 = [[-1] * (n2 + 5) for i in range(n2+5)]
ar4 = [[[-1] * (102) for i in range(102)] for i in range(102)]
num5 = 0
def fun(i, n3, num3):
if i > n3 - 1:
return 0
ans = 0
num = num3
num2 = 0
for j in range(i,n3,2):
num += ar2[j]
if ar3[j+1][n3] == -1:
ar3[j+1][n3] = fun(j+1,n3,0)
ans = max(ans, ar3[j+1][n3] + ar[num] + num2)
for z in range(j+3,n3,2):
if ar3[j+1][z+1] == -1:
ar3[j+1][z+1] = fun(j+1,z+1,0)
if ar4[z+1][n3][num] == -1:
ar4[z+1][n3][num] = fun(z+1,n3,num)
ans = max(ans, ar3[j+1][z+1] + ar4[z+1][n3][num] + num2)
if j < n3 - 1:
num2 += ar[ar2[j+1]]
return ans
print(fun(0, n2, 0))
```
No
| 2,501 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Vasya has a string s of length n consisting only of digits 0 and 1. Also he has an array a of length n.
Vasya performs the following operation until the string becomes empty: choose some consecutive substring of equal characters, erase it from the string and glue together the remaining parts (any of them can be empty). For example, if he erases substring 111 from string 111110 he will get the string 110. Vasya gets a_x points for erasing substring of length x.
Vasya wants to maximize his total points, so help him with this!
Input
The first line contains one integer n (1 ≤ n ≤ 100) — the length of string s.
The second line contains string s, consisting only of digits 0 and 1.
The third line contains n integers a_1, a_2, ... a_n (1 ≤ a_i ≤ 10^9), where a_i is the number of points for erasing the substring of length i.
Output
Print one integer — the maximum total points Vasya can get.
Examples
Input
7
1101001
3 4 9 100 1 2 3
Output
109
Input
5
10101
3 10 15 15 15
Output
23
Note
In the first example the optimal sequence of erasings is: 1101001 → 111001 → 11101 → 1111 → ∅.
In the second example the optimal sequence of erasings is: 10101 → 1001 → 11 → ∅.
Submitted Solution:
```
# I'm ashamed for trying this
import time
import sys
start = time.perf_counter()
n = int(input())
st = input() + '$'
A = [int(x) for x in input().split()]
DP = {}
DP[0] = 0
for s in range(1,n+1):
DP[s] = max(DP[i]+A[s-i-1] for i in range(s))
lc = None
count = 0
L = []
for c in st:
if c != lc:
if lc:
L.append(count)
count = 0
count += 1
lc = c
best = 0
def f(state,score=0):
global best
ones = sum(state[::2])
zeros = sum(state[1::2])
if score + DP[ones] + DP[zeros] <= best:
if time.perf_counter() - start > 1.75:
print(best)
sys.exit()
#print('abort')
return
if not state:
if best < score:
best = score
#print(score)
return
for i in range(len(state)):
if i == 0:
nstate = state[1:]
elif i == len(state)-1:
nstate = state[:-1]
else:
nstate = state[:i-1] + [state[i-1]+state[i+1]] + state[i+2:]
f(nstate, score + DP[state[i]])
f(L)
print(best)
```
No
| 2,502 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this task, Nastya asked us to write a formal statement.
An array a of length n and an array k of length n-1 are given. Two types of queries should be processed:
* increase a_i by x. Then if a_{i+1} < a_i + k_i, a_{i+1} becomes exactly a_i + k_i; again, if a_{i+2} < a_{i+1} + k_{i+1}, a_{i+2} becomes exactly a_{i+1} + k_{i+1}, and so far for a_{i+3}, ..., a_n;
* print the sum of the contiguous subarray from the l-th element to the r-th element of the array a.
It's guaranteed that initially a_i + k_i ≤ a_{i+1} for all 1 ≤ i ≤ n-1.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^{5}) — the number of elements in the array a.
The second line contains n integers a_1, a_2, …, a_n (-10^{9} ≤ a_i ≤ 10^{9}) — the elements of the array a.
The third line contains n-1 integers k_1, k_2, …, k_{n-1} (-10^{6} ≤ k_i ≤ 10^{6}) — the elements of the array k.
The fourth line contains a single integer q (1 ≤ q ≤ 10^{5}) — the number of queries.
Each of the following q lines contains a query of one of two types:
* if the query has the first type, the corresponding line contains the character '+' (without quotes), and then there are two integers i and x (1 ≤ i ≤ n, 0 ≤ x ≤ 10^{6}), it means that integer x is added to the i-th element of the array a as described in the statement.
* if the query has the second type, the corresponding line contains the character 's' (without quotes) and then there are two integers l and r (1 ≤ l ≤ r ≤ n).
Output
For each query of the second type print a single integer in a new line — the sum of the corresponding subarray.
Examples
Input
3
1 2 3
1 -1
5
s 2 3
+ 1 2
s 1 2
+ 3 1
s 2 3
Output
5
7
8
Input
3
3 6 7
3 1
3
+ 1 3
+ 2 4
s 1 3
Output
33
Note
In the first example:
* after the first change a = [3, 4, 3];
* after the second change a = [3, 4, 4].
In the second example:
* after the first change a = [6, 9, 10];
* after the second change a = [6, 13, 14].
Submitted Solution:
```
n = int(input())
a = []
k = []
a = list(map(int, input().split()))
k = list(map(int, input().split()))
q = int(input())
for i in range(q):
qry = list(input().split())
if qry[0] == 's':
l = int(qry[1])
r = int(qry[2])
#if r < n and l > 1:
print(sum(a[l - 1:r]))
elif qry[0] == '+':
i = int(qry[1]) - 1
x = int(qry[2])
a[i] += x
if (i + 1) < n and a[i + 1] < a[i] + k[i]:
a[i + 1] = a[i] + k[i]
```
No
| 2,503 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this task, Nastya asked us to write a formal statement.
An array a of length n and an array k of length n-1 are given. Two types of queries should be processed:
* increase a_i by x. Then if a_{i+1} < a_i + k_i, a_{i+1} becomes exactly a_i + k_i; again, if a_{i+2} < a_{i+1} + k_{i+1}, a_{i+2} becomes exactly a_{i+1} + k_{i+1}, and so far for a_{i+3}, ..., a_n;
* print the sum of the contiguous subarray from the l-th element to the r-th element of the array a.
It's guaranteed that initially a_i + k_i ≤ a_{i+1} for all 1 ≤ i ≤ n-1.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^{5}) — the number of elements in the array a.
The second line contains n integers a_1, a_2, …, a_n (-10^{9} ≤ a_i ≤ 10^{9}) — the elements of the array a.
The third line contains n-1 integers k_1, k_2, …, k_{n-1} (-10^{6} ≤ k_i ≤ 10^{6}) — the elements of the array k.
The fourth line contains a single integer q (1 ≤ q ≤ 10^{5}) — the number of queries.
Each of the following q lines contains a query of one of two types:
* if the query has the first type, the corresponding line contains the character '+' (without quotes), and then there are two integers i and x (1 ≤ i ≤ n, 0 ≤ x ≤ 10^{6}), it means that integer x is added to the i-th element of the array a as described in the statement.
* if the query has the second type, the corresponding line contains the character 's' (without quotes) and then there are two integers l and r (1 ≤ l ≤ r ≤ n).
Output
For each query of the second type print a single integer in a new line — the sum of the corresponding subarray.
Examples
Input
3
1 2 3
1 -1
5
s 2 3
+ 1 2
s 1 2
+ 3 1
s 2 3
Output
5
7
8
Input
3
3 6 7
3 1
3
+ 1 3
+ 2 4
s 1 3
Output
33
Note
In the first example:
* after the first change a = [3, 4, 3];
* after the second change a = [3, 4, 4].
In the second example:
* after the first change a = [6, 9, 10];
* after the second change a = [6, 13, 14].
Submitted Solution:
```
import sys
n = int(sys.stdin.readline())
a = sys.stdin.readline().strip().split()
a = [int(x) for x in a]
k = sys.stdin.readline().strip().split()
k = [int(x) for x in k]
cache = {}
q = int(sys.stdin.readline())
st = 1
for i in range(q):
inp = sys.stdin.readline().split()
if inp[0]=='s':
s = 0
l = int(inp[1])
r = int(inp[2])
key = str(l)+'-'+str(r)
if r<st:
try:
print(cache[key])
except:
for pos in range(l-1,r):
s += a[pos]
cache[key] = s
print(cache[key])
else:
for pos in range(l-1,r):
s += a[pos]
cache[key] = s
print(cache[key])
else:
st = int(inp[1])
x = int(inp[2])
a[st-1]+=x
for pos in range(st,n):
tmp = a[pos-1]+k[pos-1]
#break
#print(tmp)
if a[pos]<tmp:
a[pos]=tmp#tmp#(a[pos-1]+k[pos-1])
#print(a)
'''
n = int(sys.stdin.readline())
inp = sys.stdin.readline().strip().split()
a = [int(x) for x in inp]
ans = -(10**9)
s = 0
for l in range(n-1):
l+=1
s = 0
for i in range(l-1,n-1):
print(s)
s = s+(abs(a[i]-a[i+1])*(-1)**(i-l))
if s>ans:
ans = s
print(ans)
'''
```
No
| 2,504 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this task, Nastya asked us to write a formal statement.
An array a of length n and an array k of length n-1 are given. Two types of queries should be processed:
* increase a_i by x. Then if a_{i+1} < a_i + k_i, a_{i+1} becomes exactly a_i + k_i; again, if a_{i+2} < a_{i+1} + k_{i+1}, a_{i+2} becomes exactly a_{i+1} + k_{i+1}, and so far for a_{i+3}, ..., a_n;
* print the sum of the contiguous subarray from the l-th element to the r-th element of the array a.
It's guaranteed that initially a_i + k_i ≤ a_{i+1} for all 1 ≤ i ≤ n-1.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^{5}) — the number of elements in the array a.
The second line contains n integers a_1, a_2, …, a_n (-10^{9} ≤ a_i ≤ 10^{9}) — the elements of the array a.
The third line contains n-1 integers k_1, k_2, …, k_{n-1} (-10^{6} ≤ k_i ≤ 10^{6}) — the elements of the array k.
The fourth line contains a single integer q (1 ≤ q ≤ 10^{5}) — the number of queries.
Each of the following q lines contains a query of one of two types:
* if the query has the first type, the corresponding line contains the character '+' (without quotes), and then there are two integers i and x (1 ≤ i ≤ n, 0 ≤ x ≤ 10^{6}), it means that integer x is added to the i-th element of the array a as described in the statement.
* if the query has the second type, the corresponding line contains the character 's' (without quotes) and then there are two integers l and r (1 ≤ l ≤ r ≤ n).
Output
For each query of the second type print a single integer in a new line — the sum of the corresponding subarray.
Examples
Input
3
1 2 3
1 -1
5
s 2 3
+ 1 2
s 1 2
+ 3 1
s 2 3
Output
5
7
8
Input
3
3 6 7
3 1
3
+ 1 3
+ 2 4
s 1 3
Output
33
Note
In the first example:
* after the first change a = [3, 4, 3];
* after the second change a = [3, 4, 4].
In the second example:
* after the first change a = [6, 9, 10];
* after the second change a = [6, 13, 14].
Submitted Solution:
```
import sys
n = int(sys.stdin.readline())
a = sys.stdin.readline().strip().split()
a = [int(x) for x in a]
k = sys.stdin.readline().strip().split()
k = [int(x) for x in k]
cache = {}
q = int(sys.stdin.readline())
st = 1
for i in range(q):
inp = sys.stdin.readline().split()
if inp[0]=='s':
s = 0
l = int(inp[1])
r = int(inp[2])
key = str(l)+'-'+str(r)
if r>st:
try:
print(cache[key])
except:
for pos in range(l-1,r):
s += a[pos]
cache[key] = s
print(cache[key])
else:
for pos in range(l-1,r):
s += a[pos]
cache[key] = s
print(cache[key])
else:
st = int(inp[1])
x = int(inp[2])
a[st-1]+=x
for pos in range(st,n):
tmp = a[pos-1]+k[pos-1]
#break
#print(tmp)
if a[pos]<tmp:
a[pos]=tmp#tmp#(a[pos-1]+k[pos-1])
#print(a)
'''
n = int(sys.stdin.readline())
inp = sys.stdin.readline().strip().split()
a = [int(x) for x in inp]
ans = -(10**9)
s = 0
for l in range(n-1):
l+=1
s = 0
for i in range(l-1,n-1):
print(s)
s = s+(abs(a[i]-a[i+1])*(-1)**(i-l))
if s>ans:
ans = s
print(ans)
'''
```
No
| 2,505 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In this task, Nastya asked us to write a formal statement.
An array a of length n and an array k of length n-1 are given. Two types of queries should be processed:
* increase a_i by x. Then if a_{i+1} < a_i + k_i, a_{i+1} becomes exactly a_i + k_i; again, if a_{i+2} < a_{i+1} + k_{i+1}, a_{i+2} becomes exactly a_{i+1} + k_{i+1}, and so far for a_{i+3}, ..., a_n;
* print the sum of the contiguous subarray from the l-th element to the r-th element of the array a.
It's guaranteed that initially a_i + k_i ≤ a_{i+1} for all 1 ≤ i ≤ n-1.
Input
The first line contains a single integer n (2 ≤ n ≤ 10^{5}) — the number of elements in the array a.
The second line contains n integers a_1, a_2, …, a_n (-10^{9} ≤ a_i ≤ 10^{9}) — the elements of the array a.
The third line contains n-1 integers k_1, k_2, …, k_{n-1} (-10^{6} ≤ k_i ≤ 10^{6}) — the elements of the array k.
The fourth line contains a single integer q (1 ≤ q ≤ 10^{5}) — the number of queries.
Each of the following q lines contains a query of one of two types:
* if the query has the first type, the corresponding line contains the character '+' (without quotes), and then there are two integers i and x (1 ≤ i ≤ n, 0 ≤ x ≤ 10^{6}), it means that integer x is added to the i-th element of the array a as described in the statement.
* if the query has the second type, the corresponding line contains the character 's' (without quotes) and then there are two integers l and r (1 ≤ l ≤ r ≤ n).
Output
For each query of the second type print a single integer in a new line — the sum of the corresponding subarray.
Examples
Input
3
1 2 3
1 -1
5
s 2 3
+ 1 2
s 1 2
+ 3 1
s 2 3
Output
5
7
8
Input
3
3 6 7
3 1
3
+ 1 3
+ 2 4
s 1 3
Output
33
Note
In the first example:
* after the first change a = [3, 4, 3];
* after the second change a = [3, 4, 4].
In the second example:
* after the first change a = [6, 9, 10];
* after the second change a = [6, 13, 14].
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
k=list(map(int,input().split()))
su=[0]*n
for i in range(n):
if(i>=1):
su[i]=su[i-1]+l[i-1]
try:
for _ in range(int(input())):
a,b,c=input().split()
b=int(b)
c=int(c)
if(a=='+'):
flag2=0
l[b-1]+=c
temp=b
while(temp<n):
su[temp]+=c
temp+=1
for i in range(b,n):
if(l[i]<l[i-1]+k[i-1]):
if(i<n-1):
su[i+1]+=l[i-1]+k[i-1]-l[i]
l[i]=l[i-1]+k[i-1]
else:
print(su[c-1]+l[c-1]-su[b-1])
except:
temp2=0
```
No
| 2,506 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Tags: games, greedy, implementation
Correct Solution:
```
n = int(input())
l = list(map(int,list(input())))
diff = n-11
if(l[0:diff+1].count(8)>diff//2):
print("YES")
else:
print("NO")
```
| 2,507 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Tags: games, greedy, implementation
Correct Solution:
```
n = int(input().strip())
s = input().strip()
n = len(s)
eights = s[:-10].count('8')
if eights == 0:
print('NO')
else:
extras = n-10-eights
if extras > eights:
print('NO')
else:
print('YES')
```
| 2,508 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Tags: games, greedy, implementation
Correct Solution:
```
n = int(input())
s = input()
r = n - 11
if s[:r+1].count('8') > (r+1)//2:
print('YES')
else:
print('NO')
```
| 2,509 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Tags: games, greedy, implementation
Correct Solution:
```
n = int(input())
s = input()
x = (n-11)//2
a = s.count('8')
if a<=x:
print('NO')
else:
res=[]
for i,y in enumerate(s):
if y=='8':
res.append(i)
e=0
for i in range(x+1):
if res[i]-e>x:
print('NO')
from sys import exit
exit()
e+=1
print('YES')
```
| 2,510 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Tags: games, greedy, implementation
Correct Solution:
```
n=int(input())
num=input()
if num[0:-10].count('8')<=(n-11)//2:
print('NO')
else:
print('YES')
```
| 2,511 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Tags: games, greedy, implementation
Correct Solution:
```
n = int(input())
string = str(input())
count = 0
first = 0
for i in range(n-10):
if string[i] == '8':
count += 1
if count > (n-11)/2:
print("YES")
else:
print("NO")
```
| 2,512 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Tags: games, greedy, implementation
Correct Solution:
```
n=int(input())
s=input()
a=0
for i in range(len(s)-10) :
if s[i]=="8" :
a+=1
if a>(n-10-a) :
print("YES")
else :
print("NO")
```
| 2,513 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Tags: games, greedy, implementation
Correct Solution:
```
import sys
from math import ceil
input = sys.stdin.readline
n = int(input())
s = list(input().strip())
deleteEights = (n-11)//2
deleteOthers = (n-11)//2
for i in range(n):
if deleteEights > 0:
if s[i] == '8':
s[i] = -1
deleteEights -= 1
continue
if deleteOthers > 0:
if s[i] != '8':
s[i] = -1
deleteOthers -= 1
continue
for i in range(n):
if s[i] != -1:
if s[i] == '8':
print("YES")
else:
print("NO")
break
```
| 2,514 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
n = int(input())
s = input()
t = n - 11
f = t // 2
ss = 0
for i in s:
if i == '8':
ss += 1
if ss <= f:
print('NO')
else:
for i in range(n):
if s[i] == '8':
f = f - 1
if f == -1:
p = i
break
if i <= t:
print('YES')
else:
print('NO')
```
Yes
| 2,515 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
n = int(input())
s = input()
cnt = 0
for i in range(n - 10):
if s[i] == '8':
cnt += 1
if cnt >= ((n - 9) // 2):
print('YES')
else:
print('NO')
```
Yes
| 2,516 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
n=int(input())
s=input()
# for i in range(n-10) :
# if s['i']!='8'
# if s[:n-10].count('8')%2==0:
# print(s[:n-10])
# print("YES")
# else: print("NO")
c=n-10-(s[:n-10].count('8'))
if c<s[:n-10].count('8'):
print("YES")
else: print("NO")
```
Yes
| 2,517 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
N = int(input())
S = input()
turns = (N - 11) // 2
cnt = 0
for i in range(N - 10):
if S[i] == '8':
cnt += 1
if cnt >= turns + 1:
print("YES")
else:
print("NO")
```
Yes
| 2,518 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
'''
___ ___ ___ ___ ___ ___
/\__\ /\ \ _____ /\ \ /\ \ /\ \ /\__\
/:/ _/_ \:\ \ /::\ \ \:\ \ ___ /::\ \ |::\ \ ___ /:/ _/_
/:/ /\ \ \:\ \ /:/\:\ \ \:\ \ /\__\ /:/\:\__\ |:|:\ \ /\__\ /:/ /\ \
/:/ /::\ \ ___ \:\ \ /:/ \:\__\ ___ /::\ \ /:/__/ /:/ /:/ / __|:|\:\ \ /:/ / /:/ /::\ \
/:/_/:/\:\__\ /\ \ \:\__\ /:/__/ \:|__| /\ /:/\:\__\ /::\ \ /:/_/:/__/___ /::::|_\:\__\ /:/__/ /:/_/:/\:\__\
\:\/:/ /:/ / \:\ \ /:/ / \:\ \ /:/ / \:\/:/ \/__/ \/\:\ \__ \:\/:::::/ / \:\~~\ \/__/ /::\ \ \:\/:/ /:/ /
\::/ /:/ / \:\ /:/ / \:\ /:/ / \::/__/ ~~\:\/\__\ \::/~~/~~~~ \:\ \ /:/\:\ \ \::/ /:/ /
\/_/:/ / \:\/:/ / \:\/:/ / \:\ \ \::/ / \:\~~\ \:\ \ \/__\:\ \ \/_/:/ /
/:/ / \::/ / \::/ / \:\__\ /:/ / \:\__\ \:\__\ \:\__\ /:/ /
\/__/ \/__/ \/__/ \/__/ \/__/ \/__/ \/__/ \/__/ \/__/
'''
"""
░░██▄░░░░░░░░░░░▄██
░▄▀░█▄░░░░░░░░▄█░░█░
░█░▄░█▄░░░░░░▄█░▄░█░
░█░██████████████▄█░
░█████▀▀████▀▀█████░
▄█▀█▀░░░████░░░▀▀███
██░░▀████▀▀████▀░░██
██░░░░█▀░░░░▀█░░░░██
███▄░░░░░░░░░░░░▄███
░▀███▄░░████░░▄███▀░
░░░▀██▄░▀██▀░▄██▀░░░
░░░░░░▀██████▀░░░░░░
░░░░░░░░░░░░░░░░░░░░
"""
import sys
import math
import collections
import operator as op
from collections import deque
from math import gcd, inf, sqrt, pi, cos, sin, ceil, log2
from bisect import bisect_right, bisect_left
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2**20)
def ncr(n, r):
r = min(r, n - r)
numer = reduce(op.mul, range(n, n - r, -1), 1)
denom = reduce(op.mul, range(1, r + 1), 1)
return numer // denom # or / in Python 2
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i:
i += 1
else:
n //= i
factors.append(i)
if n > 1:
factors.append(n)
return (list(factors))
def sumDigits(no):
return 0 if no == 0 else int(no % 10) + sumDigits(int(no / 10))
MOD = 1000000007
PMOD = 998244353
N = 10**9 + 7
LOGN = 30
T = 1
# T = int(stdin.readline())
for _ in range(T):
# n = list(map(int, stdin.readline().rstrip().split()))
n = int(stdin.readline())
# a = list(map(int, stdin.readline().rstrip().split()))
# l = list(map(int, stdin.readline().rstrip().split()))
a = list(stdin.readline().strip('\n'))
# t = str(stdin.readline().strip('\n'))
# m = int(stdin.readline())
# s = list(map(int, stdin.readline().rstrip().split())
n8 = 0
ne = 0
for i in range(n):
if a[i] == '8':
n8 += 1
li = -1
for i in range(n - 1, -1, -1):
if a[i] == '8':
li = i
break
for i in range(li + 1):
if a[i] != '8':
ne += 1
break
n -= 11
if n8 > n // 2:
if ne <= n // 2 and li + 1 > n:
print('YES')
else:
print('NO')
continue
print('NO')
```
No
| 2,519 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
import sys, collections
n = int(sys.stdin.readline())
arr = list(map(int, sys.stdin.readline().rstrip()))
v = 0
p = 0
for i in range(n):
if v == (n - 11) // 2:
break
if arr[i] != 8:
arr[i] = -1
v += 1
for i in range(n):
if p == (n - 11) // 2:
break
if arr[i] == 8:
arr[i] = -1
p += 1
print('YES' if arr[n - 11] == 8 else 'NO')
```
No
| 2,520 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
def mp():
return map(int, input().split())
n = int(input())
s = [int(i) for i in input()]
if s.count(8) >= n - 11:
print('YES')
else:
print('NO')
```
No
| 2,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A telephone number is a sequence of exactly 11 digits such that its first digit is 8.
Vasya and Petya are playing a game. Initially they have a string s of length n (n is odd) consisting of digits. Vasya makes the first move, then players alternate turns. In one move the player must choose a character and erase it from the current string. For example, if the current string 1121, after the player's move it may be 112, 111 or 121. The game ends when the length of string s becomes 11. If the resulting string is a telephone number, Vasya wins, otherwise Petya wins.
You have to determine if Vasya has a winning strategy (that is, if Vasya can win the game no matter which characters Petya chooses during his moves).
Input
The first line contains one integer n (13 ≤ n < 10^5, n is odd) — the length of string s.
The second line contains the string s (|s| = n) consisting only of decimal digits.
Output
If Vasya has a strategy that guarantees him victory, print YES.
Otherwise print NO.
Examples
Input
13
8380011223344
Output
YES
Input
15
807345619350641
Output
NO
Note
In the first example Vasya needs to erase the second character. Then Petya cannot erase a character from the remaining string 880011223344 so that it does not become a telephone number.
In the second example after Vasya's turn Petya can erase one character character 8. The resulting string can't be a telephone number, because there is no digit 8 at all.
Submitted Solution:
```
n = int(input())
s = input()
if s[0] != '8':
if s[1] != '8': print('NO'); exit()
else: s = s[1:]
while(s[0] == '8'):
if s[1] == '8': s = s[1:]
else: s = s[0] + s[2:]
if len(s) == 11: print('YES'); exit()
s = s[1:]
if len(s) == 11: print('YES'); exit()
print('NO')
```
No
| 2,522 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Tags: implementation
Correct Solution:
```
st=''
for i in range(1,10000):
st+=str(i)
n=int(input())
print(st[n-1])
```
| 2,523 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Tags: implementation
Correct Solution:
```
import sys,math
def read_int():
return int(sys.stdin.readline().strip())
def read_int_list():
return list(map(int,sys.stdin.readline().strip().split()))
def read_string():
return sys.stdin.readline().strip()
def read_string_list(delim=" "):
return sys.stdin.readline().strip().split(delim)
###### Author : Samir Vyas #######
###### Write Code Below #######
k = read_int()
base_digit_number = 1; expo = 0
while k >= base_digit_number:
base_digit_number += 9*(expo+1)*(10**expo)
expo += 1
base_digit_number -= 9*(expo)*(10**(expo-1))
ans_number = (k - base_digit_number)//expo + 10**(expo-1)
ans_digit = str(ans_number)[(k - base_digit_number)%expo]
print(ans_digit)
```
| 2,524 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Tags: implementation
Correct Solution:
```
st="0"
n=int(input(''))
i=0
j=1
while i<n :
st += str(j)
i+=1
j+=1
print(st[n]);
#print(st)
```
| 2,525 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Tags: implementation
Correct Solution:
```
l=int(input())
k=''
for i in range(1,10001):
k=k+str(i)
m=str(k)
print(m[l-1])
```
| 2,526 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Tags: implementation
Correct Solution:
```
st=""
for i in range(1,pow(10,4)+1):
st=st+str(i)
#print(st)
k=int(input())
print(st[k-1])
```
| 2,527 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Tags: implementation
Correct Solution:
```
n = ''
for i in range(1, 100001, 1):
n += str(i)
k = int(input())
print(n[k-1])
```
| 2,528 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Tags: implementation
Correct Solution:
```
def main():
k = int(input())
digit = 1; low=1; high=9; totalDigit=9; lastTotalDigit=0
while (totalDigit < k) :
low *= 10
high = 10*low-1
digit += 1
lastTotalDigit = totalDigit
totalDigit += (high+1-low)*digit
k -= lastTotalDigit
cur = str(low+(k-1) // digit)
print(cur[(k-1)%digit])
main()
```
| 2,529 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Tags: implementation
Correct Solution:
```
n=int(input())
ar=map(str,range(1,10001))
s=''
d=s.join(ar)
print(d[n-1])
```
| 2,530 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
k = int(input())
a=""
i=0
while(True):
a = a + str(i)
i += 1
if len(a) > k:
break
print(a[k])
```
Yes
| 2,531 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
num = input()
num = int(num)
lst = []
i = 1
count = 0
index = -1
while (count<num):
strI = str(i)
strI = list(strI)
for n in range(0,len(strI)):
lst.append(strI[n])
if(i>=1000):
count+=4
elif(i>=100):
count+=3
elif(i>=10):
count+=2
else:
count+=1
i+=1
if count != num:
diff = count - num
index -= diff
ans = (lst[index])
finalAns = ''.join(ans)
print(finalAns)
```
Yes
| 2,532 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
k = int(input())
number = 1
main_number = ''
while len(main_number) + len(str(number)) < k:
main_number += str(number)
number += 1
print(str(number)[k - len(main_number) - 1])
```
Yes
| 2,533 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
n = int(input())
s = ''
k = 1
while len(s)<n:
s+=str(k)
k+=1
print(s[n-1])
```
Yes
| 2,534 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
n=int(input())
x=1
while n>(10**len(str(x))*9):
n-=10**len(str(x))*9
x*=10
while n>len(str(x)):
n-=len(str(x))
x+=1
for i in range(len(str(x))):
if n!=0:
s=str(x)[i]
n-=1
print(s)
```
No
| 2,535 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
import os
k = int(input())
string = ""
i=0
while len(string)<k:
i=i+1
string=string+str(i)
print(string[-1])
```
No
| 2,536 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
import math
k = int(input())
x = 1
s=0
while s < k:
s = s + int(math.log10(x)) + 1
x += 1
print(str(x-1)[s-k-1])
```
No
| 2,537 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Let's write all the positive integer numbers one after another from 1 without any delimiters (i.e. as a single string). It will be the infinite sequence starting with 123456789101112131415161718192021222324252627282930313233343536...
Your task is to print the k-th digit of this sequence.
Input
The first and only line contains integer k (1 ≤ k ≤ 10000) — the position to process (1-based index).
Output
Print the k-th digit of the resulting infinite sequence.
Examples
Input
7
Output
7
Input
21
Output
5
Submitted Solution:
```
k = int(input())
x = []
i=0
flag = True
while flag==True:
x.append(9*(10**i))
i = i+1
if sum(x) >= k : flag = False
p = len(x)
base = sum(x) - x[p-1]
r = k - base
d = -((-r)//p)
dd = r%p
if dd==0: dd=p
number = str(base + d)
digit = number[dd-1]
# print(number)
print(digit)
```
No
| 2,538 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Seryozha conducts a course dedicated to building a map of heights of Stepanovo recreation center. He laid a rectangle grid of size n × m cells on a map (rows of grid are numbered from 1 to n from north to south, and columns are numbered from 1 to m from west to east). After that he measured the average height of each cell above Rybinsk sea level and obtained a matrix of heights of size n × m. The cell (i, j) lies on the intersection of the i-th row and the j-th column and has height h_{i, j}.
Seryozha is going to look at the result of his work in the browser. The screen of Seryozha's laptop can fit a subrectangle of size a × b of matrix of heights (1 ≤ a ≤ n, 1 ≤ b ≤ m). Seryozha tries to decide how the weather can affect the recreation center — for example, if it rains, where all the rainwater will gather. To do so, he is going to find the cell having minimum height among all cells that are shown on the screen of his laptop.
Help Seryozha to calculate the sum of heights of such cells for all possible subrectangles he can see on his screen. In other words, you have to calculate the sum of minimum heights in submatrices of size a × b with top left corners in (i, j) over all 1 ≤ i ≤ n - a + 1 and 1 ≤ j ≤ m - b + 1.
Consider the sequence g_i = (g_{i - 1} ⋅ x + y) mod z. You are given integers g_0, x, y and z. By miraculous coincidence, h_{i, j} = g_{(i - 1) ⋅ m + j - 1} ((i - 1) ⋅ m + j - 1 is the index).
Input
The first line of the input contains four integers n, m, a and b (1 ≤ n, m ≤ 3 000, 1 ≤ a ≤ n, 1 ≤ b ≤ m) — the number of rows and columns in the matrix Seryozha has, and the number of rows and columns that can be shown on the screen of the laptop, respectively.
The second line of the input contains four integers g_0, x, y and z (0 ≤ g_0, x, y < z ≤ 10^9).
Output
Print a single integer — the answer to the problem.
Example
Input
3 4 2 1
1 2 3 59
Output
111
Note
The matrix from the first example:
<image>
Tags: data structures, two pointers
Correct Solution:
```
def slide_min(tl,ql,val):
res=[0]*(tl-ql+1)
q=[0]*tl
s=0
t=0
for i in range(0,tl):
while s<t and val[q[t-1]]>=val[i]:
t-=1
q[t]=i
t+=1
if (i-ql+1)>=0:
res[i-ql+1]=val[q[s]]
if q[s]==(i-ql+1):
s+=1
return res
def slide_min2(tl,ql,val):
res=0
q=[0]*tl
s=0
t=0
for i in range(0,tl):
while s<t and val[q[t-1]]>=val[i]:
t-=1
q[t]=i
t+=1
if (i-ql+1)>=0:
res+=val[q[s]]
if q[s]==(i-ql+1):
s+=1
return res
n,m,a,b=map(int,input().split())
g,x,y,z=map(int,input().split())
if n==3000 and m==3000 and a==4 and b==10:
print(215591588260257)
elif n==3000 and m==3000 and a==10 and b==4:
print(218197599525055)
elif n==3000 and m==3000 and a==1000 and b==1000 and g==794639486:
print(3906368067)
elif n==3000 and m==3000 and a==3000 and b==3000:
print(49)
elif n==2789 and m==2987 and a==1532 and b==1498:
print(635603994)
elif n==2799 and m==2982 and a==1832 and b==1498:
print(156738085)
elif n==2759 and m==2997 and a==1432 and b==1998:
print(33049528)
elif n==3000 and m==3000 and a==1000 and b==50:
print(23035758532)
elif n==3000 and m==3000 and a==1000 and b==30:
print(19914216432)
elif n==3000 and m==3000 and a==1000 and b==1000 and g==200000000:
print(800800200000000)
else:
h=[[0]*m for _ in range(n)]
tmp=g
for i in range(n):
for j in range(m):
h[i][j]=tmp
tmp=(tmp*x+y)%z
for i in range(n):
h[i]=slide_min(m,b,h[i])
ans=0
for i in range(m-b+1):
tmp=[]
for j in range(n):
tmp.append(h[j][i])
ans+=slide_min2(n,a,tmp)
print(ans)
```
| 2,539 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Seryozha conducts a course dedicated to building a map of heights of Stepanovo recreation center. He laid a rectangle grid of size n × m cells on a map (rows of grid are numbered from 1 to n from north to south, and columns are numbered from 1 to m from west to east). After that he measured the average height of each cell above Rybinsk sea level and obtained a matrix of heights of size n × m. The cell (i, j) lies on the intersection of the i-th row and the j-th column and has height h_{i, j}.
Seryozha is going to look at the result of his work in the browser. The screen of Seryozha's laptop can fit a subrectangle of size a × b of matrix of heights (1 ≤ a ≤ n, 1 ≤ b ≤ m). Seryozha tries to decide how the weather can affect the recreation center — for example, if it rains, where all the rainwater will gather. To do so, he is going to find the cell having minimum height among all cells that are shown on the screen of his laptop.
Help Seryozha to calculate the sum of heights of such cells for all possible subrectangles he can see on his screen. In other words, you have to calculate the sum of minimum heights in submatrices of size a × b with top left corners in (i, j) over all 1 ≤ i ≤ n - a + 1 and 1 ≤ j ≤ m - b + 1.
Consider the sequence g_i = (g_{i - 1} ⋅ x + y) mod z. You are given integers g_0, x, y and z. By miraculous coincidence, h_{i, j} = g_{(i - 1) ⋅ m + j - 1} ((i - 1) ⋅ m + j - 1 is the index).
Input
The first line of the input contains four integers n, m, a and b (1 ≤ n, m ≤ 3 000, 1 ≤ a ≤ n, 1 ≤ b ≤ m) — the number of rows and columns in the matrix Seryozha has, and the number of rows and columns that can be shown on the screen of the laptop, respectively.
The second line of the input contains four integers g_0, x, y and z (0 ≤ g_0, x, y < z ≤ 10^9).
Output
Print a single integer — the answer to the problem.
Example
Input
3 4 2 1
1 2 3 59
Output
111
Note
The matrix from the first example:
<image>
Submitted Solution:
```
def mat_mult(A, B, MOD):
n, m, p = len(A), len(A[0]), len(B[0])
assert (len(B) == m)
C = [[0] * p for _ in range(n)]
for i in range(n):
for k in range(m):
Aik = A[i][k]
for j in range(p):
C[i][j] = (C[i][j] + Aik * B[k][j]) % MOD
return C
def ksm(A, n, MOD):
if (n == 0):
E = [[0 for i in range(len(A))] for j in range(len(A))]
for i in range(len(A)):
z[i][i] = 1
return E
if (n == 1):
return A
k = ksm(A, n//2, MOD)
z = mat_mult(k, k, MOD)
if (n&1):
return (mat_mult(z, A, MOD))
else:
return z
n, m, a, b = map(int, input().split())
g, x, y, z = map(int, input().split())
MOD = z
A = [[x,y],[0,1]]
B = [[g],[1]]
AA = ksm(A, m, MOD)
su = 0
l = [g]
for i in range(m-b):
l.append((l[-1]*x+y) % MOD)
su += sum(l)
for i in range(n-a):
l = [(AA[0][0]*i+AA[0][1])%MOD for i in l]
su += sum(l)
print(su)
```
No
| 2,540 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Seryozha conducts a course dedicated to building a map of heights of Stepanovo recreation center. He laid a rectangle grid of size n × m cells on a map (rows of grid are numbered from 1 to n from north to south, and columns are numbered from 1 to m from west to east). After that he measured the average height of each cell above Rybinsk sea level and obtained a matrix of heights of size n × m. The cell (i, j) lies on the intersection of the i-th row and the j-th column and has height h_{i, j}.
Seryozha is going to look at the result of his work in the browser. The screen of Seryozha's laptop can fit a subrectangle of size a × b of matrix of heights (1 ≤ a ≤ n, 1 ≤ b ≤ m). Seryozha tries to decide how the weather can affect the recreation center — for example, if it rains, where all the rainwater will gather. To do so, he is going to find the cell having minimum height among all cells that are shown on the screen of his laptop.
Help Seryozha to calculate the sum of heights of such cells for all possible subrectangles he can see on his screen. In other words, you have to calculate the sum of minimum heights in submatrices of size a × b with top left corners in (i, j) over all 1 ≤ i ≤ n - a + 1 and 1 ≤ j ≤ m - b + 1.
Consider the sequence g_i = (g_{i - 1} ⋅ x + y) mod z. You are given integers g_0, x, y and z. By miraculous coincidence, h_{i, j} = g_{(i - 1) ⋅ m + j - 1} ((i - 1) ⋅ m + j - 1 is the index).
Input
The first line of the input contains four integers n, m, a and b (1 ≤ n, m ≤ 3 000, 1 ≤ a ≤ n, 1 ≤ b ≤ m) — the number of rows and columns in the matrix Seryozha has, and the number of rows and columns that can be shown on the screen of the laptop, respectively.
The second line of the input contains four integers g_0, x, y and z (0 ≤ g_0, x, y < z ≤ 10^9).
Output
Print a single integer — the answer to the problem.
Example
Input
3 4 2 1
1 2 3 59
Output
111
Note
The matrix from the first example:
<image>
Submitted Solution:
```
def mat_mult(A, B, MOD):
n, m, p = len(A), len(A[0]), len(B[0])
assert (len(B) == m)
C = [[0] * p for _ in range(n)]
for i in range(n):
for k in range(m):
Aik = A[i][k]
for j in range(p):
C[i][j] = (C[i][j] + Aik * B[k][j]) % MOD
return C
def ksm(A, n, MOD):
if (n == 0):
E = [[0 for i in range(len(A))] for j in range(len(A))]
for i in range(len(A)):
E[i][i] = 1
return E
if (n == 1):
return A
k = ksm(A, n//2, MOD)
z = mat_mult(k, k, MOD)
if (n&1):
return (mat_mult(z, A, MOD))
else:
return z
n, m, a, b = map(int, input().split())
g, x, y, z = map(int, input().split())
MOD = z
A = [[x,y],[0,1]]
B = [[g],[1]]
AA = ksm(A, m, MOD)
su = 0
l = [[g]]
for i in range(m-1):
l[0].append((l[0][-1]*x+y) % MOD)
for i in range(n-1):
l.append([(AA[0][0]*i+AA[0][1])%MOD for i in l[-1]])
for i in range(n-a+1):
for j in range(m-b+1):
p = []
for k in range(a):
p += l[i][j:j+b]
su += min(p)
print(su)
```
No
| 2,541 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Seryozha conducts a course dedicated to building a map of heights of Stepanovo recreation center. He laid a rectangle grid of size n × m cells on a map (rows of grid are numbered from 1 to n from north to south, and columns are numbered from 1 to m from west to east). After that he measured the average height of each cell above Rybinsk sea level and obtained a matrix of heights of size n × m. The cell (i, j) lies on the intersection of the i-th row and the j-th column and has height h_{i, j}.
Seryozha is going to look at the result of his work in the browser. The screen of Seryozha's laptop can fit a subrectangle of size a × b of matrix of heights (1 ≤ a ≤ n, 1 ≤ b ≤ m). Seryozha tries to decide how the weather can affect the recreation center — for example, if it rains, where all the rainwater will gather. To do so, he is going to find the cell having minimum height among all cells that are shown on the screen of his laptop.
Help Seryozha to calculate the sum of heights of such cells for all possible subrectangles he can see on his screen. In other words, you have to calculate the sum of minimum heights in submatrices of size a × b with top left corners in (i, j) over all 1 ≤ i ≤ n - a + 1 and 1 ≤ j ≤ m - b + 1.
Consider the sequence g_i = (g_{i - 1} ⋅ x + y) mod z. You are given integers g_0, x, y and z. By miraculous coincidence, h_{i, j} = g_{(i - 1) ⋅ m + j - 1} ((i - 1) ⋅ m + j - 1 is the index).
Input
The first line of the input contains four integers n, m, a and b (1 ≤ n, m ≤ 3 000, 1 ≤ a ≤ n, 1 ≤ b ≤ m) — the number of rows and columns in the matrix Seryozha has, and the number of rows and columns that can be shown on the screen of the laptop, respectively.
The second line of the input contains four integers g_0, x, y and z (0 ≤ g_0, x, y < z ≤ 10^9).
Output
Print a single integer — the answer to the problem.
Example
Input
3 4 2 1
1 2 3 59
Output
111
Note
The matrix from the first example:
<image>
Submitted Solution:
```
u = list(map(int,input().split()))
v = list(map(int,input().split()))
n=u[0]
m=u[1]
h=[[0]*m for _ in range(n) ]
k=[[0]*m for _ in range(n) ]
g=[]
a=u[2]
b=u[3]
g.append(v[0])
x=int(v[1])
y=int(v[2])
z=int(v[3])
s=[]
for i in range(m*n-1):
g.append(int(g[i]*x+y)%z)
s.append(int(0))
for i in range(n) :
l=int(1)
r=int(0)
for j in range(m) :
h[i][j]=g[(i)*m+j]
while ( r >= l and h[i][s[r]] >= h[i][j] ): r-=1
r+=1
s[r]=j
while ( s[l] <= j-b ): l+=1
k[i][j]=h[i][s[l]]
print(k[i][j],end=' ')
print(" ")
dem=int(0)
for j in range(m):
if ( j < b-1 ): continue
l=1
r=0
for i in range(n):
#print(s[r],i,k[s[r]][j],k[i][j])
while ( r >= l and k[s[r]][j] >= k[i][j] ): r-=1
r+=1
s[r]=i
while ( s[l] <= i-a ): l+=1
if ( i > a-2 ): dem+=k[s[l]][j]
print(dem)
```
No
| 2,542 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Seryozha conducts a course dedicated to building a map of heights of Stepanovo recreation center. He laid a rectangle grid of size n × m cells on a map (rows of grid are numbered from 1 to n from north to south, and columns are numbered from 1 to m from west to east). After that he measured the average height of each cell above Rybinsk sea level and obtained a matrix of heights of size n × m. The cell (i, j) lies on the intersection of the i-th row and the j-th column and has height h_{i, j}.
Seryozha is going to look at the result of his work in the browser. The screen of Seryozha's laptop can fit a subrectangle of size a × b of matrix of heights (1 ≤ a ≤ n, 1 ≤ b ≤ m). Seryozha tries to decide how the weather can affect the recreation center — for example, if it rains, where all the rainwater will gather. To do so, he is going to find the cell having minimum height among all cells that are shown on the screen of his laptop.
Help Seryozha to calculate the sum of heights of such cells for all possible subrectangles he can see on his screen. In other words, you have to calculate the sum of minimum heights in submatrices of size a × b with top left corners in (i, j) over all 1 ≤ i ≤ n - a + 1 and 1 ≤ j ≤ m - b + 1.
Consider the sequence g_i = (g_{i - 1} ⋅ x + y) mod z. You are given integers g_0, x, y and z. By miraculous coincidence, h_{i, j} = g_{(i - 1) ⋅ m + j - 1} ((i - 1) ⋅ m + j - 1 is the index).
Input
The first line of the input contains four integers n, m, a and b (1 ≤ n, m ≤ 3 000, 1 ≤ a ≤ n, 1 ≤ b ≤ m) — the number of rows and columns in the matrix Seryozha has, and the number of rows and columns that can be shown on the screen of the laptop, respectively.
The second line of the input contains four integers g_0, x, y and z (0 ≤ g_0, x, y < z ≤ 10^9).
Output
Print a single integer — the answer to the problem.
Example
Input
3 4 2 1
1 2 3 59
Output
111
Note
The matrix from the first example:
<image>
Submitted Solution:
```
from sys import getsizeof
class deque:
def __init__(self):
self.items = []
self.l = 0
self.r = -1
def clear(self):
self.l = 0
self.r = -1
self.items.clear()
def nemp(self):
return self.l <= self.r
def add(self, x):
self.items.append(x)
self.r += 1
def pop(self):
self.r -= 1
def popleft(self):
self.l += 1
def left(self):
return self.items[self.l]
def right(self):
return self.items[self.r]
n, m, a, b = map(int, input().split())
g0, x, y, z = map(int, input().split())
h = [[0]*m for _ in range(n)]
h2 = [[0]*m for _ in range(n)]
for i in range(n):
for j in range(m):
h[i][j], g0 = g0, (g0*x+y)%z
deq = deque()
for i in range(n):
deq.clear()
for j in range(m):
while deq.nemp() and j-deq.left()+1 > b: deq.popleft()
while deq.nemp() and h[i][j] <= h[i][deq.right()]: deq.pop()
deq.add(j)
h2[i][j] = h[i][deq.left()]
ans = 0
for j in range(m):
deq.clear()
for i in range(n):
while deq.nemp() and i-deq.left()+1 > a: deq.popleft()
while deq.nemp() and h2[i][j] <= h2[deq.right()][j]: deq.pop()
deq.add(i)
if i>a-2 and j>b-2: ans += h2[deq.left()][j]
print(ans)
#print('size = ', getsizeof(h)+getsizeof(h2)+getsizeof(deq))
'''
1000 1000 100 100
1 2 3 59
'''
```
No
| 2,543 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Tags: math
Correct Solution:
```
n = int(input())
xs = [int(elem) for elem in input().split()]
even = 0
odd = 0
for i in range(n):
if xs[i] % 2 == 1:
odd += 1
else:
even += 1
ans = min(even, odd)
print(ans)
```
| 2,544 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Tags: math
Correct Solution:
```
print([min(sum(a), n - sum(a)) for n, a in [[int(input()), [int(q) % 2 for q in input().split()]]]][0])
```
| 2,545 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Tags: math
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
coev=0
for i in range(n):
if l[i]%2==0:
coev+=1
print(min(coev,n-coev))
```
| 2,546 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Tags: math
Correct Solution:
```
def readInts():
return [int(x) for x in input().split()]
N = int(input())
xs = readInts()
num_odd = 0
num_even = 0
for x in xs:
if x % 2 == 0:
num_even += 1
else:
num_odd += 1
print(min(num_odd, num_even))
```
| 2,547 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Tags: math
Correct Solution:
```
n = int(input())
cordinate = input().split()
odd = 0
even = 0
for i in cordinate:
a = int(i)
if (a%2==1):
odd+=1
else:
even+=1
if (odd<even):
print(odd)
else:
print(even)
```
| 2,548 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Tags: math
Correct Solution:
```
n = int( input())
l = list(map(int, input().split()))
f = 9e9
for i in set(l):
c = 0
for j in l:
c += (j-i)%2
f = min(c,f)
print(f)
```
| 2,549 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Tags: math
Correct Solution:
```
n = int(input())
a = [int(x) for x in input().split()]
noch = 0
for i in a:
noch += i % 2
if noch < n - noch:
print(noch)
else:
print(n - noch)
```
| 2,550 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Tags: math
Correct Solution:
```
n=int(input())
a=[int(x) for x in input().split()]
c=0
for i in a:
if(i%2!=0):
c+=1
print(min(c,n-c))
```
| 2,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Submitted Solution:
```
#!/usr/bin/env python3.7
n = int(input())
vals = [0, 0]
for num in map(int, input().split()):
vals[num % 2] += 1
print(min(vals))
```
Yes
| 2,552 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Submitted Solution:
```
n = int(input())
l = list(map(int,input().split()))
e,o = 0,0
for i in l:
if i%2==0:
e+=1
else:
o+=1
if e>=o:
print(o)
else:
print(e)
```
Yes
| 2,553 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Submitted Solution:
```
n = int(input())
l = list([int(x) for x in input().split()])
o = 0
e = 0
for i in range(n):
if(l[i] % 2 == 0):
e += 1
else:
o += 1
print(min(o, e))
```
Yes
| 2,554 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Submitted Solution:
```
# import sys
# sys.stdin = open("test.in","r")
# sys.stdout = open("test.out","w")
n=int(input())
a=list(map(int,input().split()))
b=min(a)
c=0
for i in range(n):
if abs(a[i]-b)%2!=0:
c+=1
print(min(c,n-c))
```
Yes
| 2,555 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Submitted Solution:
```
#l = [2,2,2,3,3]
n=int(input())
l=list(map(int,input().split()))
c=0
def most_frequent(l):
return max(set(l), key = l.count)
x=most_frequent(l)
#print(x)
for i in l :
if i != x :
#print(i)
if abs(i-x)>=2 :
i=i-2
else :
i=i-1
c+=1
print(c)
```
No
| 2,556 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Submitted Solution:
```
n=int(input())
m=list(map(int,input().split()))
m.sort()
avg=(m[0]+m[-1])//2
z=0
if m==[1,2,3]:
print(1)
exit()
for i in m:
if (abs(i-avg))%2==1:
z=z+1;
print(z)
```
No
| 2,557 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
c=[]
for i in range(n):
z=a[i]
y=[]
for j in range(n):
x=abs(z-a[j])
y.append(x)
c.append(y)
d=[]
for i in range(len(c)):
d.append(c[i].count(1))
print(min(d))
```
No
| 2,558 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n chips on a number line. The i-th chip is placed at the integer coordinate x_i. Some chips can have equal coordinates.
You can perform each of the two following types of moves any (possibly, zero) number of times on any chip:
* Move the chip i by 2 to the left or 2 to the right for free (i.e. replace the current coordinate x_i with x_i - 2 or with x_i + 2);
* move the chip i by 1 to the left or 1 to the right and pay one coin for this move (i.e. replace the current coordinate x_i with x_i - 1 or with x_i + 1).
Note that it's allowed to move chips to any integer coordinate, including negative and zero.
Your task is to find the minimum total number of coins required to move all n chips to the same coordinate (i.e. all x_i should be equal after some sequence of moves).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 100) — the number of chips.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^9), where x_i is the coordinate of the i-th chip.
Output
Print one integer — the minimum total number of coins required to move all n chips to the same coordinate.
Examples
Input
3
1 2 3
Output
1
Input
5
2 2 2 3 3
Output
2
Note
In the first example you need to move the first chip by 2 to the right and the second chip by 1 to the right or move the third chip by 2 to the left and the second chip by 1 to the left so the answer is 1.
In the second example you need to move two chips with coordinate 3 by 1 to the left so the answer is 2.
Submitted Solution:
```
import math
n = int(input())
arr = [int(x) for x in input().split()]
coins = 0
counter = 0
curr_frequency = 0
highest = arr[0]
arr.sort()
for i in arr:
curr_frequency = arr.count(i)
if(curr_frequency> counter):
counter = curr_frequency
highest = i
for i in arr:
if highest % 2 == 0:
if i == highest:
continue
if i%2 != 0:
coins += 1
else:
if i == highest:
continue
if i%2 == 0:
coins += 1
if n == 99:
coins+=1
print (coins)
```
No
| 2,559 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Tags: combinatorics, math
Correct Solution:
```
n,m = map(int,input().split())
print(pow(2**m-1, n, 10**9+7))
```
| 2,560 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Tags: combinatorics, math
Correct Solution:
```
d = input()
d = d.split()
n = int(d[0])
m = int(d[1])
w = pow(2,m,1000000007)-1
n = pow(w,n,1000000007)
print(n)
```
| 2,561 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Tags: combinatorics, math
Correct Solution:
```
n, m = map(int,input().split())
mod = 1000000007
ans = pow(2, m, mod)
ans -= 1
ans = pow(ans,n,mod)
print(ans)
```
| 2,562 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Tags: combinatorics, math
Correct Solution:
```
n,m=[int(i) for i in input().split()]
print(pow(2**m-1,n,10**9+7))
```
| 2,563 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Tags: combinatorics, math
Correct Solution:
```
a, b = list(map(int, input().split()))
mod = 10**9 + 7
print(pow(pow(2, b, mod)-1, a, mod))
```
| 2,564 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Tags: combinatorics, math
Correct Solution:
```
a = input('').split(' ')
n = int(a[0])
m = int(a[1])
M = 10**9+7
p = (pow(2,m,M)-1)%M
print(pow(p,n,M))
```
| 2,565 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Tags: combinatorics, math
Correct Solution:
```
n,m = [int(a) for a in input().split()]
mod = 10**9 + 7
ans = pow(pow(2,m, mod)-1, n, mod)
print(ans)
```
| 2,566 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Tags: combinatorics, math
Correct Solution:
```
n, m = [int(x) for x in input().split()]
x = -1
x += 2**m
mod = 7
mod += 10**9
r = pow(x, n, mod)
print(r)
```
| 2,567 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Submitted Solution:
```
def mp():
return map(int, input().split())
def power(a, n, mod):
if n == 0:
return 1
elif n == 1:
return a % mod
elif n % 2 != 0:
return ((a % mod) * power(a, n - 1, mod)) % mod
return power(a * a % mod, n // 2, mod) % mod
n, m = mp()
print(power(power(2, m, 10 ** 9 + 7) - 1, n, 10 ** 9 + 7))
```
Yes
| 2,568 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Submitted Solution:
```
import sys, math
from heapq import heappush, heappop
readline = sys.stdin.readline
mr = lambda:map(int,readline().split())
n, k = mr()
tp = pow(pow(2,k,1000000007) - 1,n,1000000007)
print(tp)
```
Yes
| 2,569 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Submitted Solution:
```
MOD = 1000000007
n, m = map(int, input().split())
def power(x, y, p):
res = 1
x = x % p
while (y > 0):
if (y & 1):
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
x = power(2,m,MOD) - 1
# print(x)
b = str(n)
# print(b)
remainderB = 0
# print(b)
for i in range(len(b)):
remainderB = ((remainderB * 10 + ord(b[i]) - 48) % (MOD - 1))
y = power(x,remainderB,MOD)
print(y)
# print(x)
# y = powit(x,n)
# print(y)
```
Yes
| 2,570 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Submitted Solution:
```
from sys import stdin
#import nltk
import math
from collections import defaultdict
#stdin=open('input.txt','r')
I=stdin.readline
n,m=map(int,I().split())
mod=10**9+7
a=(pow(2,m,mod)-1+mod)%mod
b=pow(a,n,mod)
print(b)
```
Yes
| 2,571 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Submitted Solution:
```
n,m=map(int,input().split())
ans=0
if(n==1):
ans=(pow(2,n*m,1000000007)-1+1000000007)%1000000007
else :
ans=(pow(2,n*m,1000000007)-((n*pow(2,(n-1)*m,1000000007))%1000000007)+1000000007)%1000000007+1
ans=ans%1000000007
print(ans)
```
No
| 2,572 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Submitted Solution:
```
n, m = map(int, input().split())
print(((pow(2, m, 1000000007) - 1) * n) % (1000000007))
```
No
| 2,573 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Submitted Solution:
```
maximal = 1e9 + 7
def binpow (a, n):
if n==0:
return 1
if n%2 == 1:
return (binpow(a, n-1) * a) % maximal
else:
b = binpow(a, int(n/2)) % maximal
return (b*b) % maximal
n, m = map(int, input().split())
sf = (binpow(2, m) - 1 + maximal) % maximal
rez = binpow(sf, n)
print(str(int(rez)))
```
No
| 2,574 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.
There are n kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.
Also, there are m boxes. All of them are for different people, so they are pairwise distinct (consider that the names of m friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.
Alice wants to pack presents with the following rules:
* She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of n kinds, empty boxes are allowed);
* For each kind at least one present should be packed into some box.
Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo 10^9+7.
See examples and their notes for clarification.
Input
The first line contains two integers n and m, separated by spaces (1 ≤ n,m ≤ 10^9) — the number of kinds of presents and the number of boxes that Alice has.
Output
Print one integer — the number of ways to pack the presents with Alice's rules, calculated by modulo 10^9+7
Examples
Input
1 3
Output
7
Input
2 2
Output
9
Note
In the first example, there are seven ways to pack presents:
\{1\}\{\}\{\}
\{\}\{1\}\{\}
\{\}\{\}\{1\}
\{1\}\{1\}\{\}
\{\}\{1\}\{1\}
\{1\}\{\}\{1\}
\{1\}\{1\}\{1\}
In the second example there are nine ways to pack presents:
\{\}\{1,2\}
\{1\}\{2\}
\{1\}\{1,2\}
\{2\}\{1\}
\{2\}\{1,2\}
\{1,2\}\{\}
\{1,2\}\{1\}
\{1,2\}\{2\}
\{1,2\}\{1,2\}
For example, the way \{2\}\{2\} is wrong, because presents of the first kind should be used in the least one box.
Submitted Solution:
```
n, m = [int(i) for i in input().split()]
mod = 1000000009
print(pow( ( pow(2, m, mod) -1) , n, mod))
```
No
| 2,575 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
mod = 1000000007
eps = 10**-9
def main():
import sys
from string import ascii_letters, digits
input = sys.stdin.readline
SS = ascii_letters + digits
for _ in range(int(input())):
H, W, K = map(int, input().split())
S = SS[:K]
grid = []
for _ in range(H):
grid.append(input().rstrip('\n'))
num_rice = 0
for h in range(H):
for w in range(W):
if grid[h][w] == "R":
num_rice += 1
minor = num_rice // K
major = minor + 1
num_major = num_rice % K
i = 0
cnt = 0
ans = [[""] * W for _ in range(H)]
for h in range(H):
if h&1:
for w in range(W-1, -1, -1):
if grid[h][w] == "R":
cnt += 1
ans[h][w] = S[i]
if i < num_major:
if cnt == major:
cnt = 0
if i != K-1:
i += 1
else:
if cnt == minor:
cnt = 0
if i != K-1:
i += 1
else:
ans[h][w] = S[i]
else:
for w in range(W):
if grid[h][w] == "R":
cnt += 1
ans[h][w] = S[i]
if i < num_major:
if cnt == major:
cnt = 0
if i != K - 1:
i += 1
else:
if cnt == minor:
cnt = 0
if i != K - 1:
i += 1
else:
ans[h][w] = S[i]
for h in range(H):
print("".join(ans[h]))
if __name__ == '__main__':
main()
```
| 2,576 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
#!/usr/bin/python3
import os
import sys
def main():
T = read_int()
for _ in range(T):
R, C, K = read_ints()
A = [inp() for _ in range(R)]
print(*solve(R, C, K, A), sep='\n')
def itoc(i):
if i < 10:
return chr(ord('0') + i)
i -= 10
if i < 26:
return chr(ord('a') + i)
i -= 26
return chr(ord('A') + i)
def solve(R, C, K, A):
ans = [[None] * C for _ in range(R)]
rice = sum([s.count('R') for s in A])
c = rice // K
i = 0
for y in range(R):
for x in range(C) if y % 2 == 0 else range(C - 1, -1, -1):
ans[y][x] = i
if A[y][x] == 'R':
c -= 1
rice -= 1
if c == 0:
K -= 1
if K > 0:
c = rice // K
i += 1
return [''.join([itoc(c) for c in r]) for r in ans]
###############################################################################
DEBUG = 'DEBUG' in os.environ
def inp():
return sys.stdin.readline().rstrip()
def read_int():
return int(inp())
def read_ints():
return [int(e) for e in inp().split()]
def dprint(*value, sep=' ', end='\n'):
if DEBUG:
print(*value, sep=sep, end=end)
if __name__ == '__main__':
main()
```
| 2,577 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
from string import ascii_letters
def solve(a,x,y,ch,ty):
if ty==0:
for j in range(y,len(a[0]),1):
a[x][j]=ch
else:
for j in range(y,-1,-1):
a[x][j]=ch
x+=1
for i in range(x,len(a),1):
for j in range(0,len(a[0]),1):
a[i][j]=ch
def main():
al=list(ascii_letters)+[chr(i+48) for i in range(10)]
for _ in range(int(input())):
r,c,k=map(int,input().split())
a=[list(input().rstrip()) for _ in range(r)]
u,v=divmod(sum(i.count("R") for i in a),k)
z,v,k=u+(v>0),v-1,k-1
for i in range(r):
if i&1:
for j in range(c-1,-1,-1):
a[i][j],z=al[k],z-(a[i][j]=="R")
if z==0:
z,v,k=u+(v>0),v-1,k-1
if k==-1:
solve(a,i,j,al[0],1)
break
else:
for j in range(c):
a[i][j],z=al[k],z-(a[i][j]=="R")
if z==0:
z,v,k=u+(v>0),v-1,k-1
if k==-1:
solve(a,i,j,al[0],0)
break
if k==-1:
break
for i in a:
print("".join(i))
# FAST INPUT OUTPUT REGION
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
```
| 2,578 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
from collections import deque
t = int(input())
ls = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
def proceed(x,y):
if x%2 == 0 and 0 <= y < c-1:
return(x,y+1)
elif x%2 == 0:
return(x+1,y)
elif 0 < y <= c-1:
return(x,y-1)
else:
return(x+1,y)
for _ in range(t):
r,c,k = map(int,input().split())
cell = [input() for i in range(r)]
nr = 0
pr = []
for i in range(r):
for j in range(c):
if cell[i][j] == "R":
pr.append((i,j))
nr += 1
Q,R = divmod(nr,k)
cnt = 0
cntr = 0
ans = [["" for i in range(c)] for j in range(r)]
x,y = 0,0
for cntr in range(k):
cnt = 0
while (cnt < Q+(cntr<R) or cntr == k-1):
ans[x][y] = ls[cntr]
if cell[x][y] == "R":
cnt += 1
x,y = proceed(x,y)
if x == r:
break
for arr in ans:
print(*arr,sep="")
```
| 2,579 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
import math
n=int(input())
res=[chr(x) for x in range(ord('a'), ord('z') + 1)]
res1=[chr(x) for x in range(ord('A'), ord('Z') + 1)]
res+=res1
res2=[0,1,2,3,4,5,6,7,8,9]
res+=res2
for i in range(n):
r,c,f=map(int,input().split())
s=[]
e=0
for j in range(r):
k=input()
e+=k.count('R')
s.append(k)
w=e%f
e=math.ceil(e/f)
e=int(e)
cou=f
cou1=1
ans=[[-1 for i in range(c)]for j in range(r)]
rw=0
co=0
inc=1
while(cou>1):
#print(cou)
if w!=0 and cou1==w+1:
e-=1
cur=0
while(cur<e):
ans[rw][co]=res[cou1-1]
#print(rw,co)
if s[rw][co]=='R':
cur+=1
co+=inc
if inc==1 and co==c:
rw+=1
co=c-1
inc=-1
elif inc==-1 and co==-1:
rw+=1
co=0
inc=1
cou-=1
cou1+=1
#print(ans)
for jk in range(r):
for ik in range(c):
if ans[jk][ik]==-1:
ans[jk][ik]=res[f-1]
for jk in range(r):
print(*ans[jk],sep="")
```
| 2,580 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
from string import ascii_letters, digits
def snake(n, m):
i = j = 0
d = 1
while i < n:
while 0 <= j < m:
yield i, j
j += d
i += 1
d *= -1
j += d
chickens = ascii_letters + digits
cfield = [[''] * 100 for _ in range(100)]
rfield = [''] * 100
for _ in range(int(input())):
r, c, k = map(int, input().split())
n = 0
for i in range(r):
rfield[i] = input()
n += rfield[i].count('R')
q = n // k
a = n % k
u = 0
v = q + int(u < a)
for i, j in snake(r, c):
cfield[i][j] = chickens[min(u, k - 1)]
if rfield[i][j] == 'R':
v -= 1
if v == 0:
u += 1
v = q + int(u < a)
for i in range(r):
print(*cfield[i][:c], sep='')
```
| 2,581 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
import sys
from string import ascii_letters, digits
readline = sys.stdin.readline
T = int(readline())
Ans = []
cnums = ascii_letters + digits
for qu in range(T):
r, c, k = map(int, readline().split())
G = [[1 if s == 'R' else 0 for s in readline().strip()] for _ in range(r)]
ans = [[None]*c for _ in range(r)]
tr = sum(sum(g) for g in G)
visited = set([-1])
nr, nc = 0, -1
sep = [tr//k + (1 if i < tr%k else 0) for i in range(k)]
cc = 0
chiken = 0
for cnt in range(r*c):
for dr, dc in ((0, 1), (0, -1), (1, 0)):
if not 0 <= nc + dc <= c-1 or ((nr+dr)*c + nc+dc) in visited:
continue
else:
nc += dc
nr += dr
visited.add(nr*c + nc)
break
if G[nr][nc]:
cc += 1
ans[nr][nc] = chiken
if cc == sep[chiken] and chiken + 1 <k :
cc = 0
chiken += 1
for an in ans:
sys.stdout.write(''.join(cnums[a] for a in an))
sys.stdout.write('\n')
```
| 2,582 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Tags: constructive algorithms, greedy, implementation
Correct Solution:
```
from collections import deque, Counter
import array
from itertools import combinations, permutations
from math import sqrt
import unittest
def read_int():
return int(input().strip())
def read_int_array():
return [int(i) for i in input().strip().split(' ')]
for test in range(read_int()):
rows, cols, ch = read_int_array()
rice = 0
field = []
for r in range(rows):
field += [list(input().strip())]
rice += field[-1].count('R')
code = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
i = 0
j = 0
count = 0
ch_n = 1
base = rice // ch
rem = rice % ch
base_num = ch - rem
for i in range(rows):
for j in range(cols):
j = j if i % 2 == 0 else -j-1
if field[i][j] == 'R':
count += 1
if count > (base if ch_n <= base_num else base + 1):
ch_n += 1
count = 1
field[i][j] = code[ch_n - 1]
print('\n'.join(''.join(field[i]) for i in range(rows)))
```
| 2,583 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Submitted Solution:
```
import string
chars=string.ascii_letters+string.digits
def main():
# Alternately fill left-right and right-left
t=int(input())
for _ in range(t):
n,m,k=readIntArr()
grid=list()
for __ in range(n):
grid.append(input())
riceCnts=0
for i in range(n):
for j in range(m):
if grid[i][j]=='R':
riceCnts+=1
base=riceCnts//k
remainder=riceCnts%k
chickenCnts=[base for __ in range(k)]
for i in range(remainder):
chickenCnts[i]+=1
assert sum(chickenCnts)==riceCnts
ans=[[-1 for _ in range(m)] for __ in range(n)]
fromLeft=True
chickenIdx=0
for row in range(n):
if fromLeft:
start,end,inc=0,m,1
else:
start,end,inc=m-1,-1,-1
for col in range(start,end,inc):
ans[row][col]=chars[chickenIdx]
if grid[row][col]=='R':
chickenCnts[chickenIdx]-=1
if chickenIdx+1<k and chickenCnts[chickenIdx]==0: # move on to the next chicken
chickenIdx+=1
fromLeft=not fromLeft
multiLineArrayOfArraysPrint(ans)
return
import sys
# input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
def oneLineArrayPrint(arr):
print(' '.join([str(x) for x in arr]))
def multiLineArrayPrint(arr):
print('\n'.join([str(x) for x in arr]))
def multiLineArrayOfArraysPrint(arr):
print('\n'.join([''.join([str(x) for x in y]) for y in arr]))
def readIntArr():
return [int(x) for x in input().split()]
# def readFloatArr():
# return [float(x) for x in input().split()]
def makeArr(defaultVal,dimensionArr): # eg. makeArr(0,[n,m])
dv=defaultVal;da=dimensionArr
if len(da)==1:return [dv for _ in range(da[0])]
else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
def queryInteractive(x,y):
print('? {} {}'.format(x,y))
sys.stdout.flush()
return int(input())
def answerInteractive(ans):
print('! {}'.format(ans))
sys.stdout.flush()
inf=float('inf')
MOD=10**9+7
for _abc in range(1):
main()
```
Yes
| 2,584 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Submitted Solution:
```
from string import ascii_letters
import os
L = ascii_letters + "".join(map(str, range(10)))
def f(lines, n_chick):
n_food = sum(x == "R" for l in lines for x in l)
res = [["X"] * len(lines[0]) for _ in range(len(lines))]
food_per_chick, extra_food = divmod(n_food, n_chick)
chick_num = 0
current_food_count = 0
for r_idx in range(len(lines)):
if r_idx % 2 == 0:
cc = range(len(lines[0]))
else:
cc = range(len(lines[0]) - 1, -1, -1)
for c_idx in cc:
if lines[r_idx][c_idx] == "R":
current_food_count += 1
if current_food_count > food_per_chick + (chick_num < extra_food):
chick_num += 1
current_food_count = 1
res[r_idx][c_idx] = L[chick_num]
return "\n".join("".join(r) for r in res)
def pp(input):
n = int(input())
for test in range(n):
r, c, k = map(int, input().split())
lines = [input() for _ in range(r)]
print(f(lines, k))
if "paalto" in os.getcwd():
from string_source import string_source
s0 = string_source(
"""4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR"""
)
pp(s0)
else:
pp(input)
```
Yes
| 2,585 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Submitted Solution:
```
from collections import Counter, OrderedDict
from itertools import permutations as perm
from collections import deque
from sys import stdin
from bisect import *
from heapq import *
import math
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
mod = int(1e9)+7
inf = float("inf")
t, = gil()
for _ in range(t):
n, m, k = gil()
mat = []
r = 0
for _ in range(n):
mat.append(g())
r += mat[-1].count("R")
cnt = {}; base = r//k
cnt[base] = k - r%k
cnt[base+1] = r%k
ide = []
for i in range(10):
ide.append(str(i))
for ch in "abcdefghijklmnopqrstuvwxyz":
ide.append(ch)
ide.append(ch.capitalize())
x, y, idx, ct = 0, 0, 0, 0
dt = 1
# print(cnt)
ans = []
for i in range(n):
ans.append([None for _ in range(m)])
while y < n and x < m:
ans[y][x] = ide[idx]
if mat[y][x] == "R":
ct += 1
if ct in cnt :
cnt[ct] -= 1
if cnt[ct] == 0:
del cnt[ct]
idx += 1
# print(ct)
ct =0
idx = min(idx, k-1)
y += dt
if y == n:
x+=1
y=n-1
dt = -1
if y == -1:
x += 1
y = 0
dt = 1
for r in ans:
print("".join(r))
# print()
```
Yes
| 2,586 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Submitted Solution:
```
arid='abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'
for _ in range(int(input())):
r,c,k=map(int,input().split())
ar=[]
count=0
for i in range(r):
ar.append(input())
for j in ar[-1]:
if(j=='R'):
count+=1
each=count//k
rem=count%k
count=0
tem=0
for i in range(r):
if(i%2==0):
xx=''
for j in range(0,c,1):
if(ar[i][j]=='R'):
if(count<=(rem-1)):
if(tem==(each+1)):
count+=1
tem=0
if(tem<(each+1)):
xx+=arid[count]
tem+=1
elif(count>(rem-1)):
if(tem==each):
count+=1
tem=0
if(tem<each):
xx+=arid[count]
tem+=1
else:
xx+=arid[count]
print(xx)
else:
xx=''
for j in range(c-1,-1,-1):
if(ar[i][j]=='R'):
if(count<=(rem-1)):
if(tem==(each+1)):
count+=1
tem=0
if(tem<(each+1)):
xx+=arid[count]
tem+=1
elif(count>(rem-1)):
if(tem==each):
count+=1
tem=0
if(tem<each):
xx+=arid[count]
tem+=1
else:
xx+=arid[count]
print(xx[::-1])
```
Yes
| 2,587 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Submitted Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
from collections import deque
from string import ascii_letters
def main():
t=[]
zzz=list(ascii_letters)+[chr(i+48) for i in range(10)]
for _ in range(int(input())):
r,c,kk=map(int,input().split())
a=[list(input().rstrip())+["#"] for _ in range(r)]
a.append(["#"]*(c+1))
u,v=divmod(sum(i.count("R") for i in a),kk)
dx=[0,1,-1,0]
dy=[-1,0,0,1]
k=0
for i in range(r):
for j in range(c):
if a[i][j] not in "R.":
continue
q,z,a[i][j]=deque([(i,j)]),u+(v>0)-(a[i][j]=="R"),zzz[k]
while z and q:
x,y=q.popleft()
for l in range(4):
xx,yy=x+dx[l],y+dy[l]
if a[xx][yy]=="R":
a[xx][yy],z=zzz[k],z-1
if not z:
break
q.append((xx,yy))
elif a[xx][yy]==".":
a[xx][yy]=zzz[k]
q.append((xx, yy))
v,k=v-1,k+1
if k==kk:
break
if k==kk:
break
for i in range(r):
for j in range(c):
if a[i][j]==".":
continue
q,z=deque([(i,j)]),a[i][j]
while q:
x,y=q.popleft()
for l in range(4):
xx,yy=x+dx[l],y+dy[l]
if a[xx][yy] ==".":
a[xx][yy]=z
q.append((xx,yy))
for i in a[:r]:
print("".join(i[:c]))
# FAST INPUT OUTPUT REGION
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
```
No
| 2,588 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Submitted Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
from collections import deque
from string import ascii_letters
from copy import deepcopy
def main():
t,f=[],0
zzz=list(ascii_letters)+[chr(i+48) for i in range(10)]
for tt in range(int(input())):
r,c,kk=map(int,input().split())
a=[list(input().rstrip())+["#"] for _ in range(r)]
a.append(["#"]*(c+1))
b=deepcopy(a)
u,v=divmod(sum(i.count("R") for i in a),kk)
dx=[0,1,-1,0]
dy=[-1,0,0,1]
k=0
for i in range(r):
for j in range(c):
if a[i][j]!="R":
continue
q,z,a[i][j]=deque([(i,j)]),u+(v>0)-1,zzz[k]
while z and q:
x,y=q.popleft()
for l in range(4):
xx,yy=x+dx[l],y+dy[l]
if a[xx][yy]=="R":
a[xx][yy],z=zzz[k],z-1
if not z:
break
q.append((xx,yy))
elif a[xx][yy]==".":
a[xx][yy]=zzz[k]
q.append((xx, yy))
if z:
f=1
print(r,c,kk,tt+1,b)
break
v,k=v-1,k+1
if f:
break
if not f:
for i in range(r):
for j in range(c):
if a[i][j]==".":
continue
q,z=deque([(i,j)]),a[i][j]
while q:
x,y=q.popleft()
for l in range(4):
xx,yy=x+dx[l],y+dy[l]
if a[xx][yy] ==".":
a[xx][yy]=z
q.append((xx,yy))
t.append(a)
if not f:
for i in t:
for j in i[:len(i)-1]:
print("".join(j[:len(j)-1]))
# FAST INPUT OUTPUT REGION
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
```
No
| 2,589 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
def toord(c): return ord(c) - ord('a')
def lcm(a, b): return a * b // lcm(a, b)
mod = 998244353
INF = float('inf')
from math import factorial, sqrt, ceil, floor, gcd
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
from string import ascii_lowercase as lw
from string import ascii_uppercase as uw
from string import digits as dg
# ------------------------------
# f = open('./input.txt')
# sys.stdin = f
def main():
for _ in range(N()):
r, c, k = RL()
arr = [list(input()) for _ in range(r)]
rnum = 0
for i in arr:
rnum+=i.count('R')
sig = rnum//k
dif = rnum%k
st = lw + uw + dg
res = [['']*c for _ in range(r)]
now = 0
tag = 0
stag = 0
for i in range(r):
for j in range(c):
if tag==0:
nj = j
else:
nj = c-j-1
if arr[i][nj]=='R':
now+=1
res[i][nj] = st[stag]
if dif==0:
if now == sig:
now = 0
stag+=1
else:
if now==sig+1:
now = 0
stag+=1
dif-=1
tag^=1
for i in res: print(''.join(i))
if __name__ == "__main__":
main()
```
No
| 2,590 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Long is a huge fan of CFC (Codeforces Fried Chicken). But the price of CFC is increasing, so he decides to breed the chicken on his own farm.
His farm is presented by a rectangle grid with r rows and c columns. Some of these cells contain rice, others are empty. k chickens are living on his farm. The number of chickens is not greater than the number of cells with rice on the farm.
Long wants to give his chicken playgrounds by assigning these farm cells to his chickens. He would like to satisfy the following requirements:
* Each cell of the farm is assigned to exactly one chicken.
* Each chicken is assigned at least one cell.
* The set of cells assigned to every chicken forms a connected area. More precisely, if two cells (x, y) and (u, v) are assigned to the same chicken, this chicken is able to walk from (x, y) to (u, v) by passing only its cells and moving from each cell to another cell sharing a side.
Long also wants to prevent his chickens from fighting for food. Hence he wants the difference between the maximum and the minimum number of cells with rice assigned to a chicken to be as small as possible. Please help him.
Input
Each test contains multiple test cases. The first line contains the number of test cases T (1 ≤ T ≤ 2 ⋅ 10^4). Description of the test cases follows.
The first line of each test case contains three integers r, c and k (1 ≤ r, c ≤ 100, 1 ≤ k ≤ 62), representing the size of Long's farm and the number of chickens Long has.
Each of the next r lines contains c characters, each is either "." or "R", representing an empty cell or a cell with rice. It is guaranteed that the number of chickens is not greater than the number of cells with rice on the farm.
It is guaranteed that the sum of r ⋅ c over all test cases does not exceed 2 ⋅ 10^4.
Output
For each test case, print r lines with c characters on each line. Each character should be either a lowercase English character, an uppercase English character, or a digit. Two characters should be equal if and only if the two corresponding cells are assigned to the same chicken. Uppercase and lowercase characters are considered different, so "A" and "a" belong to two different chickens.
If there are multiple optimal answers, print any.
Example
Input
4
3 5 3
..R..
...R.
....R
6 4 6
R..R
R..R
RRRR
RRRR
R..R
R..R
5 5 4
RRR..
R.R..
RRR..
R..R.
R...R
2 31 62
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
Output
11122
22223
33333
aacc
aBBc
aBBc
CbbA
CbbA
CCAA
11114
22244
32444
33344
33334
abcdefghijklmnopqrstuvwxyzABCDE
FGHIJKLMNOPQRSTUVWXYZ0123456789
Note
These pictures explain the sample output. Each color represents one chicken. Cells filled with patterns (not solid colors) contain rice.
In the first test case, each chicken has one cell with rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 0.
<image>
In the second test case, there are 4 chickens with 3 cells of rice, and 2 chickens with 2 cells of rice. Hence, the difference between the maximum and the minimum number of cells with rice assigned to a chicken is 3 - 2 = 1.
<image>
In the third test case, each chicken has 3 cells with rice. <image>
In the last test case, since there are 62 chicken with exactly 62 cells of rice, each chicken must be assigned to exactly one cell. The sample output is one of the possible way.
Submitted Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
from io import BytesIO, IOBase
import sys
from string import ascii_letters
def solve(a,x,y,ch):
for i in range(x,len(a),1):
for j in range(y,len(a[0]),1):
a[i][j]=ch
y=0
def main():
al=list(ascii_letters)+[chr(i+48) for i in range(10)]
for _ in range(int(input())):
r,c,k=map(int,input().split())
a=[list(input().rstrip()) for _ in range(r)]
u,v=divmod(sum(i.count("R") for i in a),k)
z,v,k=u+(v>0),v-1,k-1
for i in range(r):
if i&1:
for j in range(c-1,-1,-1):
a[i][j],z=al[k],z-(a[i][j]=="R")
if z==0:
z,v,k=u+(v>0),v-1,k-1
if k==-1:
solve(a,i,j,al[0])
else:
for j in range(c):
a[i][j],z=al[k],z-(a[i][j]=="R")
if z==0:
z,v,k=u+(v>0),v-1,k-1
if k==-1:
solve(a,i,j,al[0])
for i in a:
print("".join(i))
# FAST INPUT OUTPUT REGION
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
```
No
| 2,591 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Tags: brute force, combinatorics, constructive algorithms, data structures, greedy, math
Correct Solution:
```
from collections import Counter
from sys import stdin
def input():
return next(stdin)[:-1]
def main():
n = int(input())
aa = input().split()
cc = list(Counter(aa).most_common())
if n % cc[0][1] == 0 and cc[0][1] * cc[0][1] <= n:
h = cc[0][1]
w = n//cc[0][1]
best = n
else:
count_count = [0] * (n+1)
for v, c in cc:
count_count[c] += 1
geq = [count_count[n]]
for v in reversed(count_count[:n]):
geq.append(geq[-1] + v)
geq.reverse()
tot = 0
best = 0
for a in range(1,n+1):
tot += geq[a]
b = tot//a
if a <= b and best < a * b:
best = a * b
h = a
w = b
print(best)
print(h,w)
x = 0
y = 0
mat = [[''] * w for _ in range(h) ]
for v, c in cc:
for j in range(min(c, h)):
if mat[x][y] != '':
x = (x+1)%h
if mat[x][y] == '':
mat[x][y] = v
x = (x+1)%h
y = (y+1)%w
for i in range(h):
print(' '.join(mat[i]))
if __name__ == "__main__":
main()
```
| 2,592 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Tags: brute force, combinatorics, constructive algorithms, data structures, greedy, math
Correct Solution:
```
from collections import Counter
from itertools import accumulate
from math import sqrt
from operator import itemgetter
import sys
n = int(input())
cnt = Counter(map(int, input().split()))
nums, counts = zip(*sorted(cnt.items(), key=itemgetter(1)))
acc = [0] + list(accumulate(counts))
area = 1
h, w = 1, 1
i = len(counts)
for y in range(int(sqrt(n)), 0, -1):
while i and counts[i-1] > y:
i -= 1
total = acc[i] + (len(counts) - i) * y
x = total // y
if y <= x and area < x * y:
h, w, area = y, x, x*y
ans = [[0]*w for _ in range(h)]
i = len(counts)-1
num, count = nums[i], min(h, counts[i])
for x in range(w):
for y in range(h):
ans[y][(x + y) % w] = num
count -= 1
if count == 0:
i -= 1
num, count = nums[i], h if h < counts[i] else counts[i]
print(area)
print(h, w)
for y in range(h):
sys.stdout.write(' '.join(map(str, ans[y])) + '\n')
```
| 2,593 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Tags: brute force, combinatorics, constructive algorithms, data structures, greedy, math
Correct Solution:
```
n = int(input())
arr = list(map(int, input().split()))
d = {}
for i in arr:
d[i] = d.get(i, 0) + 1
d2 = {}
for k, v in d.items():
d2.setdefault(v, []).append(k)
s = n
prev = 0
ansp = ansq = anss = 0
for p in range(n, 0, -1):
q = s // p
if p <= q and q * p > anss:
anss = q * p
ansq = q
ansp = p
prev += len(d2.get(p, []))
s -= prev
def get_ans():
cur_i = 0
cur_j = 0
cur = 0
for k, v in d3:
for val in v:
f = min(k, anss - cur, ansp)
cur += f
for i in range(f):
cur_i = (cur_i + 1) % ansp
cur_j = (cur_j + 1) % ansq
if ans[cur_i][cur_j]:
cur_i = (cur_i + 1) % ansp
ans[cur_i][cur_j] = val
print(anss)
print(ansp, ansq)
d3 = sorted(d2.items(), reverse=True)
ans = [[0] * ansq for i in range(ansp)]
get_ans()
for i in range(ansp):
print(*ans[i])
```
| 2,594 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Tags: brute force, combinatorics, constructive algorithms, data structures, greedy, math
Correct Solution:
```
def play(arr):
n = len(arr)
number2Count = {}
for p in arr:
number2Count[p] = number2Count.get(p, 0) + 1
count2Numbers = {}
maxCnt = 0
for num in number2Count:
cnt = number2Count[num]
if not cnt in count2Numbers:
count2Numbers[cnt] = []
count2Numbers[cnt].append(num)
maxCnt = max(maxCnt, cnt)
numRepeats = [0] * (n + 1)
numRepeats[n] = len(count2Numbers.get(n, []))
for i in range(n - 1, 0, -1):
numRepeats[i] = numRepeats[i + 1] + len(count2Numbers.get(i, []))
a_ideal = 0
b_ideal = 0
square = 0
square_ideal = 0
for a in range(1, n + 1):
square += numRepeats[a]
b = int(square / a)
if a <= b:
if square_ideal < a * b:
square_ideal = a * b
a_ideal = a
b_ideal = b
print(a_ideal * b_ideal)
print(str(a_ideal) + ' ' + str(b_ideal))
matrix = [[0] * b_ideal for p in range(0, a_ideal)]
x = 0
y = 0
for cnt in range(maxCnt, 0, -1):
for num in count2Numbers.get(cnt, []):
for i in range(0, min(cnt, a_ideal)):
if matrix[x][y] > 0:
x = (x + 1) % a_ideal
if matrix[x][y] == 0:
matrix[x][y] = num
x = (x + 1) % a_ideal
y = (y + 1) % b_ideal
for i in range(0, a_ideal):
print(*matrix[i])
def main():
input()
arr = list(map(int, input().split()))
play(arr)
main()
#print(play([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8]))
#print(play([4, 9, 5, 9, 6, 8, 9, 8, 7]))
# play(['010', '101', '0'])
# play(['00000', '00001'])
# play(['01', '001', '0001', '00001'])
```
| 2,595 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Tags: brute force, combinatorics, constructive algorithms, data structures, greedy, math
Correct Solution:
```
n = int(input())
l = list(map(int,input().split()))
if n == 1:
print(1)
print(1,1)
print(l[0])
else:
d = {}
for i in l:
d[i] = 0
for i in l:
d[i] += 1
equal = [0] * (n + 1)
for i in d:
equal[d[i]] += 1
atmost = [0] * (n + 1)
atmost[0] = equal[0]
for i in range(1, n+1):
atmost[i] = atmost[i-1] + equal[i]
sumka = 0
best_iloczyn = 0
best_a = 0
best_b = 0
for a in range(1, n):
if a**2 > n:
break
sumka += (len(d) - atmost[a-1])
b_cand = sumka//a
if b_cand < a:
continue
if a * b_cand > best_iloczyn:
best_iloczyn = a * b_cand
best_a = a
best_b = b_cand
print(best_iloczyn)
print(best_a, best_b)
li = []
for i in d:
if d[i] >= best_a:
li += [i]*min(best_a, d[i])
for i in d:
if d[i] < best_a:
li += [i]*min(best_a, d[i])
#print(li)
mat = [[0] * best_b for i in range(best_a)]
for dd in range(1, best_a + 1):
if best_a%dd==0 and best_b%dd==0:
du = dd
i = 0
for st in range(du):
for j in range(best_iloczyn//du):
mat[i%best_a][(st+i)%best_b] = li[i]
i += 1
for i in range(best_a):
print(*mat[i])
```
| 2,596 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Submitted Solution:
```
n = int(input())
l = list(map(int,input().split()))
if n == 1:
print(1)
print(1,1)
print(l[0])
else:
d = {}
for i in l:
d[i] = 0
for i in l:
d[i] += 1
equal = [0] * (n + 1)
for i in d:
equal[d[i]] += 1
atmost = [0] * (n + 1)
atmost[0] = equal[0]
for i in range(1, n+1):
atmost[i] = atmost[i-1] + equal[i]
sumka = 0
best_iloczyn = 0
best_a = 0
best_b = 0
for a in range(1, n):
if a**2 > n:
break
sumka += (len(d) - atmost[a-1])
b_cand = sumka//a
if b_cand < a:
continue
if a * b_cand > best_iloczyn:
best_iloczyn = a * b_cand
best_a = a
best_b = b_cand
print(best_iloczyn)
print(best_a, best_b)
li = []
for i in d:
if d[i] == best_a:
li += [i]*min(best_a, d[i])
for i in d:
if d[i] != best_a:
li += [i]*min(best_a, d[i])
mat = [[0] * best_b for i in range(best_a)]
for dd in range(1, best_a + 1):
if best_a%dd==0 and best_b%dd==0:
du = dd
i = 0
for st in range(du):
for j in range(best_iloczyn//du):
mat[i%best_a][(st+i)%best_b] = li[i]
i += 1
for i in range(best_a):
print(*mat[i])
```
No
| 2,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Submitted Solution:
```
from collections import Counter
from math import sqrt
def main():
n = int(input())
aa = map(int,input().split())
cc = list(Counter(aa).most_common())
val_by_count = [[] for _ in range(n+1)]
for v, c in cc:
val_by_count[c].append(v)
geq = [len(val_by_count[n])]
for v in reversed(val_by_count[:n]):
geq.append(geq[-1] + len(v))
geq.reverse()
tot = 0
best = 0
for a in range(1,n+1):
tot += geq[a]
b = tot//a
if a <= b and best < a * b:
best = a * b
h = a
w = b
mat = [[0] * w for _ in range(h) ]
i = 0
j = 0
for v, c in cc:
for k in range(c):
if i+k < h:
mat[i+k][(j+k) % w ] = v
while i < h and mat[i][j] != 0:
j+=1
if j == w:
i+=1
j=0
print(h*w)
print(h, w)
for i in range(h):
print(' '.join(map(str, mat[i])))
if __name__ == "__main__":
main()
```
No
| 2,598 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n integers. You need to choose a subset and put the chosen numbers in a beautiful rectangle (rectangular matrix). Each chosen number should occupy one of its rectangle cells, each cell must be filled with exactly one chosen number. Some of the n numbers may not be chosen.
A rectangle (rectangular matrix) is called beautiful if in each row and in each column all values are different.
What is the largest (by the total number of cells) beautiful rectangle you can construct? Print the rectangle itself.
Input
The first line contains n (1 ≤ n ≤ 4⋅10^5). The second line contains n integers (1 ≤ a_i ≤ 10^9).
Output
In the first line print x (1 ≤ x ≤ n) — the total number of cells of the required maximum beautiful rectangle. In the second line print p and q (p ⋅ q=x): its sizes. In the next p lines print the required rectangle itself. If there are several answers, print any.
Examples
Input
12
3 1 4 1 5 9 2 6 5 3 5 8
Output
12
3 4
1 2 3 5
3 1 5 4
5 6 8 9
Input
5
1 1 1 1 1
Output
1
1 1
1
Submitted Solution:
```
n = int(input())
l = list(map(int,input().split()))
if n == 1:
print(1)
print(1,1)
print(l[0])
else:
d = {}
for i in l:
d[i] = 0
for i in l:
d[i] += 1
equal = [0] * (n + 1)
for i in d:
equal[d[i]] += 1
atmost = [0] * (n + 1)
atmost[0] = equal[0]
for i in range(1, n+1):
atmost[i] = atmost[i-1] + equal[i]
sumka = 0
best_iloczyn = 0
best_a = 0
best_b = 0
for a in range(1, n):
if a**2 > n:
break
sumka += (len(d) - atmost[a-1])
b_cand = sumka//a
if b_cand < a:
continue
if a * b_cand > best_iloczyn:
best_iloczyn = a * b_cand
best_a = a
best_b = b_cand
print(best_iloczyn)
print(best_a, best_b)
li = []
for i in d:
li += [i]*min(best_a, d[i])
mat = [[0] * best_b for i in range(best_a)]
for dd in range(1, best_a + 1):
if best_a%dd==0 and best_b%dd==0:
du = dd
i = 0
for st in range(du):
for j in range(best_iloczyn//du):
mat[i%best_a][(st+i)%best_b] = li[i]
i += 1
for i in range(best_a):
print(*mat[i])
```
No
| 2,599 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.