text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of students.
Then n lines follow. Each line contains two integer li, ri (1 ≤ li ≤ ri ≤ 5000) — the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 ≤ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Tags: implementation
Correct Solution:
```
## ar = list(map(int, input().strip().split(' ')))
t=int(input())
for i in range(t):
n=int(input())
l=[]
c=0
for j in range(n):
li,ri = map(int, input().strip().split(' '))
if j==0:
if li<=ri:
l.append(li)
c+=li
else:
l.append(0)
c=0
else:
if ri<=c:
l.append(0)
else:
c=max(c+1,li)
l.append(c)
for j in range(n):
print(l[j],end=" ")
print()
```
| 96,700 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of students.
Then n lines follow. Each line contains two integer li, ri (1 ≤ li ≤ ri ≤ 5000) — the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 ≤ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Tags: implementation
Correct Solution:
```
for repeat in range(int(input())):
studentsnum = int(input())
res = ""
laststudent = 0
for i in range(studentsnum):
inp = input().split(" ", 1)
arrival = int(inp[0])
departure = int(inp[1])
if arrival > laststudent:
laststudent = arrival
if departure < laststudent:
res = res + str(0) + " "
else:
res = res + str(laststudent) + " "
laststudent = laststudent + 1
print(res)
```
| 96,701 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of students.
Then n lines follow. Each line contains two integer li, ri (1 ≤ li ≤ ri ≤ 5000) — the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 ≤ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Tags: implementation
Correct Solution:
```
n=int(input())
t=0
for x in range(n):
p=int(input())
ol=[]
sl=[]
na=[]
ki=[]
pi=[]
t=0
for y in range(p):
v,c=list(map(int,input().split()))
ol.append(v)
sl.append(c)
for z in range(p):
sam=min(ol)
kp=ol.index(sam)
pi.append(kp)
if t<min(ol):
t=min(ol)+1
ki.append(min(ol))
ol[kp]=5555555
elif t==min(ol):
t+=1
ki.append(min(ol))
ol[kp]=55555555
else:
if sl[kp]>=t:
ki.append(t)
t+=1
ol[kp]=555555555
else:
ki.append(0)
ol[kp]=55555555
for r in range(0,p):
oll=pi.index(r)
na.append(ki[oll])
print(*na)
```
| 96,702 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of students.
Then n lines follow. Each line contains two integer li, ri (1 ≤ li ≤ ri ≤ 5000) — the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 ≤ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
# python 3
from collections import defaultdict
import math
from sys import stdin
casenumber = int(stdin.readline())
mydict=defaultdict(list)
output=[]
for i in range(casenumber):
n_student = int(stdin.readline())
outputlist=[]
l=[]
r=[]
for n in range(n_student):
string1 = stdin.readline().strip().split()
l_n=int(string1[0])
r_n=int(string1[1])
if l_n>len(l):
for count in range(l_n-len(l)):
l.append(0)
l.append(r_n)
else:
l.append(r_n)
if (len(l)-1)<=(r_n):
outputlist.append(len(l)-1)
else:
outputlist.append(0)
l.pop()
output.append(outputlist)
for i in range(casenumber):
for j in range(len(output[i])):
print(output[i][j],end=" ")
print('')
#
# B. Tea Queue
# time limit per test1 second
# memory limit per test256 megabytes
# inputstandard input
# outputstandard output
# Recently n students from city S moved to city P to attend a programming camp.
#
# They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
#
# i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
#
# For each student determine the second he will use the teapot and get his tea (if he actually gets it).
#
# Input
# The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 1000).
#
# Then t test cases follow. The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of students.
#
# Then n lines follow. Each line contains two integer li, ri (1 ≤ li ≤ ri ≤ 5000) — the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
#
# It is guaranteed that for every condition li - 1 ≤ li holds.
#
# The sum of n over all test cases doesn't exceed 1000.
#
# Note that in hacks you have to set t = 1.
#
# Output
# For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
#
# Example
# input
# 2
# 2
# 1 3
# 1 4
# 3
# 1 5
# 1 1
# 2 3
# output
# 1 2
# 1 0 2
# Note
# The example contains 2 tests:
#
# During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
# During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
```
Yes
| 96,703 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of students.
Then n lines follow. Each line contains two integer li, ri (1 ≤ li ≤ ri ≤ 5000) — the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 ≤ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n = int(input())
lims = [tuple(int(v) for v in input().split()) for _ in range(n)]
ctime = 0
ans = []
for l, r in lims:
if l >= ctime:
ans.append(l)
ctime = l + 1
elif r < ctime:
ans.append(0)
else:
ans.append(ctime)
ctime += 1
print(' '.join(str(v) for v in ans))
```
Yes
| 96,704 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of students.
Then n lines follow. Each line contains two integer li, ri (1 ≤ li ≤ ri ≤ 5000) — the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 ≤ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
# Put them all in queue in order of l. At popping check: should they be in? (time++)Should they be already out? (0)
t = int(input())
for _ in range(t):
n = int(input())
arr = [[int(i) for i in input().split()] + [i] for i in range(n)]
timearr = [0 for i in range(n)]
checked = 0
currtime = 1
arr.sort(key=lambda a:a[0])
while checked < n:
if arr[checked][0] > currtime:
currtime += 1
elif arr[checked][1] < currtime:
checked += 1
else:
timearr[arr[checked][2]] = currtime
currtime += 1
checked += 1
print(' '.join(str(i) for i in timearr))
```
Yes
| 96,705 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of students.
Then n lines follow. Each line contains two integer li, ri (1 ≤ li ≤ ri ≤ 5000) — the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 ≤ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
t = int(input())
ans1 = []
for i in range(t):
n=int(input())
st=[]
for i in range(n):
l,r = map(int,input().split())
st.append((l,r,i))
st = sorted(st, key=lambda x: (x[0], x[2]))
ans = []
f = -1
for s in st:
if s[1] < f:
ans.append(0)
else:
ans.append(max(f, s[0]))
f = ans[-1]+1
ans1.append(ans)
for ans2 in ans1:
print(' '.join([str(i) for i in ans2]))
```
Yes
| 96,706 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of students.
Then n lines follow. Each line contains two integer li, ri (1 ≤ li ≤ ri ≤ 5000) — the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 ≤ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
_ = int(input())
while _>0:
A = []
B = []
n = int(input())
for i in range(n):
p, q = map(int, input().split())
A.append([p, i, q])
A = sorted(A)
i = 0
k = A[0][0]
while i < len(A):
k = max(k + 1, A[i][0]) if i > 0 else k
while i < len(A) and max(k, A[i][0]) > A[i][2]:
del A[i]
B.append(0)
if i < len(A):B.append(k)
i += 1
print(' '.join(map(str,B)))
_-=1
```
No
| 96,707 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of students.
Then n lines follow. Each line contains two integer li, ri (1 ≤ li ≤ ri ≤ 5000) — the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 ≤ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
from collections import Counter as cntr
from math import inf
def cin():
return map(int, input().split(' '))
t = int(input())
for i in range(t):
l=[]
r=[]
n = int(input())
for i in range(n):
a, b = cin()
l.append(a)
r.append(b)
m = r[-1]
timer = 1
ans = []
for j in range(n):
if l[j]<=timer:
if r[j] >= timer:
ans.append(timer)
timer += 1
else:
ans.append(0)
else:
timer += 1
print(*ans)
```
No
| 96,708 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of students.
Then n lines follow. Each line contains two integer li, ri (1 ≤ li ≤ ri ≤ 5000) — the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 ≤ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
L=[]
res=[]
for j in range(n):
l,r=map(int,input().split())
L.insert(0,(l,r))
sec=L[-1][0]
while len(L)!=0:
tup=L.pop()
if tup[0]<=sec and tup[1]>=sec:
res.append(sec)
sec+=1
else:
res.append(0)
print(*res)
```
No
| 96,709 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently n students from city S moved to city P to attend a programming camp.
They moved there by train. In the evening, all students in the train decided that they want to drink some tea. Of course, no two people can use the same teapot simultaneously, so the students had to form a queue to get their tea.
i-th student comes to the end of the queue at the beginning of li-th second. If there are multiple students coming to the queue in the same moment, then the student with greater index comes after the student with lesser index. Students in the queue behave as follows: if there is nobody in the queue before the student, then he uses the teapot for exactly one second and leaves the queue with his tea; otherwise the student waits for the people before him to get their tea. If at the beginning of ri-th second student i still cannot get his tea (there is someone before him in the queue), then he leaves the queue without getting any tea.
For each student determine the second he will use the teapot and get his tea (if he actually gets it).
Input
The first line contains one integer t — the number of test cases to solve (1 ≤ t ≤ 1000).
Then t test cases follow. The first line of each test case contains one integer n (1 ≤ n ≤ 1000) — the number of students.
Then n lines follow. Each line contains two integer li, ri (1 ≤ li ≤ ri ≤ 5000) — the second i-th student comes to the end of the queue, and the second he leaves the queue if he still cannot get his tea.
It is guaranteed that for every <image> condition li - 1 ≤ li holds.
The sum of n over all test cases doesn't exceed 1000.
Note that in hacks you have to set t = 1.
Output
For each test case print n integers. i-th of them must be equal to the second when i-th student gets his tea, or 0 if he leaves without tea.
Example
Input
2
2
1 3
1 4
3
1 5
1 1
2 3
Output
1 2
1 0 2
Note
The example contains 2 tests:
1. During 1-st second, students 1 and 2 come to the queue, and student 1 gets his tea. Student 2 gets his tea during 2-nd second.
2. During 1-st second, students 1 and 2 come to the queue, student 1 gets his tea, and student 2 leaves without tea. During 2-nd second, student 3 comes and gets his tea.
Submitted Solution:
```
t=int(input())
for i in range(t):
n=int(input())
L=[]
res=[]
for j in range(n):
l,r=map(int,input().split())
L.insert(0,(l,r))
sec=L[-1][0]
while len(L)!=0:
tup=L.pop()
if tup[0]<=sec:
if tup[1]>=sec:
res.append(sec)
sec+=1
else:
res.append(0)
else:
sec=tup[0]
res.append(sec)
print(*res)
```
No
| 96,710 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Tags: greedy, sortings
Correct Solution:
```
# python3
from sys import stdin
def main():
def parseints(line): return tuple(map(int, line.split()))
def bdiff(creature): return max(0, creature[0] - creature[1])
n, a, b = parseints(input())
hand = list(map(parseints, stdin.readlines()))
ans = sum(creature[1] for creature in hand) # default damage
if b:
hand.sort(key=bdiff)
best = 0
if n > b:
lost = bdiff(hand[n - b])
for creature in hand[:n-b]:
best = max(best, (creature[0] << a) - creature[1] - lost)
for creature in hand[max(0,n-b):]:
best = max(best, (creature[0] << a) - max(creature))
ans += bdiff(creature)
ans += best
print(ans)
main()
```
| 96,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Tags: greedy, sortings
Correct Solution:
```
# coding=utf-8
from sys import stdin
rd = lambda l: tuple(map(int, l.split()))
n, a, b = rd(input())
b = min(n, b)
s = list(map(rd, stdin.readlines()))
f = lambda x:max(0, x[0]-x[1])
g = lambda x:(x[0]<<a)-x[1]
ans = sum(x[1] for x in s)
mid = 0
if b:
s.sort(key=f, reverse=True)
t = sum(f(x) for x in s[:b] )
for i in range(b):
mid = max(mid, t-f(s[i])+g(s[i]))
for i in range(b, n):
mid = max(mid, t-f(s[b-1])+g(s[i]))
ans += mid
print(ans)
```
| 96,712 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Tags: greedy, sortings
Correct Solution:
```
# python3
from sys import stdin
from collections import namedtuple
def readline(): return tuple(map(int, input().split()))
n, a, b = readline()
hand = [tuple(map(int, line.split())) for line in stdin.readlines()]
if not b:
print(sum(creature[1] for creature in hand))
else:
hand.sort(key=lambda self: self[0] - self[1])
best = 0
if n > b:
l = hand[n - b]
lost = max(0, l[0] - l[1])
for creature in hand[:n-b]:
best = max(best, (creature[0] << a) - creature[1] - lost)
for creature in hand[max(0,n-b):]:
best = max(best, (creature[0] << a) - max(creature))
print(sum(creature[1] for creature in hand)
+ sum(max(0, creature[0] - creature[1]) for creature in hand[max(0,n-b):])
+ best)
```
| 96,713 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Tags: greedy, sortings
Correct Solution:
```
import sys
n, a, b = map(int, sys.stdin.buffer.readline().decode('utf-8').split())
creature = [list(map(int, line.decode('utf-8').split()))
for line in sys.stdin.buffer]
creature.sort(key=lambda x: -x[0]+x[1])
if b == 0:
print(sum(x for _, x in creature))
exit()
base = 0
for i in range(min(n, b)):
base += max(creature[i])
for i in range(min(n, b), n):
base += creature[i][1]
ans = base
mul = 1 << a
for i in range(min(n, b)):
ans = max(
ans,
base - max(creature[i]) + creature[i][0] * mul
)
base = base - max(creature[min(n, b)-1]) + creature[min(n, b)-1][1]
for i in range(min(n, b), n):
ans = max(
ans,
base - creature[i][1] + creature[i][0] * mul
)
print(ans)
```
| 96,714 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Tags: greedy, sortings
Correct Solution:
```
def well_played():
n,a,b = [int(x) for x in input().split()]
p = [(0,0)] * n
b= min(b,n)
for i in range(n):
h,d =[int(x) for x in input().split()]
p[i] =(h,d)
p.sort(key=lambda x:x[0]-x[1],reverse=True)
s=0
for i in range(b):
s+=max(p[i][0],p[i][1])
for i in range(b,n):
s+= p[i][1]
ans = s
for i in range(b):
ans = max(ans,s - max(p[i][0],p[i][1]) + ((p[i][0]) <<a) )
s=s - max(p[b-1][0],p[b-1][1]) + p[b-1][1]
if(b):
for i in range(b,n):
ans= max(ans,s - p[i][1] + ((p[i][0]) <<a) )
print(ans)
well_played()
```
| 96,715 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Tags: greedy, sortings
Correct Solution:
```
import sys
read=lambda:map(int,sys.stdin.buffer.readline().split())
n,a,b=read()
v=[tuple(read()) for _ in range(n)]
ans=0
if b>0:
c=[v[x][0]-v[x][1] for x in range(n)]
w,r=list(range(n)),[0]*n
w.sort(key=lambda x:c[x],reverse=True)
for i in range(n): r[w[i]]=i
f=True;s=0;m=min(n,b)
for i in range(m):
k=c[w[i]]
if k<=0: f=False;m=i;break
s+=k
ans=s
if a>0:
for i in range(n):
k=v[i][0]*(1<<a)-v[i][1]
tmp=s+k
if r[i]<m:
tmp-=c[i]
elif f:
tmp-=c[w[m-1]]
if tmp>ans: ans=tmp
print(sum([v[i][1] for i in range(n)])+ans)
```
| 96,716 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Tags: greedy, sortings
Correct Solution:
```
def main():
n, a, b = map(int, input().split())
arr = [0 for _ in range(n)]
brr = [0 for _ in range(n)]
for i in range(n):
arr[i], brr[i] = map(int,input().split())
p = [i for i in range(n)]
p.sort(key=lambda x: arr[x]-brr[x], reverse=True)
total = 0
for i in range(len(arr)):
if i < b:
total += max(arr[p[i]], brr[p[i]])
else:
total += brr[p[i]]
if b == 0:
print(total)
return
s = total
pp = 1 << a
for i in range(n):
ctotal = s
if i < b:
ctotal -= max(arr[p[i]], brr[p[i]])
ctotal += arr[p[i]] * pp
else:
ctotal -= brr[p[i]]
ctotal += arr[p[i]] * pp
ctotal -= max(arr[p[b-1]], brr[p[b-1]])
ctotal += brr[p[b-1]]
total = max(total, ctotal)
print(total)
main()
```
| 96,717 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Tags: greedy, sortings
Correct Solution:
```
# python3
from sys import stdin
def readline(): return tuple(map(int, input().split()))
def bdiff(creature): return max(0, creature[0] - creature[1])
n, a, b = readline()
hand = [tuple(map(int, line.split())) for line in stdin.readlines()]
ans = sum(creature[1] for creature in hand) # default damage
if b:
hand.sort(key=bdiff)
best = 0
if n > b:
lost = bdiff(hand[n - b])
for creature in hand[:n-b]:
best = max(best, (creature[0] << a) - creature[1] - lost)
for creature in hand[max(0,n-b):]:
best = max(best, (creature[0] << a) - max(creature))
ans += bdiff(creature)
ans += best
print(ans)
```
| 96,718 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Submitted Solution:
```
from sys import stdin
rd = lambda l: tuple(map(int, l.split()))
n, a, b = rd(input())
b = min(b, n)
p = list(map(rd, stdin.readlines()))
f = lambda x: max(0, x[0] - x[1])
g = lambda x: (x[0] << a) - x[1]
s = sum(x[1] for x in p)
e = 0
if b:
p.sort(key=f, reverse=True)
t = sum(f(x) for x in p[:b])
for i in range(b):
e = max(e, t - f(p[i]) + g(p[i]))
for i in range(b, n):
e = max(e, t - f(p[b - 1]) + g(p[i]))
s += e
print(s)
```
Yes
| 96,719 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Submitted Solution:
```
import sys
read=lambda:map(int,sys.stdin.buffer.readline().split())
n,a,b=read()
v=[tuple(read()) for _ in range(n)]
ans=0
if b>0:
c=[v[x][0]-v[x][1] for x in range(n)]
w,r=list(range(n)),[0]*n
w.sort(key=lambda x:c[x],reverse=True)
for i in range(n): r[w[i]]=i
f=True;s=0;m=min(n,b)
for i in range(m):
k=c[w[i]]
if k<=0: f=False;m=i;break
s+=k
ans=s
if a>0:
for i in range(n):
k=v[i][0]*(1<<a)-v[i][1];tmp=s+k
if r[i]<m: tmp-=c[i]
elif f: tmp-=c[w[m-1]]
if tmp>ans: ans=tmp
print(sum([v[i][1] for i in range(n)])+ans)
```
Yes
| 96,720 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Submitted Solution:
```
def main():
n, a, b = map(int, input().split())
arr = []
ind = -1
curr = -10000000000
for i in range(n):
arr.append(list(map(int,input().split())))
if arr[-1][0] * 2 ** a - arr[-1][1] > curr:
ind = i
curr = arr[-1][0] * 2 ** a - arr[-1][1]
arr[ind][0] *= 2 ** a
arr.sort(key=lambda x:-x[0]+x[1])
total = 0
for i in arr:
if b > 0 and i[0] > i[1]:
total += i[0]
b -= 1
else:
total += i[1]
print(total)
main()
```
No
| 96,721 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Submitted Solution:
```
n, a, b=map(int, input().split(' '));
hp=[0]*n;
dmg=[0]*n;
for i in range(n):
hp[i], dmg[i]=map(int, input().split(' '));
sumdmg=sum(dmg);
result=sumdmg;
koef=2**a;
if a>0:
bonusDmg=[max(hp[j]*koef-dmg[j], 0) - max(hp[j]-dmg[j], 0) for j in range(n)];
iMax=0;
maxBonus=0;
for i in range(n):
if bonusDmg[i]>maxBonus:
maxBonus=bonusDmg[i];
iMax=i;
#print(bonusDmg, iMax)
else:
iMax=-1;
#diff - приорст дамага при использовании заклинания
diff=[max(hp[j]-dmg[j], 0) for j in range(n) if j!=iMax];
diff.sort();
if iMax!=-1:
b-=1;
n-=1;
result+=max(hp[iMax]*koef-dmg[iMax], 0);
for j in range(n-1, max(-1, n-b-1), -1):
result+=diff[j];
if diff[j]==0:
break;
print(result);
```
No
| 96,722 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Submitted Solution:
```
import heapq
n,a,b = map(int, input().split())
L = [[0]*2 for i in range(n)]
for i in range(n):
L[i][0],L[i][1] = map(int, input().split())
a = 2**a
if b == 0:
print(sum([x[1] for x in L]))
else:
XX = L[0][0]*a-L[0][1]
XXX = 0
R = []
for i in range(n):
if L[i][0]*a-L[i][1]>XX:
XX = L[i][0]*a-L[i][1]
XXX = i
if L[i][0]>L[i][1]:
R.append(i)
#print(XX,XXX)
if L[XXX][0]*a-L[XXX][1]<=0:
print(sum([x[1] for x in L]))
else:
L[XXX] = [L[XXX][0]*a,L[XXX][0]*a]
b-=1
S = sum([x[1] for x in L])
# L.sort(key=lambda x:x[0]-x[1],reverse=True)
# #print(L)
# i = 0
# while i<b and i<n and L[i][1]<L[i][0]:
# L[i][1] = L[i][0]
# i+=1
# print(sum([x[1] for x in L]))
LL = []
count = 0
#print(R)
for i in R:
if count<b:
heapq.heappush(LL,L[i][0]-L[i][1])
count+=1
else:
heapq.heappushpop(LL,L[i][0]-L[i][1])
print(S+sum(LL))
```
No
| 96,723 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recently Max has got himself into popular CCG "BrainStone". As "BrainStone" is a pretty intellectual game, Max has to solve numerous hard problems during the gameplay. Here is one of them:
Max owns n creatures, i-th of them can be described with two numbers — its health hpi and its damage dmgi. Max also has two types of spells in stock:
1. Doubles health of the creature (hpi := hpi·2);
2. Assigns value of health of the creature to its damage (dmgi := hpi).
Spell of first type can be used no more than a times in total, of the second type — no more than b times in total. Spell can be used on a certain creature multiple times. Spells can be used in arbitrary order. It isn't necessary to use all the spells.
Max is really busy preparing for his final exams, so he asks you to determine what is the maximal total damage of all creatures he can achieve if he uses spells in most optimal way.
Input
The first line contains three integers n, a, b (1 ≤ n ≤ 2·105, 0 ≤ a ≤ 20, 0 ≤ b ≤ 2·105) — the number of creatures, spells of the first type and spells of the second type, respectively.
The i-th of the next n lines contain two number hpi and dmgi (1 ≤ hpi, dmgi ≤ 109) — description of the i-th creature.
Output
Print single integer — maximum total damage creatures can deal.
Examples
Input
2 1 1
10 15
6 1
Output
27
Input
3 0 3
10 8
7 11
5 2
Output
26
Note
In the first example Max should use the spell of the first type on the second creature, then the spell of the second type on the same creature. Then total damage will be equal to 15 + 6·2 = 27.
In the second example Max should use the spell of the second type on the first creature, then the spell of the second type on the third creature. Total damage will be equal to 10 + 11 + 5 = 26.
Submitted Solution:
```
n, a, b=map(int, input().split(' '));
hp=[0]*n;
dmg=[0]*n;
for i in range(n):
hp[i], dmg[i]=map(int, input().split(' '));
sumdmg=sum(dmg);
result=sumdmg;
koef=2**a;
if a>0:
bonusDmg=[max(hp[j]*koef-dmg[j], 0) - max(hp[j]-dmg[j], 0) for j in range(n)];
iMax=0;
maxBonus=0;
for i in range(n):
if bonusDmg[i]>maxBonus:
maxBonus=bonusDmg[i];
iMax=i;
print(bonusDmg, iMax)
else:
iMax=-1;
#diff - приорст дамага при использовании заклинания
diff=[hp[j]-dmg[j] for j in range(n) if j!=iMax and hp[j]-dmg[j]>0];
diff.sort();
if iMax!=-1:
b-=1;
result+=max(hp[iMax]*koef-dmg[iMax], 0);
n=len(diff);
for j in range(n-1, max(-1, n-b-1), -1):
result+=diff[j];
if diff[j]==0:
break;
print(result);
```
No
| 96,724 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Allen dreams of one day owning a enormous fleet of electric cars, the car of the future! He knows that this will give him a big status boost. As Allen is planning out all of the different types of cars he will own and how he will arrange them, he realizes that he has a problem.
Allen's future parking lot can be represented as a rectangle with 4 rows and n (n ≤ 50) columns of rectangular spaces, each of which can contain at most one car at any time. He imagines having k (k ≤ 2n) cars in the grid, and all the cars are initially in the second and third rows. Each of the cars also has a different designated parking space in the first or fourth row. Allen has to put the cars into corresponding parking places.
<image> Illustration to the first example.
However, since Allen would never entrust his cars to anyone else, only one car can be moved at a time. He can drive a car from a space in any of the four cardinal directions to a neighboring empty space. Furthermore, Allen can only move one of his cars into a space on the first or fourth rows if it is the car's designated parking space.
Allen knows he will be a very busy man, and will only have time to move cars at most 20000 times before he realizes that moving cars is not worth his time. Help Allen determine if he should bother parking his cars or leave it to someone less important.
Input
The first line of the input contains two space-separated integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 2n), representing the number of columns and the number of cars, respectively.
The next four lines will contain n integers each between 0 and k inclusive, representing the initial state of the parking lot. The rows are numbered 1 to 4 from top to bottom and the columns are numbered 1 to n from left to right.
In the first and last line, an integer 1 ≤ x ≤ k represents a parking spot assigned to car x (you can only move this car to this place), while the integer 0 represents a empty space (you can't move any car to this place).
In the second and third line, an integer 1 ≤ x ≤ k represents initial position of car x, while the integer 0 represents an empty space (you can move any car to this place).
Each x between 1 and k appears exactly once in the second and third line, and exactly once in the first and fourth line.
Output
If there is a sequence of moves that brings all of the cars to their parking spaces, with at most 20000 car moves, then print m, the number of moves, on the first line. On the following m lines, print the moves (one move per line) in the format i r c, which corresponds to Allen moving car i to the neighboring space at row r and column c.
If it is not possible for Allen to move all the cars to the correct spaces with at most 20000 car moves, print a single line with the integer -1.
Examples
Input
4 5
1 2 0 4
1 2 0 4
5 0 0 3
0 5 0 3
Output
6
1 1 1
2 1 2
4 1 4
3 4 4
5 3 2
5 4 2
Input
1 2
1
2
1
2
Output
-1
Input
1 2
1
1
2
2
Output
2
1 1 1
2 4 1
Note
In the first sample test case, all cars are in front of their spots except car 5, which is in front of the parking spot adjacent. The example shows the shortest possible sequence of moves, but any sequence of length at most 20000 will be accepted.
In the second sample test case, there is only one column, and the cars are in the wrong order, so no cars can move and the task is impossible.
Tags: constructive algorithms, implementation
Correct Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import time
max = 20000
def test(x1, x2, n, s):
for i in range(x1+1, x2+1):
if s[n][i] != 0:
return False
return True
def lastshift(n, s, a):
m = 0
for i in range(n):
if s[1][i] != 0 and s[1][i] == s[0][i]:
s[1][i] = 0
m += 1
a.append([s[0][i], 1, i+1] )
# elif s[2][i] != 0 and s[2][i] == s[0][i] and s[1][i] == 0:
# s[2][i] = 0
# m += 1
# a.append([s[0][i], 2, i+1])
# a.append([s[0][i], 1, i+1])
if s[2][i] != 0 and s[2][i] == s[3][i]:
s[2][i] = 0
m += 1
a.append([s[3][i], 4, i+1])
# elif s[2][i] != 0 and s[1][i] == s[3][i] and s[2][i] == 0:
# s[1][i] = 0
# m += 1
# a.append([s[3][i], 3, i+1])
# a.append([s[3][i], 4, i+1])
return(m)
(n, k) = (int(i) for i in input().split())
s = []
s.append([int(i) for i in input().split()])
s.append([int(i) for i in input().split()])
s.append([int(i) for i in input().split()])
s.append([int(i) for i in input().split()])
start = time.time()
a = []
m = lastshift(n, s, a)
I = -1
z = 0
for i in range(n):
if s[1][i] == 0:
l = 1
I = i
break
if s[2][i] == 0:
l = 2
I = i
break
if I >= 0:
while(m < k):
b = s[1][0]
e = s[2][n-1]
if l == 1:
for i in range(I, n-1):
# print(s[1][i], s[1][i+1])
s[1][i] = s[1][i+1]
# print(s[1][i], s[1][i+1])
if s[1][i+1] != 0:
a.append([s[1][i+1], 2, i+1])
if e!=0:
a.append([e, 2, n])
for i in range(n-1, 0, -1):
s[2][i] = s[2][i-1]
if s[2][i] != 0:
a.append([s[2][i], 3, i+1])
if b!=0:
a.append([b, 3, 1])
for i in range(I-1):
s[1][i] = s[1][i+1]
if s[1][i+1] != 0:
a.append([s[1][i+1], 2, i+1])
s[1][n-1] = e
s[2][0] = b
else:
for i in range(I, 0, -1):
s[2][i] = s[2][i-1]
if s[2][i] != 0:
a.append([s[2][i], 3, i+1])
if b!=0:
a.append([b, 3, 1])
for i in range(n-1):
s[1][i] = s[1][i+1]
if s[1][i] != 0:
a.append([s[1][i], 2, i+1])
if e!=0:
a.append([e, 2, n])
s[1][n-1] = e
s[2][0] = b
for i in range(n-1, I+1, -1):
s[2][i] = s[2][i-1]
if s[2][i] != 0:
a.append([s[2][i], 3, i+1])
I += 2*l-3
if I == -1:
I = 0
l = 2
if I == n:
I = n-1
l = 1
# print(l, I)
s[l][I] = 0
# print(a[z:])
# z = len(a)
# for i in range(4):
# for j in range(n):
# print(s[i][j], end=" ")
# print()
# print()
m += lastshift(n, s, a)
# print(a[z:])
# z = len(a)
# for i in range(4):
# for j in range(n):
# print(s[i][j], end=" ")
# print()
# print()
print(len(a))
for i in range(len(a)):
print(a[i][0], a[i][1], a[i][2])
else:
print(-1)
finish = time.time()
#print(finish - start)
```
| 96,725 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Allen dreams of one day owning a enormous fleet of electric cars, the car of the future! He knows that this will give him a big status boost. As Allen is planning out all of the different types of cars he will own and how he will arrange them, he realizes that he has a problem.
Allen's future parking lot can be represented as a rectangle with 4 rows and n (n ≤ 50) columns of rectangular spaces, each of which can contain at most one car at any time. He imagines having k (k ≤ 2n) cars in the grid, and all the cars are initially in the second and third rows. Each of the cars also has a different designated parking space in the first or fourth row. Allen has to put the cars into corresponding parking places.
<image> Illustration to the first example.
However, since Allen would never entrust his cars to anyone else, only one car can be moved at a time. He can drive a car from a space in any of the four cardinal directions to a neighboring empty space. Furthermore, Allen can only move one of his cars into a space on the first or fourth rows if it is the car's designated parking space.
Allen knows he will be a very busy man, and will only have time to move cars at most 20000 times before he realizes that moving cars is not worth his time. Help Allen determine if he should bother parking his cars or leave it to someone less important.
Input
The first line of the input contains two space-separated integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 2n), representing the number of columns and the number of cars, respectively.
The next four lines will contain n integers each between 0 and k inclusive, representing the initial state of the parking lot. The rows are numbered 1 to 4 from top to bottom and the columns are numbered 1 to n from left to right.
In the first and last line, an integer 1 ≤ x ≤ k represents a parking spot assigned to car x (you can only move this car to this place), while the integer 0 represents a empty space (you can't move any car to this place).
In the second and third line, an integer 1 ≤ x ≤ k represents initial position of car x, while the integer 0 represents an empty space (you can move any car to this place).
Each x between 1 and k appears exactly once in the second and third line, and exactly once in the first and fourth line.
Output
If there is a sequence of moves that brings all of the cars to their parking spaces, with at most 20000 car moves, then print m, the number of moves, on the first line. On the following m lines, print the moves (one move per line) in the format i r c, which corresponds to Allen moving car i to the neighboring space at row r and column c.
If it is not possible for Allen to move all the cars to the correct spaces with at most 20000 car moves, print a single line with the integer -1.
Examples
Input
4 5
1 2 0 4
1 2 0 4
5 0 0 3
0 5 0 3
Output
6
1 1 1
2 1 2
4 1 4
3 4 4
5 3 2
5 4 2
Input
1 2
1
2
1
2
Output
-1
Input
1 2
1
1
2
2
Output
2
1 1 1
2 4 1
Note
In the first sample test case, all cars are in front of their spots except car 5, which is in front of the parking spot adjacent. The example shows the shortest possible sequence of moves, but any sequence of length at most 20000 will be accepted.
In the second sample test case, there is only one column, and the cars are in the wrong order, so no cars can move and the task is impossible.
Tags: constructive algorithms, implementation
Correct Solution:
```
#!/usr/bin/python3
def parknext(N, P, sq, rem):
for i in range(N):
if P[0][i] == P[1][i] and P[0][i] > 0:
sq.append((P[0][i], 1, i + 1))
P[0][i] = P[1][i] = 0
rem[0] -= 1
if P[3][i] == P[2][i] and P[3][i] > 0:
sq.append((P[3][i], 4, i + 1))
P[3][i] = P[2][i] = 0
rem[0] -= 1
def rotnext(N, pos):
c, r = pos
assert r == 1 or r == 2
if r == 1 and c == N - 1:
return (N - 1, 2)
if r == 2 and c == 0:
return (0, 1)
if r == 1:
return (c + 1, r)
return (c - 1, r)
def rot(N, P, sq):
pos = None
for c in range(N):
for r in (1, 2):
# print(P[c][r])
if P[r][c] == 0:
pos = (c, r)
break
if pos is not None:
break
if pos is None:
return False
origpos = pos
prev = pos
cur = rotnext(N, pos)
while cur != origpos:
pc, pr = prev
cc, cr = cur
assert P[pr][pc] == 0
if P[cr][cc] > 0:
sq.append((P[cr][cc], pr + 1, pc + 1))
P[pr][pc] = P[cr][cc]
P[cr][cc] = 0
prev = cur
cur = rotnext(N, cur)
return True
def solve(N, K, P):
sq = []
rem = [K]
parknext(N, P, sq, rem)
while rem[0] > 0:
# print(P)
if not rot(N, P, sq):
return -1
parknext(N, P, sq, rem)
return sq
def main():
N, K = [int(e) for e in input().split(' ')]
P = []
for _ in range(4):
a = [int(e) for e in input().split(' ')]
assert len(a) == N
P.append(a)
ans = solve(N, K, P)
if ans == -1:
print("-1")
else:
print(len(ans))
for l in ans:
print(' '.join(map(str, l)))
if __name__ == '__main__':
main()
```
| 96,726 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Allen dreams of one day owning a enormous fleet of electric cars, the car of the future! He knows that this will give him a big status boost. As Allen is planning out all of the different types of cars he will own and how he will arrange them, he realizes that he has a problem.
Allen's future parking lot can be represented as a rectangle with 4 rows and n (n ≤ 50) columns of rectangular spaces, each of which can contain at most one car at any time. He imagines having k (k ≤ 2n) cars in the grid, and all the cars are initially in the second and third rows. Each of the cars also has a different designated parking space in the first or fourth row. Allen has to put the cars into corresponding parking places.
<image> Illustration to the first example.
However, since Allen would never entrust his cars to anyone else, only one car can be moved at a time. He can drive a car from a space in any of the four cardinal directions to a neighboring empty space. Furthermore, Allen can only move one of his cars into a space on the first or fourth rows if it is the car's designated parking space.
Allen knows he will be a very busy man, and will only have time to move cars at most 20000 times before he realizes that moving cars is not worth his time. Help Allen determine if he should bother parking his cars or leave it to someone less important.
Input
The first line of the input contains two space-separated integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 2n), representing the number of columns and the number of cars, respectively.
The next four lines will contain n integers each between 0 and k inclusive, representing the initial state of the parking lot. The rows are numbered 1 to 4 from top to bottom and the columns are numbered 1 to n from left to right.
In the first and last line, an integer 1 ≤ x ≤ k represents a parking spot assigned to car x (you can only move this car to this place), while the integer 0 represents a empty space (you can't move any car to this place).
In the second and third line, an integer 1 ≤ x ≤ k represents initial position of car x, while the integer 0 represents an empty space (you can move any car to this place).
Each x between 1 and k appears exactly once in the second and third line, and exactly once in the first and fourth line.
Output
If there is a sequence of moves that brings all of the cars to their parking spaces, with at most 20000 car moves, then print m, the number of moves, on the first line. On the following m lines, print the moves (one move per line) in the format i r c, which corresponds to Allen moving car i to the neighboring space at row r and column c.
If it is not possible for Allen to move all the cars to the correct spaces with at most 20000 car moves, print a single line with the integer -1.
Examples
Input
4 5
1 2 0 4
1 2 0 4
5 0 0 3
0 5 0 3
Output
6
1 1 1
2 1 2
4 1 4
3 4 4
5 3 2
5 4 2
Input
1 2
1
2
1
2
Output
-1
Input
1 2
1
1
2
2
Output
2
1 1 1
2 4 1
Note
In the first sample test case, all cars are in front of their spots except car 5, which is in front of the parking spot adjacent. The example shows the shortest possible sequence of moves, but any sequence of length at most 20000 will be accepted.
In the second sample test case, there is only one column, and the cars are in the wrong order, so no cars can move and the task is impossible.
Tags: constructive algorithms, implementation
Correct Solution:
```
all_the_moves = []
parked = 0
n, k = map(int, input().split())
park = []
park += [[int(x) for x in input().split()]]
park += [[int(x) for x in input().split()]]
park += [[int(x) for x in input().split()]]
park += [[int(x) for x in input().split()]]
def add_move(car, r, c):
global all_the_moves
if car == 0:
return
all_the_moves += [(car, r, c)]
def cycle():
if len(park[1]) == 1:
if park[1][0] != 0:
add_move(park[1][0], 2, 0)
park[1][0], park[2][0] = park[2][0], park[1][0]
elif park[2][0] != 0:
add_move(park[2][0], 1, 0)
park[1][0], park[2][0] = park[2][0], park[1][0]
return
if 0 not in park[1]:
i = park[2].index(0)
park[2][i], park[1][i] = park[1][i], park[2][i]
add_move(park[2][i], 2, i)
i = park[1].index(0)
for j in range(i, 0, -1):
add_move(park[1][j - 1], 1, j)
park[1][j], park[1][j - 1] = park[1][j - 1], park[1][j]
add_move(park[2][0], 1, 0)
park[1][0], park[2][0] = park[2][0], park[1][0]
for j in range(n - 1):
add_move(park[2][j + 1], 2, j)
park[2][j], park[2][j + 1] = park[2][j + 1], park[2][j]
if i < n - 1:
add_move(park[1][n - 1], 2, n - 1)
park[1][n - 1], park[2][n - 1] = park[2][n - 1], park[1][n - 1]
for j in range(n - 2, i, -1):
add_move(park[1][j], 1, j + 1)
park[1][j], park[1][j + 1] = park[1][j + 1], park[1][j]
def cars_to_their_places():
global all_the_moves
global parked
for i in range(n):
if park[0][i] != 0 and park[0][i] == park[1][i]:
all_the_moves += [(park[0][i], 0, i)]
park[1][i] = 0
parked += 1
for i in range(n):
if park[3][i] != 0 and park[3][i] == park[2][i]:
all_the_moves += [(park[3][i], 3, i)]
park[2][i] = 0
parked += 1
cars_to_their_places()
if k == 2 * n and parked == 0:
print(-1)
else:
while parked < k:
cycle()
cars_to_their_places()
if len(all_the_moves) <= 2 * 10 ** 4:
print(len(all_the_moves))
for i, r, c in all_the_moves:
print(i, r + 1, c + 1)
else:
print(-1)
```
| 96,727 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Allen dreams of one day owning a enormous fleet of electric cars, the car of the future! He knows that this will give him a big status boost. As Allen is planning out all of the different types of cars he will own and how he will arrange them, he realizes that he has a problem.
Allen's future parking lot can be represented as a rectangle with 4 rows and n (n ≤ 50) columns of rectangular spaces, each of which can contain at most one car at any time. He imagines having k (k ≤ 2n) cars in the grid, and all the cars are initially in the second and third rows. Each of the cars also has a different designated parking space in the first or fourth row. Allen has to put the cars into corresponding parking places.
<image> Illustration to the first example.
However, since Allen would never entrust his cars to anyone else, only one car can be moved at a time. He can drive a car from a space in any of the four cardinal directions to a neighboring empty space. Furthermore, Allen can only move one of his cars into a space on the first or fourth rows if it is the car's designated parking space.
Allen knows he will be a very busy man, and will only have time to move cars at most 20000 times before he realizes that moving cars is not worth his time. Help Allen determine if he should bother parking his cars or leave it to someone less important.
Input
The first line of the input contains two space-separated integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 2n), representing the number of columns and the number of cars, respectively.
The next four lines will contain n integers each between 0 and k inclusive, representing the initial state of the parking lot. The rows are numbered 1 to 4 from top to bottom and the columns are numbered 1 to n from left to right.
In the first and last line, an integer 1 ≤ x ≤ k represents a parking spot assigned to car x (you can only move this car to this place), while the integer 0 represents a empty space (you can't move any car to this place).
In the second and third line, an integer 1 ≤ x ≤ k represents initial position of car x, while the integer 0 represents an empty space (you can move any car to this place).
Each x between 1 and k appears exactly once in the second and third line, and exactly once in the first and fourth line.
Output
If there is a sequence of moves that brings all of the cars to their parking spaces, with at most 20000 car moves, then print m, the number of moves, on the first line. On the following m lines, print the moves (one move per line) in the format i r c, which corresponds to Allen moving car i to the neighboring space at row r and column c.
If it is not possible for Allen to move all the cars to the correct spaces with at most 20000 car moves, print a single line with the integer -1.
Examples
Input
4 5
1 2 0 4
1 2 0 4
5 0 0 3
0 5 0 3
Output
6
1 1 1
2 1 2
4 1 4
3 4 4
5 3 2
5 4 2
Input
1 2
1
2
1
2
Output
-1
Input
1 2
1
1
2
2
Output
2
1 1 1
2 4 1
Note
In the first sample test case, all cars are in front of their spots except car 5, which is in front of the parking spot adjacent. The example shows the shortest possible sequence of moves, but any sequence of length at most 20000 will be accepted.
In the second sample test case, there is only one column, and the cars are in the wrong order, so no cars can move and the task is impossible.
Tags: constructive algorithms, implementation
Correct Solution:
```
n, k = list(map(int, input().split()))
table = []
for row in range(4):
table.append(list(map(int, input().split())))
moves = []
def make_move(start,finish):
moves.append((table[start[0]][start[1]], finish[0]+1, finish[1]+1))
table[finish[0]][finish[1]] = table[start[0]][start[1]]
table[start[0]][start[1]] = 0
def move_all_to_places():
for pos in range(n):
if (table[1][pos] == table[0][pos]) and table[1][pos]:
make_move((1,pos), (0,pos))
if (table[2][pos] == table[3][pos]) and table[2][pos]:
make_move((2,pos), (3,pos))
move_all_to_places()
found = False
for pos in range(n):
if table[1][pos] == 0:
found = True
break
if table[2][pos] == 0:
found = True
break
if not found:
print(-1)
exit()
for cnt in range(20000):
if (table[1][0] != 0) and (table[2][0] == 0) :
make_move((1,0), (2,0)) # moved down
if n == 1:
continue
for pos in range(1,n):
if (table[1][pos-1] == 0) and (table[1][pos] != 0):
make_move((1,pos), (1, pos-1))
move_all_to_places()
if (table[1][n-1] == 0) and (table[2][n-1] != 0) :
make_move((2,n-1), (1,n-1)) # moved up
for pos in range(n-2,-1, -1):
if (table[2][pos+1] == 0) and (table[2][pos] != 0):
make_move((2,pos), (2, pos+1))
move_all_to_places()
if len(moves) > 20000:
print(-1)
exit()
print(len(moves))
for m in moves:
print(*m)
```
| 96,728 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Allen dreams of one day owning a enormous fleet of electric cars, the car of the future! He knows that this will give him a big status boost. As Allen is planning out all of the different types of cars he will own and how he will arrange them, he realizes that he has a problem.
Allen's future parking lot can be represented as a rectangle with 4 rows and n (n ≤ 50) columns of rectangular spaces, each of which can contain at most one car at any time. He imagines having k (k ≤ 2n) cars in the grid, and all the cars are initially in the second and third rows. Each of the cars also has a different designated parking space in the first or fourth row. Allen has to put the cars into corresponding parking places.
<image> Illustration to the first example.
However, since Allen would never entrust his cars to anyone else, only one car can be moved at a time. He can drive a car from a space in any of the four cardinal directions to a neighboring empty space. Furthermore, Allen can only move one of his cars into a space on the first or fourth rows if it is the car's designated parking space.
Allen knows he will be a very busy man, and will only have time to move cars at most 20000 times before he realizes that moving cars is not worth his time. Help Allen determine if he should bother parking his cars or leave it to someone less important.
Input
The first line of the input contains two space-separated integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 2n), representing the number of columns and the number of cars, respectively.
The next four lines will contain n integers each between 0 and k inclusive, representing the initial state of the parking lot. The rows are numbered 1 to 4 from top to bottom and the columns are numbered 1 to n from left to right.
In the first and last line, an integer 1 ≤ x ≤ k represents a parking spot assigned to car x (you can only move this car to this place), while the integer 0 represents a empty space (you can't move any car to this place).
In the second and third line, an integer 1 ≤ x ≤ k represents initial position of car x, while the integer 0 represents an empty space (you can move any car to this place).
Each x between 1 and k appears exactly once in the second and third line, and exactly once in the first and fourth line.
Output
If there is a sequence of moves that brings all of the cars to their parking spaces, with at most 20000 car moves, then print m, the number of moves, on the first line. On the following m lines, print the moves (one move per line) in the format i r c, which corresponds to Allen moving car i to the neighboring space at row r and column c.
If it is not possible for Allen to move all the cars to the correct spaces with at most 20000 car moves, print a single line with the integer -1.
Examples
Input
4 5
1 2 0 4
1 2 0 4
5 0 0 3
0 5 0 3
Output
6
1 1 1
2 1 2
4 1 4
3 4 4
5 3 2
5 4 2
Input
1 2
1
2
1
2
Output
-1
Input
1 2
1
1
2
2
Output
2
1 1 1
2 4 1
Note
In the first sample test case, all cars are in front of their spots except car 5, which is in front of the parking spot adjacent. The example shows the shortest possible sequence of moves, but any sequence of length at most 20000 will be accepted.
In the second sample test case, there is only one column, and the cars are in the wrong order, so no cars can move and the task is impossible.
Tags: constructive algorithms, implementation
Correct Solution:
```
n, k = map(int, input().strip().split())
p = list()
for _ in range(4):
p.append(list(map(int, input().strip().split())))
def find():
for i in range(n):
if p[1][i] != 0 and p[0][i] == p[1][i]:
car = p[1][i]
p[1][i] = 0
return [car, 1, i + 1]
if p[2][i] != 0 and p[3][i] == p[2][i]:
car = p[2][i]
p[2][i] = 0
return [car, 4, i + 1]
return list()
def rotate():
for c in range(n):
if p[1][c] != 0:
nc = c + 1
nr = 1
if nc == n:
nc = n - 1
nr = 2
if p[nr][nc] == 0:
ans.append([p[1][c], nr + 1, nc + 1])
p[nr][nc] = p[1][c]
p[1][c] = 0
return
for c in range(n):
if p[2][c] != 0:
nc = c - 1
nr = 2
if nc == -1:
nc = 0
nr = 1
if p[nr][nc] == 0:
ans.append([p[2][c], nr + 1, nc + 1])
p[nr][nc] = p[2][c]
p[2][c] = 0
return
cnt = 0
ans = list()
while cnt < k:
cur = find()
if len(cur) == 0 and k == 2 * n and cnt == 0:
print(-1)
exit(0)
if cur:
ans.append(cur)
cnt += 1
# print(p)
rotate()
# print(p)
print(len(ans))
for e in ans:
print(' '.join(map(str, e)))
```
| 96,729 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Allen dreams of one day owning a enormous fleet of electric cars, the car of the future! He knows that this will give him a big status boost. As Allen is planning out all of the different types of cars he will own and how he will arrange them, he realizes that he has a problem.
Allen's future parking lot can be represented as a rectangle with 4 rows and n (n ≤ 50) columns of rectangular spaces, each of which can contain at most one car at any time. He imagines having k (k ≤ 2n) cars in the grid, and all the cars are initially in the second and third rows. Each of the cars also has a different designated parking space in the first or fourth row. Allen has to put the cars into corresponding parking places.
<image> Illustration to the first example.
However, since Allen would never entrust his cars to anyone else, only one car can be moved at a time. He can drive a car from a space in any of the four cardinal directions to a neighboring empty space. Furthermore, Allen can only move one of his cars into a space on the first or fourth rows if it is the car's designated parking space.
Allen knows he will be a very busy man, and will only have time to move cars at most 20000 times before he realizes that moving cars is not worth his time. Help Allen determine if he should bother parking his cars or leave it to someone less important.
Input
The first line of the input contains two space-separated integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 2n), representing the number of columns and the number of cars, respectively.
The next four lines will contain n integers each between 0 and k inclusive, representing the initial state of the parking lot. The rows are numbered 1 to 4 from top to bottom and the columns are numbered 1 to n from left to right.
In the first and last line, an integer 1 ≤ x ≤ k represents a parking spot assigned to car x (you can only move this car to this place), while the integer 0 represents a empty space (you can't move any car to this place).
In the second and third line, an integer 1 ≤ x ≤ k represents initial position of car x, while the integer 0 represents an empty space (you can move any car to this place).
Each x between 1 and k appears exactly once in the second and third line, and exactly once in the first and fourth line.
Output
If there is a sequence of moves that brings all of the cars to their parking spaces, with at most 20000 car moves, then print m, the number of moves, on the first line. On the following m lines, print the moves (one move per line) in the format i r c, which corresponds to Allen moving car i to the neighboring space at row r and column c.
If it is not possible for Allen to move all the cars to the correct spaces with at most 20000 car moves, print a single line with the integer -1.
Examples
Input
4 5
1 2 0 4
1 2 0 4
5 0 0 3
0 5 0 3
Output
6
1 1 1
2 1 2
4 1 4
3 4 4
5 3 2
5 4 2
Input
1 2
1
2
1
2
Output
-1
Input
1 2
1
1
2
2
Output
2
1 1 1
2 4 1
Note
In the first sample test case, all cars are in front of their spots except car 5, which is in front of the parking spot adjacent. The example shows the shortest possible sequence of moves, but any sequence of length at most 20000 will be accepted.
In the second sample test case, there is only one column, and the cars are in the wrong order, so no cars can move and the task is impossible.
Tags: constructive algorithms, implementation
Correct Solution:
```
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
sys.setrecursionlimit(10000)
def read_int():
return int(input())
def read_int_n():
return list(map(int, input().split()))
def read_float():
return float(input())
def read_float_n():
return list(map(float, input().split()))
def read_str():
return input()
def read_str_n():
return list(map(str, input().split()))
def error_print(*args):
print(*args, file=sys.stderr)
def mt(f):
import time
def wrap(*args, **kwargs):
s = time.time()
ret = f(*args, **kwargs)
e = time.time()
error_print(e - s, 'sec')
return ret
return wrap
@mt
def slv(N, K, S):
error_print('------')
for s in S:
error_print(s)
ans = []
for i, (p, c) in enumerate(zip(S[0], S[1])):
if c != 0 and p == c:
ans.append((c , 1, i+1))
S[1][i] = 0
for i, (p, c) in enumerate(zip(S[3], S[2])):
if c != 0 and p == c:
ans.append((c , 4, i+1))
S[2][i] = 0
while len(ans) <= 20000 and sum(S[1]) + sum(S[2]) != 0:
error_print('------')
m = len(ans)
for s in S:
error_print(s)
S1 = [c for c in S[1]]
S2 = [c for c in S[2]]
for i in range(N):
c = S[1][i]
if i == 0:
if c != 0 and S[2][0] == 0:
ans.append((c, 3, i+1))
S1[i] = 0
S2[i] = c
else:
if c != 0 and S[1][i-1] == 0:
ans.append((c, 2, i))
S1[i] = 0
S1[i-1] = c
for i in range(0, N)[::-1]:
c = S[2][i]
if i == N-1:
if c != 0 and S[1][i] == 0:
ans.append((c, 2, i+1))
S2[i] = 0
S1[i] = c
else:
if c != 0 and S[2][i+1] == 0:
ans.append((c, 3, i+2))
S2[i] = 0
S2[i+1] = c
S[1] = S1
S[2] = S2
for i, (p, c) in enumerate(zip(S[0], S[1])):
if c != 0 and p == c:
ans.append((c , 1, i+1))
S[1][i] = 0
for i, (p, c) in enumerate(zip(S[3], S[2])):
if c != 0 and p == c:
ans.append((c , 4, i+1))
S[2][i] = 0
if len(ans) == m:
break
if len(ans) > 20000:
return -1
if sum(S[1]) + sum(S[2]) != 0:
return -1
error_print('------')
for s in S:
error_print(s)
return str(len(ans)) + '\n' + '\n'.join(map(lambda x: ' '.join(map(str, x)), ans))
def main():
N, K = read_int_n()
S = [read_int_n() for _ in range(4)]
print(slv(N, K, S))
if __name__ == '__main__':
main()
```
| 96,730 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Allen dreams of one day owning a enormous fleet of electric cars, the car of the future! He knows that this will give him a big status boost. As Allen is planning out all of the different types of cars he will own and how he will arrange them, he realizes that he has a problem.
Allen's future parking lot can be represented as a rectangle with 4 rows and n (n ≤ 50) columns of rectangular spaces, each of which can contain at most one car at any time. He imagines having k (k ≤ 2n) cars in the grid, and all the cars are initially in the second and third rows. Each of the cars also has a different designated parking space in the first or fourth row. Allen has to put the cars into corresponding parking places.
<image> Illustration to the first example.
However, since Allen would never entrust his cars to anyone else, only one car can be moved at a time. He can drive a car from a space in any of the four cardinal directions to a neighboring empty space. Furthermore, Allen can only move one of his cars into a space on the first or fourth rows if it is the car's designated parking space.
Allen knows he will be a very busy man, and will only have time to move cars at most 20000 times before he realizes that moving cars is not worth his time. Help Allen determine if he should bother parking his cars or leave it to someone less important.
Input
The first line of the input contains two space-separated integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 2n), representing the number of columns and the number of cars, respectively.
The next four lines will contain n integers each between 0 and k inclusive, representing the initial state of the parking lot. The rows are numbered 1 to 4 from top to bottom and the columns are numbered 1 to n from left to right.
In the first and last line, an integer 1 ≤ x ≤ k represents a parking spot assigned to car x (you can only move this car to this place), while the integer 0 represents a empty space (you can't move any car to this place).
In the second and third line, an integer 1 ≤ x ≤ k represents initial position of car x, while the integer 0 represents an empty space (you can move any car to this place).
Each x between 1 and k appears exactly once in the second and third line, and exactly once in the first and fourth line.
Output
If there is a sequence of moves that brings all of the cars to their parking spaces, with at most 20000 car moves, then print m, the number of moves, on the first line. On the following m lines, print the moves (one move per line) in the format i r c, which corresponds to Allen moving car i to the neighboring space at row r and column c.
If it is not possible for Allen to move all the cars to the correct spaces with at most 20000 car moves, print a single line with the integer -1.
Examples
Input
4 5
1 2 0 4
1 2 0 4
5 0 0 3
0 5 0 3
Output
6
1 1 1
2 1 2
4 1 4
3 4 4
5 3 2
5 4 2
Input
1 2
1
2
1
2
Output
-1
Input
1 2
1
1
2
2
Output
2
1 1 1
2 4 1
Note
In the first sample test case, all cars are in front of their spots except car 5, which is in front of the parking spot adjacent. The example shows the shortest possible sequence of moves, but any sequence of length at most 20000 will be accepted.
In the second sample test case, there is only one column, and the cars are in the wrong order, so no cars can move and the task is impossible.
Submitted Solution:
```
#!/usr/bin/python3
def parknext(N, P, sq, rem):
for i in range(N):
if P[0][i] == P[1][i] and P[0][i] > 0:
sq.append((P[0][i], 1, i + 1))
P[0][i] = P[1][i] = 0
rem[0] -= 1
if P[3][i] == P[2][i] and P[3][i] > 0:
sq.append((P[3][i], 4, i + 1))
P[3][i] = P[2][i] = 0
rem[0] -= 1
def rotnext(N, pos):
c, r = pos
assert r == 1 or r == 2
if r == 1 and c == N - 1:
return (N - 1, 2)
if r == 2 and c == 0:
return (0, 1)
if r == 1:
return (c + 1, r)
return (c - 1, r)
def rot(N, P, sq):
pos = None
for c in range(N):
for r in (1, 2):
if P[r][c] == 0:
pos = (c, r)
break
if pos is not None:
break
if pos is None:
return False
origpos = pos
prev = pos
cur = rotnext(N, pos)
while cur != origpos:
pc, pr = prev
cc, cr = cur
assert P[pr][pc] == 0
if P[cr][cc] > 0:
sq.append((P[cr][cc], pr + 1, pc + 1))
P[pr][pc] = P[cr][cc]
P[cr][cc] = 0
prev = cur
cur = rotnext(N, cur)
return True
def solve(N, K, P):
sq = []
rem = [K]
parknext(N, P, sq, rem)
while rem[0] > 0:
if not rot(N, P, sq):
return -1
parknext(N, P, sq, rem)
return sq
def main():
N, K = [int(e) for e in input().split(' ')]
P = []
for _ in range(4):
a = [int(e) for e in input().split(' ')]
assert len(a) == N
P.append(a)
ans = solve(N, K, P)
if ans == -1:
print("-1")
else:
for l in ans:
print(' '.join(map(str, l)))
if __name__ == '__main__':
main()
```
No
| 96,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Allen dreams of one day owning a enormous fleet of electric cars, the car of the future! He knows that this will give him a big status boost. As Allen is planning out all of the different types of cars he will own and how he will arrange them, he realizes that he has a problem.
Allen's future parking lot can be represented as a rectangle with 4 rows and n (n ≤ 50) columns of rectangular spaces, each of which can contain at most one car at any time. He imagines having k (k ≤ 2n) cars in the grid, and all the cars are initially in the second and third rows. Each of the cars also has a different designated parking space in the first or fourth row. Allen has to put the cars into corresponding parking places.
<image> Illustration to the first example.
However, since Allen would never entrust his cars to anyone else, only one car can be moved at a time. He can drive a car from a space in any of the four cardinal directions to a neighboring empty space. Furthermore, Allen can only move one of his cars into a space on the first or fourth rows if it is the car's designated parking space.
Allen knows he will be a very busy man, and will only have time to move cars at most 20000 times before he realizes that moving cars is not worth his time. Help Allen determine if he should bother parking his cars or leave it to someone less important.
Input
The first line of the input contains two space-separated integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 2n), representing the number of columns and the number of cars, respectively.
The next four lines will contain n integers each between 0 and k inclusive, representing the initial state of the parking lot. The rows are numbered 1 to 4 from top to bottom and the columns are numbered 1 to n from left to right.
In the first and last line, an integer 1 ≤ x ≤ k represents a parking spot assigned to car x (you can only move this car to this place), while the integer 0 represents a empty space (you can't move any car to this place).
In the second and third line, an integer 1 ≤ x ≤ k represents initial position of car x, while the integer 0 represents an empty space (you can move any car to this place).
Each x between 1 and k appears exactly once in the second and third line, and exactly once in the first and fourth line.
Output
If there is a sequence of moves that brings all of the cars to their parking spaces, with at most 20000 car moves, then print m, the number of moves, on the first line. On the following m lines, print the moves (one move per line) in the format i r c, which corresponds to Allen moving car i to the neighboring space at row r and column c.
If it is not possible for Allen to move all the cars to the correct spaces with at most 20000 car moves, print a single line with the integer -1.
Examples
Input
4 5
1 2 0 4
1 2 0 4
5 0 0 3
0 5 0 3
Output
6
1 1 1
2 1 2
4 1 4
3 4 4
5 3 2
5 4 2
Input
1 2
1
2
1
2
Output
-1
Input
1 2
1
1
2
2
Output
2
1 1 1
2 4 1
Note
In the first sample test case, all cars are in front of their spots except car 5, which is in front of the parking spot adjacent. The example shows the shortest possible sequence of moves, but any sequence of length at most 20000 will be accepted.
In the second sample test case, there is only one column, and the cars are in the wrong order, so no cars can move and the task is impossible.
Submitted Solution:
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import time
max = 20000
def test(x1, x2, n, s):
for i in range(x1+1, x2+1):
if s[n][i] != 0:
return False
return True
def lastshift(n, s, a):
m = 0
for i in range(n):
if s[1][i] != 0 and s[1][i] == s[0][i]:
s[1][i] = 0
m += 1
a.append([s[0][i], 1, i+1] )
elif s[2][i] != 0 and s[2][i] == s[0][i] and s[1][i] == 0:
s[2][i] = 0
m += 1
a.append([s[0][i], 2, i+1])
a.append([s[0][i], 1, i+1])
if s[2][i] != 0 and s[2][i] == s[3][i]:
s[2][i] = 0
m += 1
a.append([s[3][i], 4, i+1])
elif s[2][i] != 0 and s[1][i] == s[3][i] and s[2][i] == 0:
s[1][i] = 0
m += 1
a.append([s[3][i], 3, i+1])
a.append([s[3][i], 4, i+1])
return(m)
(n, k) = (int(i) for i in input().split())
s = []
s.append([int(i) for i in input().split()])
s.append([int(i) for i in input().split()])
s.append([int(i) for i in input().split()])
s.append([int(i) for i in input().split()])
start = time.time()
a = []
m = lastshift(n, s, a)
I = -1
for i in range(n):
if s[1][i] == 0:
l = 1
I = i
break
if s[2][i] == 0:
l = 2
I = i
break
if I >= 0:
while(m < k):
b = s[1][0]
e = s[2][n-1]
if l == 1:
for i in range(I, n-1):
s[1][i] = s[1][i+1]
if s[1][i+1] != 0:
a.append([s[1][i+1], 2, i+1])
if b!=0:
a.append([b, 3, 1])
for i in range(n-1, 0, -1):
s[2][i] = s[2][i-1]
if s[2][i] != 0:
a.append([s[2][i], 3, i+1])
if e!=0:
a.append([e, 2, n])
for i in range(I):
s[1][i] = s[1][i+1]
if s[1][i+1] != 0:
a.append([s[1][i+1], 2, i+1])
s[1][n-1] = e
s[2][0] = b
else:
for i in range(I, 0, -1):
s[2][i] = s[2][i-1]
if s[2][i] != 0:
a.append([s[2][i], 3, i+1])
if b!=0:
a.append([b, 3, 1])
for i in range(n-1):
s[1][i] = s[1][i+1]
if s[1][i] != 0:
a.append([s[1][i], 2, i+1])
if e!=0:
a.append([e, 2, n])
for i in range(n-1, I, -1):
s[2][i] = s[2][i-1]
if s[2][i] != 0:
a.append([s[2][i], 3, i+1])
s[1][n-1] = e
s[2][0] = b
I += 2*l-3
if I == -1:
I = 0
l = 2
if I == n:
I = n-1
l = 1
s[l][I] = 0
# print()
# for i in range(4):
# for j in range(n):
# print(s[i][j], end=" ")
# print()
# print()
m += lastshift(n, s, a)
print(len(a))
for i in range(len(a)):
print(a[i][0], a[i][1], a[i][2])
else:
print(-1)
finish = time.time()
#print(finish - start)
```
No
| 96,732 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Allen dreams of one day owning a enormous fleet of electric cars, the car of the future! He knows that this will give him a big status boost. As Allen is planning out all of the different types of cars he will own and how he will arrange them, he realizes that he has a problem.
Allen's future parking lot can be represented as a rectangle with 4 rows and n (n ≤ 50) columns of rectangular spaces, each of which can contain at most one car at any time. He imagines having k (k ≤ 2n) cars in the grid, and all the cars are initially in the second and third rows. Each of the cars also has a different designated parking space in the first or fourth row. Allen has to put the cars into corresponding parking places.
<image> Illustration to the first example.
However, since Allen would never entrust his cars to anyone else, only one car can be moved at a time. He can drive a car from a space in any of the four cardinal directions to a neighboring empty space. Furthermore, Allen can only move one of his cars into a space on the first or fourth rows if it is the car's designated parking space.
Allen knows he will be a very busy man, and will only have time to move cars at most 20000 times before he realizes that moving cars is not worth his time. Help Allen determine if he should bother parking his cars or leave it to someone less important.
Input
The first line of the input contains two space-separated integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 2n), representing the number of columns and the number of cars, respectively.
The next four lines will contain n integers each between 0 and k inclusive, representing the initial state of the parking lot. The rows are numbered 1 to 4 from top to bottom and the columns are numbered 1 to n from left to right.
In the first and last line, an integer 1 ≤ x ≤ k represents a parking spot assigned to car x (you can only move this car to this place), while the integer 0 represents a empty space (you can't move any car to this place).
In the second and third line, an integer 1 ≤ x ≤ k represents initial position of car x, while the integer 0 represents an empty space (you can move any car to this place).
Each x between 1 and k appears exactly once in the second and third line, and exactly once in the first and fourth line.
Output
If there is a sequence of moves that brings all of the cars to their parking spaces, with at most 20000 car moves, then print m, the number of moves, on the first line. On the following m lines, print the moves (one move per line) in the format i r c, which corresponds to Allen moving car i to the neighboring space at row r and column c.
If it is not possible for Allen to move all the cars to the correct spaces with at most 20000 car moves, print a single line with the integer -1.
Examples
Input
4 5
1 2 0 4
1 2 0 4
5 0 0 3
0 5 0 3
Output
6
1 1 1
2 1 2
4 1 4
3 4 4
5 3 2
5 4 2
Input
1 2
1
2
1
2
Output
-1
Input
1 2
1
1
2
2
Output
2
1 1 1
2 4 1
Note
In the first sample test case, all cars are in front of their spots except car 5, which is in front of the parking spot adjacent. The example shows the shortest possible sequence of moves, but any sequence of length at most 20000 will be accepted.
In the second sample test case, there is only one column, and the cars are in the wrong order, so no cars can move and the task is impossible.
Submitted Solution:
```
"""
http://codeforces.com/contest/996/problem/C
"""
class CarAlgorithm:
def __init__(self, n, k, parking):
self.n = n
self.k = k
self.parking = parking
self._step_count = 0
self._steps = []
self._done = False
for i in range(4):
assert len(parking[i]) == n, "%s != %s" % (len(parking[i]), n)
def do(self):
"""
1) загоянем все тривиальные машины
2) ищем пробел (если нет, то нет решения)
3) для каждой машины рассчитываем минимальной путь до парковки
4) выбираем машину с минимальным расстоянием до парковки
"""
if self._done:
return self._steps
self._done = True
n, k, parking = self.n, self.k, self.parking
car_target_cells = {}
# solve trivial cars
for park_str, car_str in [(0, 1), (3, 2)]:
for i in range(n):
car_number = parking[park_str][i]
if car_number == 0:
continue
elif parking[car_str][i] == car_number:
self.move_car(parking, car_str, i, park_str, i)
else:
car_target_cells[car_number] = (park_str, i)
# car_number = parking[3][i]
# if car_number == 0:
# continue
# elif parking[2][i] == car_number:
# self.move_car(parking, 2, i, 3, i)
# else:
# car_target_cells[car_number] = (3, i)
# print(car_target_cells)
while True:
# find shortest path for all cars
# choose car with minimal shortest path
# find free cell
target_shortest_path = None
target_car_cell = None
target_dst_str, target_dst_col = None, None
free_cell = None
for j in range(1, 3):
for i in range(n):
if parking[j][i] == 0:
if free_cell and target_car_cell and \
abs(target_car_cell[0] - j) >= abs(target_car_cell[0] - free_cell[0]):
continue
free_cell = j, i
else:
cur_car = parking[j][i]
target_str, target_col = car_target_cells[cur_car]
cur_shortest_path = find_path(j, i, target_str, target_col)
if target_shortest_path is None or len(cur_shortest_path) < len(target_shortest_path):
target_shortest_path = cur_shortest_path
target_car_cell = j, i
target_dst_str, target_dst_col = target_str, target_col
if target_shortest_path is None:
# car is on the road is not found
return self._steps
# move car to cell before dst cell
car_cell_str, car_cell_col = target_car_cell
for path_next_cell_str, path_next_cell_col in target_shortest_path:
if parking[path_next_cell_str][path_next_cell_col] != 0:
# move free cell to next cell from path
if not free_cell:
self._step_count = -1
return self._step_count
free_cell_str, free_cell_col = free_cell
if free_cell_str < car_cell_str < path_next_cell_str or path_next_cell_col < car_cell_str < free_cell_str:
# .****сx or xc****.
# |_____| |_____|
if free_cell_str == 1:
if parking[2][free_cell_col] != 0:
self.move_car(parking, 2, free_cell_col, 1, free_cell_col)
free_cell_str = 2
else: # free_cell_str == 2
self.move_car(parking, 1, free_cell_col, 2, free_cell_col)
free_cell_str = 1
free_cell_step = 1 if free_cell_col < path_next_cell_col else -1
for _ in range(free_cell_col, path_next_cell_col, free_cell_step):
next_col = free_cell_col + 1
if parking[free_cell_str][next_col] != 0:
self.move_car(parking, free_cell_str, next_col, free_cell_str, free_cell_col)
free_cell_col += free_cell_step
if (free_cell_str, path_next_cell_str) in [(1, 2), (2, 1)]:
self.move_car(parking, path_next_cell_str, path_next_cell_col, free_cell_str, free_cell_col)
free_cell = path_next_cell_str, path_next_cell_col
self.move_car(parking, car_cell_str, car_cell_col, path_next_cell_str, path_next_cell_col)
car_cell_str, car_cell_col = path_next_cell_str, path_next_cell_col
self.move_car(parking, car_cell_str, car_cell_col, target_dst_str, target_dst_col)
def move_car(self, parking, from_str, from_col, to_str, to_col):
car_number = parking[from_str][from_col]
# print("%s %s %s" % (car_number, to_str, to_col))
self._steps.append((car_number, to_str+1, to_col+1))
# print("%s %s %s" % (car_number, to_str+1, to_col+1))
# print("%s %s %s %s" % (car_number, to_str+1, to_col+1, parking))
parking[to_str][to_col] = parking[from_str][from_col]
parking[from_str][from_col] = 0
self._step_count += 1
def find_path(from_str, from_col, to_str, to_col):
"""
return internal path between from_cell and to_cell (borders are not included)
"""
str_direct = 1 if from_col < to_col else -1
path = [
(from_str, i) for i in range(
from_col + str_direct, to_col + str_direct, str_direct
)
]
if from_str == 1 and to_str == 3:
path.append((2, to_col))
elif from_str == 2 and to_str == 0:
path.append((1, to_col))
# col_direct = 1 if from_str < to_str else -1
# path.extend([
# (i, to_col) for i in range(
# from_str + col_direct, to_str + col_direct, col_direct
# )
# ])
# print(from_str, from_col, path)
return path
def test():
assert find_path(*(1,0), *(0,0)) == [], find_path(*(1,0), *(0,0))
assert find_path(*(1,0), *(0,1)) == [(1,1)]
assert find_path(*(1,0), *(0,1)) == [(1,1)]
assert find_path(*(2,0), *(0,1)) == [(2,1), (1,1)]
assert find_path(*(1,0), *(3,0)) == [(2,0)], find_path(*(1,0), *(3,0))
a = CarAlgorithm(4, 5, [[1, 2, 0, 4,], [1, 2, 0, 4,], [5, 0, 0, 3,], [0, 5, 0, 3,]])
assert a.do() == 6, a.do()
a = CarAlgorithm(1, 2, [[1], [2], [1], [2]])
assert a.do() == -1, a.do()
a = CarAlgorithm(1, 2, [[1], [1], [2], [2]])
assert a.do() == 2, a.do()
a = CarAlgorithm(50, 99, [
[i for i in range(50)],
[i for i in range(75, 100)] + [i for i in range(50, 75)],
[i for i in range(25, 50)] + [i for i in range(25)],
[i for i in range(50, 100)]
])
# print(a.parking)
assert a.do() == 2, a.do()
def do():
n, k = [int(str_i) for str_i in input().split()]
p = [
[int(str_i) for str_i in input().split()]
for _ in range(4)
]
steps = CarAlgorithm(n, k, p).do()
if steps == -1:
print(-1)
else:
print(len(steps))
for s in steps:
print("%s %s %s" % s)
# test()
do()
```
No
| 96,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Allen dreams of one day owning a enormous fleet of electric cars, the car of the future! He knows that this will give him a big status boost. As Allen is planning out all of the different types of cars he will own and how he will arrange them, he realizes that he has a problem.
Allen's future parking lot can be represented as a rectangle with 4 rows and n (n ≤ 50) columns of rectangular spaces, each of which can contain at most one car at any time. He imagines having k (k ≤ 2n) cars in the grid, and all the cars are initially in the second and third rows. Each of the cars also has a different designated parking space in the first or fourth row. Allen has to put the cars into corresponding parking places.
<image> Illustration to the first example.
However, since Allen would never entrust his cars to anyone else, only one car can be moved at a time. He can drive a car from a space in any of the four cardinal directions to a neighboring empty space. Furthermore, Allen can only move one of his cars into a space on the first or fourth rows if it is the car's designated parking space.
Allen knows he will be a very busy man, and will only have time to move cars at most 20000 times before he realizes that moving cars is not worth his time. Help Allen determine if he should bother parking his cars or leave it to someone less important.
Input
The first line of the input contains two space-separated integers n and k (1 ≤ n ≤ 50, 1 ≤ k ≤ 2n), representing the number of columns and the number of cars, respectively.
The next four lines will contain n integers each between 0 and k inclusive, representing the initial state of the parking lot. The rows are numbered 1 to 4 from top to bottom and the columns are numbered 1 to n from left to right.
In the first and last line, an integer 1 ≤ x ≤ k represents a parking spot assigned to car x (you can only move this car to this place), while the integer 0 represents a empty space (you can't move any car to this place).
In the second and third line, an integer 1 ≤ x ≤ k represents initial position of car x, while the integer 0 represents an empty space (you can move any car to this place).
Each x between 1 and k appears exactly once in the second and third line, and exactly once in the first and fourth line.
Output
If there is a sequence of moves that brings all of the cars to their parking spaces, with at most 20000 car moves, then print m, the number of moves, on the first line. On the following m lines, print the moves (one move per line) in the format i r c, which corresponds to Allen moving car i to the neighboring space at row r and column c.
If it is not possible for Allen to move all the cars to the correct spaces with at most 20000 car moves, print a single line with the integer -1.
Examples
Input
4 5
1 2 0 4
1 2 0 4
5 0 0 3
0 5 0 3
Output
6
1 1 1
2 1 2
4 1 4
3 4 4
5 3 2
5 4 2
Input
1 2
1
2
1
2
Output
-1
Input
1 2
1
1
2
2
Output
2
1 1 1
2 4 1
Note
In the first sample test case, all cars are in front of their spots except car 5, which is in front of the parking spot adjacent. The example shows the shortest possible sequence of moves, but any sequence of length at most 20000 will be accepted.
In the second sample test case, there is only one column, and the cars are in the wrong order, so no cars can move and the task is impossible.
Submitted Solution:
```
n, k = list(map(int, input().split()))
table = []
for row in range(4):
table.append(list(map(int, input().split())))
moves = []
def make_move(start,finish):
moves.append((table[start[0]][start[1]], finish[0]+1, finish[1]+1))
table[finish[0]][finish[1]] = table[start[0]][start[1]]
table[start[0]][start[1]] = 0
def move_all_to_places():
for pos in range(n):
if (table[1][pos] == table[0][pos]) and table[1][pos]:
make_move((1,pos), (0,pos))
if (table[2][pos] == table[3][pos]) and table[2][pos]:
make_move((2,pos), (3,pos))
move_all_to_places()
found = False
for pos in range(n):
if table[1][pos] == 0:
found = True
break
if table[2][pos] == 0:
found = True
break
if not found:
print(-1)
exit()
for cnt in range(20000):
if (table[1][0] != 0) and (table[2][0] == 0) :
make_move((1,0), (2,0)) # moved down
for pos in range(1,n):
if (table[1][pos-1] == 0) and (table[1][pos] != 0):
make_move((1,pos), (1, pos-1))
if (table[1][n-1] == 0) and (table[2][n-1] != 0) :
make_move((2,n-1), (1,n-1)) # moved up
for pos in range(n-2,-1, -1):
if (table[2][pos+1] == 0) and (table[2][pos] != 0):
make_move((2,pos), (2, pos+1))
move_all_to_places()
print(len(moves))
for m in moves:
print(*m)
```
No
| 96,734 |
Provide a correct Python 3 solution for this coding contest problem.
Given are N pairwise distinct non-negative integers A_1,A_2,\ldots,A_N. Find the number of ways to choose a set of between 1 and K numbers (inclusive) from the given numbers so that the following two conditions are satisfied:
* The bitwise AND of the chosen numbers is S.
* The bitwise OR of the chosen numbers is T.
Constraints
* 1 \leq N \leq 50
* 1 \leq K \leq N
* 0 \leq A_i < 2^{18}
* 0 \leq S < 2^{18}
* 0 \leq T < 2^{18}
* A_i \neq A_j (1 \leq i < j \leq N)
Input
Input is given from Standard Input in the following format:
N K S T
A_1 A_2 ... A_N
Output
Print the answer.
Examples
Input
3 3 0 3
1 2 3
Output
2
Input
5 3 1 7
3 4 9 1 5
Output
2
Input
5 4 0 15
3 4 9 1 5
Output
3
"Correct Solution:
```
import sys
readline = sys.stdin.readline
def popcount(i):
i = i - ((i >> 1) & 0x55555555)
i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
return (((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) & 0xffffffff) >> 24
Jm = 18
MOD = 10**18+3
def frac(limit):
frac = [1]*limit
for i in range(2,limit):
frac[i] = i * frac[i-1]%MOD
fraci = [None]*limit
fraci[-1] = pow(frac[-1], MOD -2, MOD)
for i in range(-2, -limit-1, -1):
fraci[i] = fraci[i+1] * (limit + i + 1) % MOD
return frac, fraci
frac, fraci = frac(100)
def comb(a, b):
if not a >= b >= 0:
return 0
return frac[a]*fraci[b]*fraci[a-b]%MOD
PP = (1<<32) - 1
def popcount64(x):
return popcount(PP&x) + popcount(x>>32)
N, K, S, T = map(int, readline().split())
lim = 60
calc = [0]*lim
for n in range(lim):
for j in range(K):
calc[n] += comb(n, j)
A = list(map(int, readline().split()))
ans = 1
table = [-1]*Jm
for i in range(Jm):
si = S&(1<<i)
ti = T&(1<<i)
if si and ti:
table[i] = 1
continue
if si and not ti:
ans = 0
break
if not si and not ti:
table[i] = 0
continue
if not ans:
print(ans)
else:
ans = 0
B = []
for idx in range(N):
for i in range(Jm):
if table[i] == 1:
if not (A[idx] & (1<<i)):
break
if table[i] == 0:
if (A[idx] & (1<<i)):
break
else:
res = 0
cnt = -1
ctr = 0
for i in range(Jm):
if table[i] == -1:
ctr += 1
cnt += 1
if A[idx] & (1<<i):
res |= (1<<cnt)
B.append(res)
Jm = ctr
L = len(B)
JJ = (1<<L)-1
G = [[0]*L for _ in range(Jm)]
for i in range(Jm):
for idx in range(L):
res = 0
for jdx in range(idx+1, L):
if (1<<i) & B[idx] == (1<<i) & B[jdx]:
res |= 1<<jdx
G[i][idx] = res
H = [[0]*L for _ in range(1<<Jm)]
for i in range(L):
H[0][i] = JJ
ans = 0
for k in range(1, K+1):
ans += comb(L, k)
#print(B, ans)
for U in range(1, 1<<Jm):
R = []
res = 0
K = -U&U
Uk = U^K
for idx in range(L):
H[U][idx] = H[Uk][idx] & G[K.bit_length()-1][idx]
cnt = H[U][idx]
res += calc[popcount64(cnt)]
#print(U, (-1 if len(R)&1 else 1)*res)
ans += (-1 if popcount(U)&1 else 1)*res
print(ans)
```
| 96,735 |
Provide a correct Python 3 solution for this coding contest problem.
Given are N pairwise distinct non-negative integers A_1,A_2,\ldots,A_N. Find the number of ways to choose a set of between 1 and K numbers (inclusive) from the given numbers so that the following two conditions are satisfied:
* The bitwise AND of the chosen numbers is S.
* The bitwise OR of the chosen numbers is T.
Constraints
* 1 \leq N \leq 50
* 1 \leq K \leq N
* 0 \leq A_i < 2^{18}
* 0 \leq S < 2^{18}
* 0 \leq T < 2^{18}
* A_i \neq A_j (1 \leq i < j \leq N)
Input
Input is given from Standard Input in the following format:
N K S T
A_1 A_2 ... A_N
Output
Print the answer.
Examples
Input
3 3 0 3
1 2 3
Output
2
Input
5 3 1 7
3 4 9 1 5
Output
2
Input
5 4 0 15
3 4 9 1 5
Output
3
"Correct Solution:
```
import sys
readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def solve():
n, k, s, t = nm()
a = [x ^ s for x in nl() if x & s == s and x | t == t]
n = len(a)
t ^= s
s = 0
C = [[0]*(n+1) for i in range(n+1)]
for i in range(n+1):
for j in range(i+1):
if j == 0:
C[i][j] = 1
elif i > 0:
C[i][j] = C[i-1][j] + C[i-1][j-1]
D = [0]*(n+1)
for i in range(n+1):
for j in range(1, min(k, n)+1):
D[i] += C[i][j]
for i in range(n, 0, -1):
D[i] -= D[i-1]
l = list()
for i in range(20, -1, -1):
if t & (1 << i):
l.append(i)
p = len(l)
na = list()
for x in a:
v = 0
for i in l:
v = v << 1 | x >> i & 1
na.append(v)
pc = [popcount(i) for i in range(1 << p)]
l = [0]*(1 << p)
ans = 0
for bit in range(1 << p):
cur = 0
for x in na:
l[bit&x] += 1
cur += D[l[bit&x]]
for x in na:
l[bit&x] -= 1
if pc[bit] & 1:
ans -= cur
else:
ans += cur
print(ans)
return
solve()
```
| 96,736 |
Provide a correct Python 3 solution for this coding contest problem.
Given are N pairwise distinct non-negative integers A_1,A_2,\ldots,A_N. Find the number of ways to choose a set of between 1 and K numbers (inclusive) from the given numbers so that the following two conditions are satisfied:
* The bitwise AND of the chosen numbers is S.
* The bitwise OR of the chosen numbers is T.
Constraints
* 1 \leq N \leq 50
* 1 \leq K \leq N
* 0 \leq A_i < 2^{18}
* 0 \leq S < 2^{18}
* 0 \leq T < 2^{18}
* A_i \neq A_j (1 \leq i < j \leq N)
Input
Input is given from Standard Input in the following format:
N K S T
A_1 A_2 ... A_N
Output
Print the answer.
Examples
Input
3 3 0 3
1 2 3
Output
2
Input
5 3 1 7
3 4 9 1 5
Output
2
Input
5 4 0 15
3 4 9 1 5
Output
3
"Correct Solution:
```
def popcount_parity(x):
x ^= x >> 1
x ^= x >> 2
x ^= x >> 4
x ^= x >> 8
x ^= x >> 16
return -1 if x & 1 else 1
N, K, S, T = map(int, input().split())
if S & T != S:
print(0)
exit()
C = [[1]]
CC = [0] * 51
for i in range(1, 51):
C.append([1] * (i + 1))
for j in range(1, i):
C[i][j] = C[i-1][j-1] + C[i-1][j]
for i in range(51):
CC[i] = sum(C[i][1:K+1])
A = [int(a) for a in input().split()]
aa, oo = - 1, 0
for i in range(N)[::-1]:
a = A[i]
if a & S != S or a | T != T:
del A[i]
continue
aa &= a
oo |= a
aa ^= oo
i = aa
ans = 0
while 1:
D = {}
for a in A:
t = i & a
if t not in D: D[t] = 1
else: D[t] += 1
c = 0
for t in D.values():
c += CC[t]
ans += c * popcount_parity(i)
if not i: break
i = (i - 1) & aa
print(ans)
```
| 96,737 |
Provide a correct Python 3 solution for this coding contest problem.
Given are N pairwise distinct non-negative integers A_1,A_2,\ldots,A_N. Find the number of ways to choose a set of between 1 and K numbers (inclusive) from the given numbers so that the following two conditions are satisfied:
* The bitwise AND of the chosen numbers is S.
* The bitwise OR of the chosen numbers is T.
Constraints
* 1 \leq N \leq 50
* 1 \leq K \leq N
* 0 \leq A_i < 2^{18}
* 0 \leq S < 2^{18}
* 0 \leq T < 2^{18}
* A_i \neq A_j (1 \leq i < j \leq N)
Input
Input is given from Standard Input in the following format:
N K S T
A_1 A_2 ... A_N
Output
Print the answer.
Examples
Input
3 3 0 3
1 2 3
Output
2
Input
5 3 1 7
3 4 9 1 5
Output
2
Input
5 4 0 15
3 4 9 1 5
Output
3
"Correct Solution:
```
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
cmb=[[0 for i in range(51)] for j in range(51)]
cmb[0][0]=1
for i in range(51):
for j in range(51):
if i!=50:
cmb[i+1][j]+=cmb[i][j]
if j!=50 and i!=50:
cmb[i+1][j+1]+=cmb[i][j]
for i in range(1,51):
for j in range(2,51):
cmb[i][j]+=cmb[i][j-1]
import random
N,K,T,S=map(int,input().split())
a=list(map(int,input().split()))
must0=[i for i in range(18) if S>>i &1==0]
must1=[i for i in range(18) if T>>i &1==1]
A=[]
for val in a:
check=True
for j in must0:
check=check&(val>>j &1==0)
for j in must1:
check=check&(val>>j &1==1)
if check:
A.append(val)
if not A:
print(0)
exit()
bit=[]
for i in range(18):
if i not in must0 and i not in must1:
bit.append(i)
for i in range(len(A)):
temp=0
for j in range(len(bit)):
temp+=(A[i]>>bit[j] &1==1)*2**j
A[i]=temp
ans=0
n=len(bit)
data=[0]*(2**n)
pc=[popcount(i) for i in range(2**n)]
for i in range(2**n):
for a in A:
data[a&i]+=1
for a in A:
if data[a&i]:
ans+=cmb[data[a&i]][min(K,data[a&i])]*(-1)**pc[i]
data[a&i]=0
print(ans)
```
| 96,738 |
Provide a correct Python 3 solution for this coding contest problem.
Given are N pairwise distinct non-negative integers A_1,A_2,\ldots,A_N. Find the number of ways to choose a set of between 1 and K numbers (inclusive) from the given numbers so that the following two conditions are satisfied:
* The bitwise AND of the chosen numbers is S.
* The bitwise OR of the chosen numbers is T.
Constraints
* 1 \leq N \leq 50
* 1 \leq K \leq N
* 0 \leq A_i < 2^{18}
* 0 \leq S < 2^{18}
* 0 \leq T < 2^{18}
* A_i \neq A_j (1 \leq i < j \leq N)
Input
Input is given from Standard Input in the following format:
N K S T
A_1 A_2 ... A_N
Output
Print the answer.
Examples
Input
3 3 0 3
1 2 3
Output
2
Input
5 3 1 7
3 4 9 1 5
Output
2
Input
5 4 0 15
3 4 9 1 5
Output
3
"Correct Solution:
```
def popcount_parity(x):
for i in range(8):
x ^= x >> (1 << i)
return -1 if x & 1 else 1
N, K, S, T = map(int, input().split())
if S & T != S:
print(0)
exit()
C = [[1]]
CC = [0] * 51
for i in range(1, 51):
C.append([1] * (i + 1))
for j in range(1, i):
C[i][j] = C[i-1][j-1] + C[i-1][j]
for i in range(51):
CC[i] = sum(C[i][1:K+1])
A = [int(a) for a in input().split()]
aa, oo = - 1, 0
for i in range(N)[::-1]:
a = A[i]
if a & S != S or a | T != T:
del A[i]
continue
aa &= a
oo |= a
aa ^= oo
i = aa
ans = 0
while 1:
D = {}
for a in A:
t = i & a
if t not in D: D[t] = 1
else: D[t] += 1
ans += sum([CC[t] for t in D.values()]) * popcount_parity(i)
if not i: break
i = (i - 1) & aa
print(ans)
```
| 96,739 |
Provide a correct Python 3 solution for this coding contest problem.
Given are N pairwise distinct non-negative integers A_1,A_2,\ldots,A_N. Find the number of ways to choose a set of between 1 and K numbers (inclusive) from the given numbers so that the following two conditions are satisfied:
* The bitwise AND of the chosen numbers is S.
* The bitwise OR of the chosen numbers is T.
Constraints
* 1 \leq N \leq 50
* 1 \leq K \leq N
* 0 \leq A_i < 2^{18}
* 0 \leq S < 2^{18}
* 0 \leq T < 2^{18}
* A_i \neq A_j (1 \leq i < j \leq N)
Input
Input is given from Standard Input in the following format:
N K S T
A_1 A_2 ... A_N
Output
Print the answer.
Examples
Input
3 3 0 3
1 2 3
Output
2
Input
5 3 1 7
3 4 9 1 5
Output
2
Input
5 4 0 15
3 4 9 1 5
Output
3
"Correct Solution:
```
def cmb(n, r, mod):#コンビネーションの高速計算
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return (g1[n] * g2[r] * g2[n-r])%mod
mod = 10**18+7 #出力の制限
N = 50
g1 = [1, 1] # 元テーブル
g2 = [1, 1] #逆元テーブル
inverse = [0, 1] #逆元テーブル計算用テーブル
for i in range( 2, N + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
N,K,T,S=map(int,input().split())
a=list(map(int,input().split()))
must0=[i for i in range(18) if S>>i &1==0]
must1=[i for i in range(18) if T>>i &1==1]
A=[]
for val in a:
check=True
for j in must0:
check=check&(val>>j &1==0)
for j in must1:
check=check&(val>>j &1==1)
if check:
A.append(val)
if not A:
print(0)
exit()
bit=[]
for i in range(18):
if i not in must0 and i not in must1:
bit.append(i)
for i in range(len(A)):
temp=0
for j in range(len(bit)):
temp+=(A[i]>>bit[j] &1==1)*2**j
A[i]=temp
ans=0
n=len(bit)
for i in range(2**n):
dic={}
for a in A:
val=a&i
if val not in dic:
dic[val]=0
dic[val]+=1
temp=0
for val in dic:
for j in range(1,min(K,dic[val])+1):
temp+=cmb(dic[val],j,mod)
popcount=0
for j in range(n):
popcount+=(i>>j &1)
ans+=temp*(-1)**popcount
print(ans%mod)
```
| 96,740 |
Provide a correct Python 3 solution for this coding contest problem.
Given are N pairwise distinct non-negative integers A_1,A_2,\ldots,A_N. Find the number of ways to choose a set of between 1 and K numbers (inclusive) from the given numbers so that the following two conditions are satisfied:
* The bitwise AND of the chosen numbers is S.
* The bitwise OR of the chosen numbers is T.
Constraints
* 1 \leq N \leq 50
* 1 \leq K \leq N
* 0 \leq A_i < 2^{18}
* 0 \leq S < 2^{18}
* 0 \leq T < 2^{18}
* A_i \neq A_j (1 \leq i < j \leq N)
Input
Input is given from Standard Input in the following format:
N K S T
A_1 A_2 ... A_N
Output
Print the answer.
Examples
Input
3 3 0 3
1 2 3
Output
2
Input
5 3 1 7
3 4 9 1 5
Output
2
Input
5 4 0 15
3 4 9 1 5
Output
3
"Correct Solution:
```
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
cmb=[[0 for i in range(51)] for j in range(51)]
cmb[0][0]=1
for i in range(51):
for j in range(51):
if i!=50 and j!=50:
cmb[i+1][j+1]+=cmb[i][j]
if i!=50:
cmb[i+1][j]+=cmb[i][j]
for i in range(1,51):
for j in range(2,51):
cmb[i][j]+=cmb[i][j-1]
N,K,T,S=map(int,input().split())
a=list(map(int,input().split()))
must0=[i for i in range(18) if S>>i &1==0]
must1=[i for i in range(18) if T>>i &1==1]
A=[]
for val in a:
check=True
for j in must0:
check=check&(val>>j &1==0)
for j in must1:
check=check&(val>>j &1==1)
if check:
A.append(val)
if not A:
print(0)
exit()
bit=[]
for i in range(18):
if i not in must0 and i not in must1:
bit.append(i)
for i in range(len(A)):
temp=0
for j in range(len(bit)):
temp+=(A[i]>>bit[j] &1==1)*2**j
A[i]=temp
ans=0
n=len(bit)
data=[0]*(2**n)
for i in range(2**n):
t=set([])
for a in A:
data[a&i]+=1
t.add(a&i)
temp=0
for val in t:
temp+=cmb[data[val]][min(K,data[val])]
ans+=temp*(-1)**popcount(i)
for val in t:
data[val]=0
print(ans)
```
| 96,741 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are N pairwise distinct non-negative integers A_1,A_2,\ldots,A_N. Find the number of ways to choose a set of between 1 and K numbers (inclusive) from the given numbers so that the following two conditions are satisfied:
* The bitwise AND of the chosen numbers is S.
* The bitwise OR of the chosen numbers is T.
Constraints
* 1 \leq N \leq 50
* 1 \leq K \leq N
* 0 \leq A_i < 2^{18}
* 0 \leq S < 2^{18}
* 0 \leq T < 2^{18}
* A_i \neq A_j (1 \leq i < j \leq N)
Input
Input is given from Standard Input in the following format:
N K S T
A_1 A_2 ... A_N
Output
Print the answer.
Examples
Input
3 3 0 3
1 2 3
Output
2
Input
5 3 1 7
3 4 9 1 5
Output
2
Input
5 4 0 15
3 4 9 1 5
Output
3
Submitted Solution:
```
N, K, S, T = map(int, input().split())
A = list(map(int, input().split()))
ans = 0
for i in range(1, 2**N):
start = 0
for j in range(N):
if((i >> j) & 1):
if start == 1:
s = s&A[j]
t = t | A[j]
else:
s = A[j]
t = A[j]
start = 1
if (s == S) and (t == T):
ans += 1
print(ans)
```
No
| 96,742 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are N pairwise distinct non-negative integers A_1,A_2,\ldots,A_N. Find the number of ways to choose a set of between 1 and K numbers (inclusive) from the given numbers so that the following two conditions are satisfied:
* The bitwise AND of the chosen numbers is S.
* The bitwise OR of the chosen numbers is T.
Constraints
* 1 \leq N \leq 50
* 1 \leq K \leq N
* 0 \leq A_i < 2^{18}
* 0 \leq S < 2^{18}
* 0 \leq T < 2^{18}
* A_i \neq A_j (1 \leq i < j \leq N)
Input
Input is given from Standard Input in the following format:
N K S T
A_1 A_2 ... A_N
Output
Print the answer.
Examples
Input
3 3 0 3
1 2 3
Output
2
Input
5 3 1 7
3 4 9 1 5
Output
2
Input
5 4 0 15
3 4 9 1 5
Output
3
Submitted Solution:
```
import sys
readline = sys.stdin.readline
readall = sys.stdin.read
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def solve():
n, k, s, t = nm()
a = [x ^ s for x in nl() if x & s == s and x | t == t]
n = len(a)
t ^= s
s = 0
C = [[0]*(n+1) for i in range(n+1)]
for i in range(n+1):
for j in range(i+1):
if j == 0:
C[i][j] = 1
elif i > 0:
C[i][j] = C[i-1][j] + C[i-1][j-1]
D = [0]*(n+1)
for i in range(n+1):
for j in range(1, k+1):
D[i] += C[i][j]
for i in range(n, 0, -1):
D[i] -= D[i-1]
l = list()
for i in range(20, -1, -1):
if t & (1 << i):
l.append(i)
p = len(l)
na = list()
for x in a:
v = 0
for i in l:
v = v << 1 | x >> i & 1
na.append(v)
return
pc = [0]*(1 << p)
for bit in range(1 << p):
for i in range(p):
if not bit & (1 << i):
pc[bit | (1 << i)] = pc[bit] + 1
return
l = [0]*(1 << p)
ans = 0
for bit in range(1 << p):
cur = 0
for x in na:
l[bit&x] += 1
cur += D[l[bit&x]]
for x in na:
l[bit&x] -= 1
if pc[bit] & 1:
ans -= cur
else:
ans += cur
print(ans)
return
solve()
```
No
| 96,743 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are N pairwise distinct non-negative integers A_1,A_2,\ldots,A_N. Find the number of ways to choose a set of between 1 and K numbers (inclusive) from the given numbers so that the following two conditions are satisfied:
* The bitwise AND of the chosen numbers is S.
* The bitwise OR of the chosen numbers is T.
Constraints
* 1 \leq N \leq 50
* 1 \leq K \leq N
* 0 \leq A_i < 2^{18}
* 0 \leq S < 2^{18}
* 0 \leq T < 2^{18}
* A_i \neq A_j (1 \leq i < j \leq N)
Input
Input is given from Standard Input in the following format:
N K S T
A_1 A_2 ... A_N
Output
Print the answer.
Examples
Input
3 3 0 3
1 2 3
Output
2
Input
5 3 1 7
3 4 9 1 5
Output
2
Input
5 4 0 15
3 4 9 1 5
Output
3
Submitted Solution:
```
from functools import lru_cache
n, k, and_, or_ = map(int, input().split())
lst = sorted([int(n) for n in input().split()])
lst = [n for n in lst if n & and_ == and_ and n | or_ == or_]
n = len(lst)
# print(lst)
@lru_cache(None)
def fac(n):
return 1 if n <= 1 else n * fac(n - 1)
def choose(a, b):
return fac(a) // fac(b) // fac(a - b)
@lru_cache(None)
def f(i, k, a, b):
if a == and_ and b == or_:
return sum(choose(n - i, x) for x in range(1 + min(k, n - i)))
elif i == n:
return 0
else:
return (f(i + 1, k - 1, a & lst[i], b | lst[i]) if k > 0 else 0) + f(i + 1, k, a, b)
print(sum(f(i + 1, k - 1, x, x) for i, x in enumerate(lst)))
```
No
| 96,744 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given are N pairwise distinct non-negative integers A_1,A_2,\ldots,A_N. Find the number of ways to choose a set of between 1 and K numbers (inclusive) from the given numbers so that the following two conditions are satisfied:
* The bitwise AND of the chosen numbers is S.
* The bitwise OR of the chosen numbers is T.
Constraints
* 1 \leq N \leq 50
* 1 \leq K \leq N
* 0 \leq A_i < 2^{18}
* 0 \leq S < 2^{18}
* 0 \leq T < 2^{18}
* A_i \neq A_j (1 \leq i < j \leq N)
Input
Input is given from Standard Input in the following format:
N K S T
A_1 A_2 ... A_N
Output
Print the answer.
Examples
Input
3 3 0 3
1 2 3
Output
2
Input
5 3 1 7
3 4 9 1 5
Output
2
Input
5 4 0 15
3 4 9 1 5
Output
3
Submitted Solution:
```
import math
import itertools
def main():
n, k, s, t = list(map(int, input().split()))
a = list(map(int, input().split()))
# mask = 1 << (math.ceil(math.sqrt(s)) + 1) - 1
a.sort()
for i, e in enumerate(a):
if s <= e:
a = a[i:]
break
else:
return 0
max_value = 2 ** math.ceil(math.sqrt(t))
for i, e in enumerate(a):
if max_value < e:
a = a[:i]
break
result = 0
for i in range(1, k + 1):
for c in itertools.combinations(a, i):
sr = c[0]
tr = 0
for e in c:
if (s & e) == s:
sr &= e
else:
break
tr |= e
if tr > t:
break
if sr == s and tr == t:
result += 1
return result
if __name__ == '__main__':
result = main()
print(result)
```
No
| 96,745 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
"Correct Solution:
```
s = input()
q = len(s)
print("x"*q)
```
| 96,746 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
"Correct Solution:
```
print(''.join('x' for x in input()))
```
| 96,747 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
"Correct Solution:
```
S = input()
L = len(S)
print('x'*L)
```
| 96,748 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
"Correct Solution:
```
S = input()
l=len(S)
print("x"*l)
```
| 96,749 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
"Correct Solution:
```
s = input()
y = len(s)
print('x'*y)
```
| 96,750 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
"Correct Solution:
```
b = input()
print("x" * len(b))
```
| 96,751 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
"Correct Solution:
```
s = input()
n = len(s)
print("x"*n)
```
| 96,752 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
"Correct Solution:
```
S = input()
print(['x'*len(S)][0])
```
| 96,753 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
Submitted Solution:
```
S= input()
t= len(S)
print("x" * t)
```
Yes
| 96,754 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
Submitted Solution:
```
s = input()
print((len(s)*chr(120)))
```
Yes
| 96,755 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
Submitted Solution:
```
#B
S=input()
print("x"*len(S))
```
Yes
| 96,756 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
Submitted Solution:
```
s=input()
l=len(s)
k="x"*l
print(k)
```
Yes
| 96,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
Submitted Solution:
```
def resolve_B():
s = input()
l = len(s)
print("x" * l)
resolve_B
```
No
| 96,758 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
Submitted Solution:
```
S = input()
L = len[S]
for i in rnage(L):
print("x")
```
No
| 96,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
Submitted Solution:
```
print('x'for i in range(len(input())))
```
No
| 96,760 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S. Replace every character in S with `x` and print the result.
Constraints
* S is a string consisting of lowercase English letters.
* The length of S is between 1 and 100 (inclusive).
Input
Input is given from Standard Input in the following format:
S
Output
Replace every character in S with `x` and print the result.
Examples
Input
sardine
Output
xxxxxxx
Input
xxxx
Output
xxxx
Input
gone
Output
xxxx
Submitted Solution:
```
u = input()
for i in len(u):
u[i]="x"
print(u)
```
No
| 96,761 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
"Correct Solution:
```
N = int(input())
S = input()
dp = [[0]*N for i in range(N)]
pm = 0
ans = 0
for i in range(N-1,0,-1):
for j in range(i-1,-1,-1):
if S[i]==S[j]:
if i<N-1:
dp[i][j] = min(dp[i+1][j+1]+1, i-j)
else:
dp[i][j] = 1
else:
dp[i][j] = 0
if dp[i][j]>ans:
ans = dp[i][j]
print(ans)
```
| 96,762 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
"Correct Solution:
```
def main():
n=int(input())
s=input()
dp=[[0]*(n+1) for i in range(n+1)]
ans=0
for i in reversed(range(n)):
for j in reversed(range(i+1,n)):
if s[i]==s[j]:
dp[i][j]=dp[i+1][j+1]+1
ans=max(ans,min(j-i,dp[i][j]))
print(ans)
if __name__=='__main__':
main()
```
| 96,763 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
"Correct Solution:
```
I=input;n=int(I());s=I();j=1;r=[]
for i in range(n):
while (j<n)and(s[i:j] in s[j:]):j+=1
r.append(j-i-1)
print(max(r))
```
| 96,764 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
"Correct Solution:
```
N = int(input())
S = input()
ans = 0
dp = [0] * N
for i in range(N - 1):
dp2 = dp[:]
for j in range(i + 1, N):
if S[i] == S[j] and j - i > dp2[j-1]:
dp[j] = dp2[j-1] + 1
ans = max(ans, dp[j])
else:
dp[j] = 0
print(ans)
```
| 96,765 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
"Correct Solution:
```
import sys
input = sys.stdin.readline
def main():
n = int(input())
s = input()[::-1]
ans = 0
l = 0
r = 1
for r in range(1,n):
if s[l:r] in s[r:]:
ans=r-l
else:
l += 1
print(ans)
main()
```
| 96,766 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
"Correct Solution:
```
n=int(input())
s=input()
ans=i=0
j=1
while j<n:
t=s[i:j]
if t in s[j:]:
ans=max(ans,j-i)
j+=1
else:
i+=1
print(ans)
```
| 96,767 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
"Correct Solution:
```
N = int(input())
S = input()
ans = 0
right = 0
for left in range(N - 1):
while right < N and (S[left : right] in S[right :]):
right += 1
if left == right:
right += 1
ans = max(ans, right - left - 1)
print(ans)
```
| 96,768 |
Provide a correct Python 3 solution for this coding contest problem.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
"Correct Solution:
```
n,s=open(0);a=i=j=0
while j<int(n):
t=s[i:j]
if t in s[j:]:a=max(a,j-i);j+=1
else:i+=1
print(a)
```
| 96,769 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
Submitted Solution:
```
n = int(input())
s = input()
ans = 0
lenS = 1
for i in range(n):
tempS = s[i:i+lenS]
while (tempS in s[i+lenS:]):
lenS += 1
tempS = s[i:i+lenS]
ans += 1
if (i + 2*lenS>= n):
break
print(ans)
```
Yes
| 96,770 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
Submitted Solution:
```
n,s=open(0);a=i=j=0
while j<int(n):
if s[i:j]in s[j:]:a=max(a,j-i);j+=1
else:i+=1
print(a)
```
Yes
| 96,771 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
Submitted Solution:
```
N = int(input())
S = input()
dp = [[0] * (N + 1) for _ in range(N + 1)]
ans = 0
for i in range(N - 1, -1, -1):
for j in range(N - 1, -1, -1):
if i >= j: break
if S[i] == S[j]:
dp[i][j] = min(1 + dp[i + 1][j + 1], j - i)
if dp[i][j] > ans:
ans = dp[i][j]
print(ans)
```
Yes
| 96,772 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
Submitted Solution:
```
N = int(input())
S = input()
dp = [[0]*(N+1) for _ in range(N+1)]
for i in reversed(range(N)):
for j in reversed(range(N)):
if S[i] == S[j]:
dp[i][j] = dp[i+1][j+1] + 1
ans = 0
for i in range(N):
for j in range(i, N):
ans = max(min(dp[i][j], j-i), ans)
print(ans)
```
Yes
| 96,773 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
Submitted Solution:
```
N=int(input())
S=input()
max=0
for f in range(len(S)-1):
#print("roop "+str(f))
i = f+1
A = [0] * (len(S)-f+i)
A[0]=len(S)
while(i<len(S)):
j=0
#print("i=" + str(i) + " j=" + str(j))
while(i+j<len(S) and S[f+j]==S[i+j] and j<i):
j+=1
#print(S[f+j]+" "+S[i+j])
A[i]=j
if(j>max):
max=j
#print("update max ="+str(max))
if(j==0):
i+=1
continue
k=1
while(k+i<len(S) and k+A[k]<j):
A[i+k]=A[k]
k+=1
i+=k
#print(A)
print(max)
```
No
| 96,774 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
Submitted Solution:
```
n = int(input())
s = list(input())
res = 0
for k in range(1,n//2+10):
d = [0]*n
for i in range(n-k):
if i+k <= n-1 and s[i] == s[i+k]:
d[i] = min(k,d[i-1]+1)
res = max(res,d[i])
print(res)
```
No
| 96,775 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
Submitted Solution:
```
def main():
n=int(input())
s=input()
dp=[[0]*(n+1) for i in range(n+1)]
for i in range(n-1,-1,-1):
for j in range(n-1,-1,-1):
if s[i]==s[j]:
dp[i][j]=dp[i+1][j+1]+1
for i in dp:
print(i)
ans=0
for i in range(n-1):
for j in range(i+1,n):
ans=max(ans,min(j-i,dp[i][j]))
print(ans)
if __name__=='__main__':
main()
```
No
| 96,776 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given is a string S of length N.
Find the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping.
More formally, find the maximum positive integer len such that there exist integers l_1 and l_2 ( 1 \leq l_1, l_2 \leq N - len + 1 ) that satisfy the following:
* l_1 + len \leq l_2
* S[l_1+i] = S[l_2+i] (i = 0, 1, ..., len - 1)
If there is no such integer len, print 0.
Constraints
* 2 \leq N \leq 5 \times 10^3
* |S| = N
* S consists of lowercase English letters.
Input
Input is given from Standard Input in the following format:
N
S
Output
Print the maximum length of a non-empty string that occurs twice or more in S as contiguous substrings without overlapping. If there is no such non-empty string, print 0 instead.
Examples
Input
5
ababa
Output
2
Input
2
xy
Output
0
Input
13
strangeorange
Output
5
Submitted Solution:
```
N = int(input())
S = input().strip()
dp = [[0 for _ in range(N+1)] for _ in range(N+1)]
for i in reversed(range(N)):
for j in reversed(range(N)):
if i >= j:
continue
if S[i] != S[j]:
dp[i][j] = 0
if S[i] == S[j]:
dp[i][j] = dp[i+1][j+1] + 1
ans = 0
for i in range(N):
for j in range(N):
now = min([dp[i][j], j-i])
ans = max(ans, now)
print(ans)
```
No
| 96,777 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
"Correct Solution:
```
_,*s=open(0).read().split()
a=b=c=d=0
for S in s:a+=S[-1]=='A';b+=S[0]=='B';c+=S[-1]+S[0]=='AB';d+=S.count('AB')
print(d+min(a,b)-(0<a==b==c))
```
| 96,778 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
"Correct Solution:
```
n = int(input())
S = [input() for i in range(n)]
ans = 0
a_cnt = 0
b_cnt = 0
ba_cnt = 0
for i in range(n):
ans+=S[i].count('AB')
if S[i][0]=='B' and S[i][-1]=='A':
ba_cnt+=1
elif S[i][-1]=='A':
a_cnt+=1
elif S[i][0]=='B':
b_cnt+=1
print(ans+min(a_cnt,b_cnt)+ba_cnt-1*(ba_cnt>0 and a_cnt==b_cnt==0))
```
| 96,779 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
"Correct Solution:
```
N=int(input())
S=[input() for _ in [0]*N]
AB=0
X_A=0
B_X=0
B_A=0
for s in S:
AB+=s.count("AB")
if s[0]!="B" and s[-1]=="A":X_A+=1
if s[0]=="B" and s[-1]!="A":B_X+=1
if s[0]=="B" and s[-1]=="A":B_A+=1
r=AB
if B_A>0:
r+=B_A-1
if X_A>0:r+=1;X_A-=1
if B_X>0:r+=1;B_X-=1
r+=min(X_A,B_X)
print(r)
```
| 96,780 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
"Correct Solution:
```
n=int(input())
l=[0,0,0,0]#non,~a,b~,b~a
ans=0
for i in range(n):
s=input()
ans+=s.count("AB")
l[2*int(s[0]=="B")+1*int(s[-1]=="A")]+=1
if l[-1]:
ans+=l[-1]-1
if l[1]:
l[1]-=1
ans+=1
if l[2]:
l[2]-=1
ans+=1
print(ans+min(l[1:3]))
```
| 96,781 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
"Correct Solution:
```
n=int(input())
s=[]
ans=0
a=0
b=0
ab=0
for i in range(n):
x=input()
s.append(x)
for j in range(len(x)-1):
if x[j]=="A" and x[j+1]=="B":
ans+=1
if x[0]=="B" and x[-1]=="A":
ab+=1
elif x[0]=="B":
b+=1
elif x[-1]=="A":
a+=1
if a==b==0:
print(ans+max(ab-1,0))
else:
print(ans+max(0,ab+min(a,b)))
```
| 96,782 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
"Correct Solution:
```
N = int(input())
a, b, ab, ret = 0, 0, 0, 0
for i in range(N):
s = input()
l = len(s) - 1
if s[0] == "B" and s[l] == "A":
ab += 1
if s[0] == "B":
b += 1
if s[l] == "A":
a += 1
ret += s.count("AB")
if a == b and a == ab and a > 0:
a -= 1
ab = min(a,b)
print(ret + ab)
```
| 96,783 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
"Correct Solution:
```
n = int(input())
ans = 0
ab = 0
a = 0
b = 0
for i in range(n):
s = input()
ans += s.count("AB")
if s[0] == "B" and s[-1] == "A":
ab += 1
elif s[0] == "B":
b += 1
elif s[-1] == "A":
a += 1
b,a = sorted([a,b])
if ab > 0:
ans += ab-1
ab = 1
if a > 0:
ans += ab
ans += b
print(ans)
```
| 96,784 |
Provide a correct Python 3 solution for this coding contest problem.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
"Correct Solution:
```
X=[input() for _ in range(int(input()))]
a,b,e,s=0,0,0,0
for x in X:
a += x.count("AB")
if x.endswith("A") and x.startswith("B"):
b += 1
elif x.endswith("A"):
e += 1
elif x.startswith("B"):
s += 1
if b > 0:
a += b-1
if e > 0:
e -= 1
a += 1
if s > 0:
s -= 1
a += 1
a += min(e,s)
print(a)
```
| 96,785 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
Submitted Solution:
```
n=int(input())
c=0
d=0
a=0
k=0
for i in range(n):
s=input()
if "AB" in s:
c+=s.count("AB")
if s[0]=="B" and s[len(s)-1]=="A":
d+=1
if s[0]=="B" and s[len(s)-1]!="A":
a+=1
if s[len(s)-1]=="A" and s[0]!="B":
k+=1
if a+k==0:
print(max(c+d-1,c))
elif a+k>0:
print(c+min(d+a,d+k))
else:
print(c+min(a,k))
```
Yes
| 96,786 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
Submitted Solution:
```
N =int(input())
co = {0:0,1:0,2:0,3:0}
ans = 0
foo =0
for _ in range(N):
i = input()
foo = 0
if i[0] =="B":
foo += 1
if i[-1] =="A":
foo += 2
co[foo] += 1
ans += i.count("AB")
ans += min(co[1],co[2])
ans += co[3]
if co[1]==0 and co[2] == 0 and co[3]!= 0:
ans -= 1
print(ans)
```
Yes
| 96,787 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
Submitted Solution:
```
N = int(input())
A = [input() for _ in range(N)]
n = 0
Acount, Bcount,both = 0,0,0
for a in A:
n += a.count("AB")
if (a[0]=="B")&(a[-1]=="A"):both+=1
elif a[0] == "B":Bcount+=1
elif a[-1] == "A":Acount+=1
# print(n,Acount,Bcount,both)
n += min(Acount,Bcount)
if Acount+Bcount>0:n += both
elif both>0:n += both-1
print(n)
```
Yes
| 96,788 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
Submitted Solution:
```
n = int(input())
ab = 0
bx = 0
xa = 0
bxa = 0
for ln in range(n):
line = input().rstrip()
ab += line.count("AB")
first , last = line[0], line[-1]
if (first, last) == ('B', 'A'):
bxa += 1
elif first == 'B':
bx += 1
elif last == 'A':
xa += 1
if bx + xa == 0:
bxa = max(0, bxa - 1)
print(ab + bxa + min(bx, xa))
```
Yes
| 96,789 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
Submitted Solution:
```
n=int(input())
count=countA=countB=countAB=0
for i in range(n):
s=input()
if "AB" in s:
count+=1
if s[-1]=="A":countA+=1
if s[0]=="B":countB+=1
if s[-1]=="A" and s[0]=="B":countAB+=1
print(count+min(countA,countB) if countAB!=0 else count+min(countA,countB)-countAB)
```
No
| 96,790 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
Submitted Solution:
```
def ab_substrings(N: int, S: list)->int:
res = 0
endA = 0
startB = 0
for s in S:
res += s.count('AB')
endA += s.endswith('A')
startB += s.startswith('B')
res1, endA1, startB1 = res, endA, startB
for s in S:
if s.endswith('A') and endA1 > 0:
if not s.startswith('B') or startB1 > 1:
res1 += 1
endA1 -= 1
startB1 -= 1
res2, endA2, startB2 = res, endA, startB
for s in S:
if s.endswith('A') and endA2 > 0:
if not s.startswith('B') or startB2 > 1:
res2 += 1
endA2 -= 1
startB2 -= 1
return max(res1, res2)
if __name__ == "__main__":
N = int(input())
S = [input() for _ in range(N)]
ans = ab_substrings(N, S)
print(ans)
```
No
| 96,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
Submitted Solution:
```
n = int(input())
cnt_a = 0 # Bで始まらないがAで終わる
cnt_b = 0 # Bで始まるがAで終わらない
cnt_ba = 0 # Bで始まりAで終わる
ans = 0
for _ in range(n):
s = input()
ans += s.count('AB')
if s.endswith('A') and s.startswith('B'):
cnt_ba += 1
else:
if s.endswith('A'):
cnt_a += 1
if s.startswith('B'):
cnt_b += 1
if cnt_a == 0:
ans += cnt_ba - 1
if cnt_b > 0:
ans += 1
else:
ans += cnt_ba
cnt_a -= 1
if cnt_b > 0:
ans += 1
cnt_b -= 1
# 残ったxxAとBxxを組み合わせてABを作る
ans += min(cnt_a, cnt_b)
print(ans)
```
No
| 96,792 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Snuke has N strings. The i-th string is s_i.
Let us concatenate these strings into one string after arranging them in some order. Find the maximum possible number of occurrences of `AB` in the resulting string.
Constraints
* 1 \leq N \leq 10^{4}
* 2 \leq |s_i| \leq 10
* s_i consists of uppercase English letters.
Input
Input is given from Standard Input in the following format:
N
s_1
\vdots
s_N
Output
Print the answer.
Examples
Input
3
ABCA
XBAZ
BAD
Output
2
Input
9
BEWPVCRWH
ZZNQYIJX
BAVREA
PA
HJMYITEOX
BCJHMRMNK
BP
QVFABZ
PRGKSPUNA
Output
4
Input
7
RABYBBE
JOZ
BMHQUVA
BPA
ISU
MCMABAOBHZ
SZMEHMA
Output
4
Submitted Solution:
```
#Rs,Gs,Bs,Ns= input().split()
#R=int(Rs)
#G=int(Gs)
#B=int(Bs)
#N=int(Ns)
#ans=0
#sub_ans=0
#while(sub_ans>=N):
ans=0
f_a=0
b_b=0
a_b=0
str_list=[]
N= int(input())
for i in range(N):
str=input()
ans=ans+str.count("AB")
if(str[-1]=="A"):
f_a=f_a+1
if(str[0]=="B"):
b_b=b_b+1
if(str[-1]=="A"and str[0]=="B"):
a_b=a_b+1
if(f_a==N and b_b==N):
ans=ans+N-1
elif((f_a==a_b)and(b_b==a_b)):
ans=ans+f_a-1
elif(f_a< b_b):
ans=ans+f_a
else:
ans=ans+b_b
#print(f_a)
#print(b_b)
print(ans)
```
No
| 96,793 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given strings s and t, both of length N. s and t consist of `0` and `1`. Additionally, in these strings, the same character never occurs three or more times in a row.
You can modify s by repeatedly performing the following operation:
* Choose an index i (1 \leq i \leq N) freely and invert the i-th character in s (that is, replace `0` with `1`, and `1` with `0`), under the condition that the same character would not occur three or more times in a row in s after the operation.
Your objective is to make s equal to t. Find the minimum number of operations required.
Constraints
* 1 \leq N \leq 5000
* The lengths of s and t are both N.
* s and t consists of `0` and `1`.
* In s and t, the same character never occurs three or more times in a row.
Input
Input is given from Standard Input in the following format:
N
s
t
Output
Find the minimum number of operations required to make s equal to t. It can be proved that the objective is always achievable in a finite number of operations.
Examples
Input
4
0011
0101
Output
4
Input
1
0
0
Output
0
Input
8
00110011
10101010
Output
10
Submitted Solution:
```
N = int(input())
s = input()
t = input()
# N = 8
# s = "0011" * 2
# t = "1010" * 2
s_list = [i for i in range(N-1) if s[i:i+2] in ("00", "11")]
s_list2 = [-1 for i in range(N+1)] + s_list + [(N-1) for i in range(N+1)]
t_list = [i for i in range(N-1) if t[i:i+2] in ("00", "11")]
ans = 10 ** 10
if s[0] == t[0]:
for i in range(-(len(t_list) + len(s_list))//2 - 1, len(t_list) + len(s_list) + 2):
new_ans = sum([abs(a-b) for a, b in zip(s_list2[N+1+2*i:N+1+2*i+len(t_list)], t_list)])
if N+1+2*i > N+1:
new_ans += sum(s_list2[N+1:min(N+1+2*i, N+1+len(s_list2))]) + min(2*i, len(s_list2))
if N+1+len(s_list) > N+1+2*i+len(t_list):
new_ans += (N-1) * (N+1+len(s_list) - max(N+1+2*i+len(t_list), N+1)) - \
sum(s_list2[max(N+1+2*i+len(t_list), N+1):N+1+len(s_list)])
if new_ans < ans:
ans = new_ans
else:
add_one = 0
if s_list[0] == 0:
s_list = s_list[1:]
s_list2 = [-1 for i in range(N + 1)] + s_list + [N for i in range(N + 1)]
add_one = 1
for i in range(-(len(t_list) + len(s_list))//2 - 1, len(t_list) + len(s_list) + 2):
new_ans = sum([abs(a-b) for a, b in zip(s_list2[N+1+2*i:N+1+2*i+len(t_list)], t_list)])
if N+1+2*i > N+1:
new_ans += sum(s_list2[N+1:min(N+1+2*i, N+1+len(s_list2))]) + min(2*i, len(s_list2))
if N+1+len(s_list) > N+1+2*i+len(t_list):
new_ans += (N-1) * (N+1+len(s_list) - max(N+1+2*i+len(t_list), N+1)) - \
sum(s_list2[max(N+1+2*i+len(t_list), N+1):N+1+len(s_list)])
if new_ans + add_one < ans:
ans = new_ans + add_one
print(str(ans))
```
No
| 96,794 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given strings s and t, both of length N. s and t consist of `0` and `1`. Additionally, in these strings, the same character never occurs three or more times in a row.
You can modify s by repeatedly performing the following operation:
* Choose an index i (1 \leq i \leq N) freely and invert the i-th character in s (that is, replace `0` with `1`, and `1` with `0`), under the condition that the same character would not occur three or more times in a row in s after the operation.
Your objective is to make s equal to t. Find the minimum number of operations required.
Constraints
* 1 \leq N \leq 5000
* The lengths of s and t are both N.
* s and t consists of `0` and `1`.
* In s and t, the same character never occurs three or more times in a row.
Input
Input is given from Standard Input in the following format:
N
s
t
Output
Find the minimum number of operations required to make s equal to t. It can be proved that the objective is always achievable in a finite number of operations.
Examples
Input
4
0011
0101
Output
4
Input
1
0
0
Output
0
Input
8
00110011
10101010
Output
10
Submitted Solution:
```
import numpy as np
N = int(input())
S = np.array(list(map(int,list(input()))),dtype=np.int)
T = np.array(list(map(int,list(input()))),dtype=np.int)
def lessthan3(s,t,N,k,f):
if k >= N:
return 0
elif s[k]==t[k]:
if f==0:
return lessthan3(s,t,N,k+1,0)
elif f==1:
if k < N-1:
return lessthan3(s,t,N,k+1,2)
else:
s[k] ^= 1
return lessthan3(s,t,N,k,1) + 1
else:
s[k] ^= 1
return lessthan3(s,t,N,k,2) + 1
elif (k >= 2 and s[k-1]==t[k] and s[k-2] == t[k]) or (N-k >= 3 and s[k+1]==t[k] and s[k+2]==t[k]) or (k>=1 and N-k>=2 and s[k-1]==t[k] and s[k+1]==t[k]):
return lessthan3(s,t,N,k+1,1)+1
# elif f==0:
else:
s[k] = t[k]
return lessthan3(s,t,N,k+1,0)+1
# else:
# return lessthan3(s,t,N,k-f,0)
print(lessthan3(S,T,N,0,0))
```
No
| 96,795 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given strings s and t, both of length N. s and t consist of `0` and `1`. Additionally, in these strings, the same character never occurs three or more times in a row.
You can modify s by repeatedly performing the following operation:
* Choose an index i (1 \leq i \leq N) freely and invert the i-th character in s (that is, replace `0` with `1`, and `1` with `0`), under the condition that the same character would not occur three or more times in a row in s after the operation.
Your objective is to make s equal to t. Find the minimum number of operations required.
Constraints
* 1 \leq N \leq 5000
* The lengths of s and t are both N.
* s and t consists of `0` and `1`.
* In s and t, the same character never occurs three or more times in a row.
Input
Input is given from Standard Input in the following format:
N
s
t
Output
Find the minimum number of operations required to make s equal to t. It can be proved that the objective is always achievable in a finite number of operations.
Examples
Input
4
0011
0101
Output
4
Input
1
0
0
Output
0
Input
8
00110011
10101010
Output
10
Submitted Solution:
```
# input
N = int(input())
S = input()
T = input()
# red nad blue bar pos
sr, sb = [], []
tr, tb = [], []
for i in range(N-1):
if S[i:i+2] == '01':
sr.append(i+1)
if S[i:i+2] == '10':
sb.append(i+1)
if T[i:i+2] == '01':
tr.append(i+1)
if T[i:i+2] == '10':
tb.append(i+1)
def dist(s, t):
long, short = (s, t) if len(s) > len(t) else t, s
dif = len(long) - len(short)
res = []
for ofs in range(dif + 1):
fit = [0] * ofs + short + [N] * (dif-ofs)
res.append(sum(abs(a-b) for a, b in zip(fit, long)))
return res
dr, db = dist(sr, tr), dist(sb, tb)
long, short = (dr, db) if len(dr) > len(db) else db, dr
dif = len(long) - len(short)
res = []
for ofs in range(dif + 1):
res.append(min(a+b for a, b in zip(short, long[ofs:ofs+len(short)])))
print(min(res))
```
No
| 96,796 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given strings s and t, both of length N. s and t consist of `0` and `1`. Additionally, in these strings, the same character never occurs three or more times in a row.
You can modify s by repeatedly performing the following operation:
* Choose an index i (1 \leq i \leq N) freely and invert the i-th character in s (that is, replace `0` with `1`, and `1` with `0`), under the condition that the same character would not occur three or more times in a row in s after the operation.
Your objective is to make s equal to t. Find the minimum number of operations required.
Constraints
* 1 \leq N \leq 5000
* The lengths of s and t are both N.
* s and t consists of `0` and `1`.
* In s and t, the same character never occurs three or more times in a row.
Input
Input is given from Standard Input in the following format:
N
s
t
Output
Find the minimum number of operations required to make s equal to t. It can be proved that the objective is always achievable in a finite number of operations.
Examples
Input
4
0011
0101
Output
4
Input
1
0
0
Output
0
Input
8
00110011
10101010
Output
10
Submitted Solution:
```
N = int(input())
s = input()
t = input()
# N = 8
# s = "0011" * 2
# t = "1010" * 2
s_list = [i for i in range(N-1) if s[i:i+2] in ("00", "11")]
s_list2 = [-1 for i in range(N+1)] + s_list + [(N-1) for i in range(N+1)]
t_list = [i for i in range(N-1) if t[i:i+2] in ("00", "11")]
ans = 10 ** 10
if s[0] == t[0]:
for i in range(-(len(t_list) + len(s_list))//2 - 1, len(t_list) + len(s_list) + 2):
new_ans = sum([abs(a-b) for a, b in zip(s_list2[N+1+2*i:N+1+2*i+len(t_list)], t_list)])
if N+1+2*i > N+1:
new_ans += sum(s_list2[N+1:min(N+1+2*i, N+1+len(s_list2))]) + min(2*i, len(s_list2))
if N+1+len(s_list) > N+1+2*i+len(t_list):
new_ans += (N-1) * (N+1+len(s_list) - max(N+1+2*i+len(t_list), N+1)) - \
sum(s_list2[max(N+1+2*i+len(t_list), N+1):N+1+len(s_list)])
if new_ans < ans:
ans = new_ans
else:
add_one = 0
if s_list[0] == 0:
s_list = s_list[1:]
s_list2 = [-1 for i in range(N + 1)] + s_list + [N for i in range(N + 1)]
add_one = 1
for i in range(-(len(t_list) + len(s_list))//2 - 1, len(t_list) + len(s_list) + 2):
new_ans = sum([abs(a-b) for a, b in zip(s_list2[N+1+2*i:N+1+2*i+len(t_list)], t_list)])
if N+1+2*i > N+1:
new_ans += sum(s_list2[N+1:min(N+1+2*i, N+1+len(s_list2))]) + min(2*i, len(s_list2))
if N+1+len(s_list) > N+1+2*i+len(t_list):
new_ans += (N-1) * (N+1+len(s_list) - max(N+1+2*i+len(t_list), N+1)) - \
sum(s_list2[max(N+1+2*i+len(t_list), N+1):N+1+len(s_list)])
if new_ans < ans + add_one:
ans = new_ans + add_one
print(str(ans))
```
No
| 96,797 |
Provide a correct Python 3 solution for this coding contest problem.
You are given two integers A and B. Find the largest value among A+B, A-B and A \times B.
Constraints
* -1000 \leq A,B \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B
Output
Print the largest value among A+B, A-B and A \times B.
Examples
Input
3 1
Output
4
Input
4 -2
Output
6
Input
0 0
Output
0
"Correct Solution:
```
a, b = map(int, input().split())
print(max([(a+b),(a-b),(a*b)]))
```
| 96,798 |
Provide a correct Python 3 solution for this coding contest problem.
You are given two integers A and B. Find the largest value among A+B, A-B and A \times B.
Constraints
* -1000 \leq A,B \leq 1000
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
A B
Output
Print the largest value among A+B, A-B and A \times B.
Examples
Input
3 1
Output
4
Input
4 -2
Output
6
Input
0 0
Output
0
"Correct Solution:
```
a,b=map(int,input().split())
ma=max(a+b,a-b,a*b)
print(ma)
```
| 96,799 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.