message stringlengths 2 39.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 219 108k | cluster float64 11 11 | __index_level_0__ int64 438 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
6
2
3
1
1
4
2
Output
Yes
Yes
Yes
No
Yes
No
Submitted Solution:
```
n = int(input())
M = 40
one = 0
rest = 2**M
for i in range(n):
x = int(input())
if x > M:
if not one:
if rest > 0:
print("Yes")
one = 1
rest -= 1
else:
print("No")
else:
print("Yes")
else:
val = 2**(M - x)
if val <= rest:
print("Yes")
rest -= val
else:
print("No")
``` | instruction | 0 | 41,146 | 11 | 82,292 |
No | output | 1 | 41,146 | 11 | 82,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
6
2
3
1
1
4
2
Output
Yes
Yes
Yes
No
Yes
No
Submitted Solution:
```
c=p=0;b=[0]*1000000
for _ in range(int(input())):
x=int(input())
if (c==x and p!=x) or b[0]==1 or c>x:print('NO');continue
print('YES')
if x>=1000000:continue
p+=1;b[x]+=1
while b[x]>1:p-=1;b[x]-=2;b[x-1]+=1;x-=1
while b[c+1]==1 and c<999999:c+=1
``` | instruction | 0 | 41,147 | 11 | 82,294 |
No | output | 1 | 41,147 | 11 | 82,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Example
Input
6
2
3
1
1
4
2
Output
Yes
Yes
Yes
No
Yes
No
Submitted Solution:
```
n = int(input())
bits = set()
count = 0
ans = []
for i in range(n):
x = int(input())
if x in bits:
y = x
while y in bits:
y -= 1
if y == 0 and count != x:
ans.append("No")
else:
bits.add(y)
if y == 0:
ans.append("Yes")
if i <= n-2:
ans.append("No\n"*(n-2-i) + "No")
break
count += 1
for i in range(y+1, x+1):
bits.remove(i)
count -= 1
ans.append("Yes")
else:
bits.add(x)
count += 1
ans.append("Yes")
print("\n".join(ans))
``` | instruction | 0 | 41,148 | 11 | 82,296 |
No | output | 1 | 41,148 | 11 | 82,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Entrance Examination
The International Competitive Programming College (ICPC) is famous for its research on competitive programming. Applicants to the college are required to take its entrance examination.
The successful applicants of the examination are chosen as follows.
* The score of any successful applicant is higher than that of any unsuccessful applicant.
* The number of successful applicants n must be between nmin and nmax, inclusive. We choose n within the specified range that maximizes the gap. Here, the gap means the difference between the lowest score of successful applicants and the highest score of unsuccessful applicants.
* When two or more candidates for n make exactly the same gap, use the greatest n among them.
Let's see the first couple of examples given in Sample Input below. In the first example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 82, 70, and 65. For n of two, three and four, the gaps will be 8, 12, and 5, respectively. We must choose three as n, because it maximizes the gap.
In the second example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 80, 75, and 65. For n of two, three and four, the gap will be 10, 5, and 10, respectively. Both two and four maximize the gap, and we must choose the greatest number, four.
You are requested to write a program that computes the number of successful applicants that satisfies the conditions.
Input
The input consists of multiple datasets. Each dataset is formatted as follows.
> m nmin nmax
> P1
> P2
> ...
> Pm
>
The first line of a dataset contains three integers separated by single spaces. m represents the number of applicants, nmin represents the minimum number of successful applicants, and nmax represents the maximum number of successful applicants. Each of the following m lines contains an integer Pi, which represents the score of each applicant. The scores are listed in descending order. These numbers satisfy 0 < nmin < nmax < m β€ 200, 0 β€ Pi β€ 10000 (1 β€ i β€ m) and Pnmin > Pnmax+1. These ensure that there always exists an n satisfying the conditions.
The end of the input is represented by a line containing three zeros separated by single spaces.
Output
For each dataset, output the number of successful applicants in a line.
Sample Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output for the Sample Input
3
4
2
2
3
2
Example
Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output
3
4
2
2
3
2
Submitted Solution:
```
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())
while True:
m,nmin,nmax = inpl()
if m == 0:
break
else:
pp = [int(input()) for _ in range(m)]
pp.sort(reverse=True)
ans = 0
ansgap = -1
for n in range(nmin,nmax+1):
gap = pp[n-1] - pp[n]
if ansgap <= gap:
ansgap = gap
ans = n
print(ans)
``` | instruction | 0 | 41,157 | 11 | 82,314 |
Yes | output | 1 | 41,157 | 11 | 82,315 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Entrance Examination
The International Competitive Programming College (ICPC) is famous for its research on competitive programming. Applicants to the college are required to take its entrance examination.
The successful applicants of the examination are chosen as follows.
* The score of any successful applicant is higher than that of any unsuccessful applicant.
* The number of successful applicants n must be between nmin and nmax, inclusive. We choose n within the specified range that maximizes the gap. Here, the gap means the difference between the lowest score of successful applicants and the highest score of unsuccessful applicants.
* When two or more candidates for n make exactly the same gap, use the greatest n among them.
Let's see the first couple of examples given in Sample Input below. In the first example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 82, 70, and 65. For n of two, three and four, the gaps will be 8, 12, and 5, respectively. We must choose three as n, because it maximizes the gap.
In the second example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 80, 75, and 65. For n of two, three and four, the gap will be 10, 5, and 10, respectively. Both two and four maximize the gap, and we must choose the greatest number, four.
You are requested to write a program that computes the number of successful applicants that satisfies the conditions.
Input
The input consists of multiple datasets. Each dataset is formatted as follows.
> m nmin nmax
> P1
> P2
> ...
> Pm
>
The first line of a dataset contains three integers separated by single spaces. m represents the number of applicants, nmin represents the minimum number of successful applicants, and nmax represents the maximum number of successful applicants. Each of the following m lines contains an integer Pi, which represents the score of each applicant. The scores are listed in descending order. These numbers satisfy 0 < nmin < nmax < m β€ 200, 0 β€ Pi β€ 10000 (1 β€ i β€ m) and Pnmin > Pnmax+1. These ensure that there always exists an n satisfying the conditions.
The end of the input is represented by a line containing three zeros separated by single spaces.
Output
For each dataset, output the number of successful applicants in a line.
Sample Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output for the Sample Input
3
4
2
2
3
2
Example
Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output
3
4
2
2
3
2
Submitted Solution:
```
def solver():
m, nmin, nmax = map(int, input().split())
if m == 0 and nmin == 0 and nmax == 0:
return None
p = [int(input()) for _ in range(m)]
ans = 0
maxdelta = 0
for a in range(nmin, nmax+1):
delta = p[a-1] - p[a]
if delta >= maxdelta:
maxdelta = delta
ans = a
return ans
outputs = []
while True:
ans = solver()
if ans == None:
break
outputs.append(ans)
print('\n'.join(map(str, outputs)))
``` | instruction | 0 | 41,158 | 11 | 82,316 |
Yes | output | 1 | 41,158 | 11 | 82,317 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Entrance Examination
The International Competitive Programming College (ICPC) is famous for its research on competitive programming. Applicants to the college are required to take its entrance examination.
The successful applicants of the examination are chosen as follows.
* The score of any successful applicant is higher than that of any unsuccessful applicant.
* The number of successful applicants n must be between nmin and nmax, inclusive. We choose n within the specified range that maximizes the gap. Here, the gap means the difference between the lowest score of successful applicants and the highest score of unsuccessful applicants.
* When two or more candidates for n make exactly the same gap, use the greatest n among them.
Let's see the first couple of examples given in Sample Input below. In the first example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 82, 70, and 65. For n of two, three and four, the gaps will be 8, 12, and 5, respectively. We must choose three as n, because it maximizes the gap.
In the second example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 80, 75, and 65. For n of two, three and four, the gap will be 10, 5, and 10, respectively. Both two and four maximize the gap, and we must choose the greatest number, four.
You are requested to write a program that computes the number of successful applicants that satisfies the conditions.
Input
The input consists of multiple datasets. Each dataset is formatted as follows.
> m nmin nmax
> P1
> P2
> ...
> Pm
>
The first line of a dataset contains three integers separated by single spaces. m represents the number of applicants, nmin represents the minimum number of successful applicants, and nmax represents the maximum number of successful applicants. Each of the following m lines contains an integer Pi, which represents the score of each applicant. The scores are listed in descending order. These numbers satisfy 0 < nmin < nmax < m β€ 200, 0 β€ Pi β€ 10000 (1 β€ i β€ m) and Pnmin > Pnmax+1. These ensure that there always exists an n satisfying the conditions.
The end of the input is represented by a line containing three zeros separated by single spaces.
Output
For each dataset, output the number of successful applicants in a line.
Sample Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output for the Sample Input
3
4
2
2
3
2
Example
Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output
3
4
2
2
3
2
Submitted Solution:
```
while 1:
m,nmi,nma=map(int,input().split())
if not m and not nmi and not nma:break
l=[int(input()) for _ in range(m)]
tg=[l[:i][-1]-l[i:][0] for i in range(nmi,nma+1)]
print(nma-tg[::-1].index(max(tg)))
``` | instruction | 0 | 41,159 | 11 | 82,318 |
Yes | output | 1 | 41,159 | 11 | 82,319 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Entrance Examination
The International Competitive Programming College (ICPC) is famous for its research on competitive programming. Applicants to the college are required to take its entrance examination.
The successful applicants of the examination are chosen as follows.
* The score of any successful applicant is higher than that of any unsuccessful applicant.
* The number of successful applicants n must be between nmin and nmax, inclusive. We choose n within the specified range that maximizes the gap. Here, the gap means the difference between the lowest score of successful applicants and the highest score of unsuccessful applicants.
* When two or more candidates for n make exactly the same gap, use the greatest n among them.
Let's see the first couple of examples given in Sample Input below. In the first example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 82, 70, and 65. For n of two, three and four, the gaps will be 8, 12, and 5, respectively. We must choose three as n, because it maximizes the gap.
In the second example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 80, 75, and 65. For n of two, three and four, the gap will be 10, 5, and 10, respectively. Both two and four maximize the gap, and we must choose the greatest number, four.
You are requested to write a program that computes the number of successful applicants that satisfies the conditions.
Input
The input consists of multiple datasets. Each dataset is formatted as follows.
> m nmin nmax
> P1
> P2
> ...
> Pm
>
The first line of a dataset contains three integers separated by single spaces. m represents the number of applicants, nmin represents the minimum number of successful applicants, and nmax represents the maximum number of successful applicants. Each of the following m lines contains an integer Pi, which represents the score of each applicant. The scores are listed in descending order. These numbers satisfy 0 < nmin < nmax < m β€ 200, 0 β€ Pi β€ 10000 (1 β€ i β€ m) and Pnmin > Pnmax+1. These ensure that there always exists an n satisfying the conditions.
The end of the input is represented by a line containing three zeros separated by single spaces.
Output
For each dataset, output the number of successful applicants in a line.
Sample Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output for the Sample Input
3
4
2
2
3
2
Example
Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output
3
4
2
2
3
2
Submitted Solution:
```
# coding: utf-8
while 1:
m,n_min,n_max=map(int,input().split())
if m==0:
break
data=[]
for i in range(m):
data.append(int(input()))
data=sorted(data,reverse=True)
mx=(-1,-1)
for i in range(n_min,n_max+1):
if data[i-1]-data[i]>=mx[0]:
mx=(data[i-1]-data[i],i)
print(mx[1])
``` | instruction | 0 | 41,160 | 11 | 82,320 |
Yes | output | 1 | 41,160 | 11 | 82,321 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Entrance Examination
The International Competitive Programming College (ICPC) is famous for its research on competitive programming. Applicants to the college are required to take its entrance examination.
The successful applicants of the examination are chosen as follows.
* The score of any successful applicant is higher than that of any unsuccessful applicant.
* The number of successful applicants n must be between nmin and nmax, inclusive. We choose n within the specified range that maximizes the gap. Here, the gap means the difference between the lowest score of successful applicants and the highest score of unsuccessful applicants.
* When two or more candidates for n make exactly the same gap, use the greatest n among them.
Let's see the first couple of examples given in Sample Input below. In the first example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 82, 70, and 65. For n of two, three and four, the gaps will be 8, 12, and 5, respectively. We must choose three as n, because it maximizes the gap.
In the second example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 80, 75, and 65. For n of two, three and four, the gap will be 10, 5, and 10, respectively. Both two and four maximize the gap, and we must choose the greatest number, four.
You are requested to write a program that computes the number of successful applicants that satisfies the conditions.
Input
The input consists of multiple datasets. Each dataset is formatted as follows.
> m nmin nmax
> P1
> P2
> ...
> Pm
>
The first line of a dataset contains three integers separated by single spaces. m represents the number of applicants, nmin represents the minimum number of successful applicants, and nmax represents the maximum number of successful applicants. Each of the following m lines contains an integer Pi, which represents the score of each applicant. The scores are listed in descending order. These numbers satisfy 0 < nmin < nmax < m β€ 200, 0 β€ Pi β€ 10000 (1 β€ i β€ m) and Pnmin > Pnmax+1. These ensure that there always exists an n satisfying the conditions.
The end of the input is represented by a line containing three zeros separated by single spaces.
Output
For each dataset, output the number of successful applicants in a line.
Sample Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output for the Sample Input
3
4
2
2
3
2
Example
Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output
3
4
2
2
3
2
Submitted Solution:
```
head = input().split(" ")
while head != "0 0 0":
num = int(head[0])
mini = int(head[1])
maxi = int(head[2])
scores = []
gaps = []
for _ in range(int(head[0])):
scores.append(int(input()))
for i in range(mini, maxi + 1):
oks = scores[:i]
ngs = scores[i:]
gap = oks[-1] - ngs[0]
gaps.append((i,gap))
filtered = list(filter(lambda x: x[1] == max(map(lambda x: x[1], gaps)), gaps))
sorted(filtered,key=lambda x: x[0])
print(filtered[-1][0])
``` | instruction | 0 | 41,161 | 11 | 82,322 |
No | output | 1 | 41,161 | 11 | 82,323 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Entrance Examination
The International Competitive Programming College (ICPC) is famous for its research on competitive programming. Applicants to the college are required to take its entrance examination.
The successful applicants of the examination are chosen as follows.
* The score of any successful applicant is higher than that of any unsuccessful applicant.
* The number of successful applicants n must be between nmin and nmax, inclusive. We choose n within the specified range that maximizes the gap. Here, the gap means the difference between the lowest score of successful applicants and the highest score of unsuccessful applicants.
* When two or more candidates for n make exactly the same gap, use the greatest n among them.
Let's see the first couple of examples given in Sample Input below. In the first example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 82, 70, and 65. For n of two, three and four, the gaps will be 8, 12, and 5, respectively. We must choose three as n, because it maximizes the gap.
In the second example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 80, 75, and 65. For n of two, three and four, the gap will be 10, 5, and 10, respectively. Both two and four maximize the gap, and we must choose the greatest number, four.
You are requested to write a program that computes the number of successful applicants that satisfies the conditions.
Input
The input consists of multiple datasets. Each dataset is formatted as follows.
> m nmin nmax
> P1
> P2
> ...
> Pm
>
The first line of a dataset contains three integers separated by single spaces. m represents the number of applicants, nmin represents the minimum number of successful applicants, and nmax represents the maximum number of successful applicants. Each of the following m lines contains an integer Pi, which represents the score of each applicant. The scores are listed in descending order. These numbers satisfy 0 < nmin < nmax < m β€ 200, 0 β€ Pi β€ 10000 (1 β€ i β€ m) and Pnmin > Pnmax+1. These ensure that there always exists an n satisfying the conditions.
The end of the input is represented by a line containing three zeros separated by single spaces.
Output
For each dataset, output the number of successful applicants in a line.
Sample Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output for the Sample Input
3
4
2
2
3
2
Example
Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output
3
4
2
2
3
2
Submitted Solution:
```
while 1:
m,nmi,nma=map(int,input().split())
if not m and not nmi and not nma:break
l=[int(input()) for _ in range(m)]
tg=[l[:i][-1]-l[i:][0] for i in range(nmi,nma+1)]
print(tg.index(max(tg))+nmi)
``` | instruction | 0 | 41,162 | 11 | 82,324 |
No | output | 1 | 41,162 | 11 | 82,325 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Entrance Examination
The International Competitive Programming College (ICPC) is famous for its research on competitive programming. Applicants to the college are required to take its entrance examination.
The successful applicants of the examination are chosen as follows.
* The score of any successful applicant is higher than that of any unsuccessful applicant.
* The number of successful applicants n must be between nmin and nmax, inclusive. We choose n within the specified range that maximizes the gap. Here, the gap means the difference between the lowest score of successful applicants and the highest score of unsuccessful applicants.
* When two or more candidates for n make exactly the same gap, use the greatest n among them.
Let's see the first couple of examples given in Sample Input below. In the first example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 82, 70, and 65. For n of two, three and four, the gaps will be 8, 12, and 5, respectively. We must choose three as n, because it maximizes the gap.
In the second example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 80, 75, and 65. For n of two, three and four, the gap will be 10, 5, and 10, respectively. Both two and four maximize the gap, and we must choose the greatest number, four.
You are requested to write a program that computes the number of successful applicants that satisfies the conditions.
Input
The input consists of multiple datasets. Each dataset is formatted as follows.
> m nmin nmax
> P1
> P2
> ...
> Pm
>
The first line of a dataset contains three integers separated by single spaces. m represents the number of applicants, nmin represents the minimum number of successful applicants, and nmax represents the maximum number of successful applicants. Each of the following m lines contains an integer Pi, which represents the score of each applicant. The scores are listed in descending order. These numbers satisfy 0 < nmin < nmax < m β€ 200, 0 β€ Pi β€ 10000 (1 β€ i β€ m) and Pnmin > Pnmax+1. These ensure that there always exists an n satisfying the conditions.
The end of the input is represented by a line containing three zeros separated by single spaces.
Output
For each dataset, output the number of successful applicants in a line.
Sample Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output for the Sample Input
3
4
2
2
3
2
Example
Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output
3
4
2
2
3
2
Submitted Solution:
```
head = input().split(" ")
while head != "0 0 0":
num = int(head[0])
mini = int(head[1])
maxi = int(head[2])
scores = []
gaps = []
for i in range(int(head[0])):
scores.append(int(input()))
for i in range(mini, maxi):
oks = scores[:i]
ngs = scores[i:]
gap = oks[-1] - ngs[0]
gaps.append((i,gap))
filtered = list(filter(lambda x: x[1] == max(gaps), gaps))
sorted(filtered, lambda x: x[0], True)
print(filtered[0][0])
``` | instruction | 0 | 41,163 | 11 | 82,326 |
No | output | 1 | 41,163 | 11 | 82,327 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Entrance Examination
The International Competitive Programming College (ICPC) is famous for its research on competitive programming. Applicants to the college are required to take its entrance examination.
The successful applicants of the examination are chosen as follows.
* The score of any successful applicant is higher than that of any unsuccessful applicant.
* The number of successful applicants n must be between nmin and nmax, inclusive. We choose n within the specified range that maximizes the gap. Here, the gap means the difference between the lowest score of successful applicants and the highest score of unsuccessful applicants.
* When two or more candidates for n make exactly the same gap, use the greatest n among them.
Let's see the first couple of examples given in Sample Input below. In the first example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 82, 70, and 65. For n of two, three and four, the gaps will be 8, 12, and 5, respectively. We must choose three as n, because it maximizes the gap.
In the second example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 80, 75, and 65. For n of two, three and four, the gap will be 10, 5, and 10, respectively. Both two and four maximize the gap, and we must choose the greatest number, four.
You are requested to write a program that computes the number of successful applicants that satisfies the conditions.
Input
The input consists of multiple datasets. Each dataset is formatted as follows.
> m nmin nmax
> P1
> P2
> ...
> Pm
>
The first line of a dataset contains three integers separated by single spaces. m represents the number of applicants, nmin represents the minimum number of successful applicants, and nmax represents the maximum number of successful applicants. Each of the following m lines contains an integer Pi, which represents the score of each applicant. The scores are listed in descending order. These numbers satisfy 0 < nmin < nmax < m β€ 200, 0 β€ Pi β€ 10000 (1 β€ i β€ m) and Pnmin > Pnmax+1. These ensure that there always exists an n satisfying the conditions.
The end of the input is represented by a line containing three zeros separated by single spaces.
Output
For each dataset, output the number of successful applicants in a line.
Sample Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output for the Sample Input
3
4
2
2
3
2
Example
Input
5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0
Output
3
4
2
2
3
2
Submitted Solution:
```
while True:
P = list()
ans = list()
tans = list()
m, Mn, Mx = map(int, input().split())
if m == 0 and Mn == 0 and Mx == 0:
break
for i in range(0, m):
P.append(int(input()))
for j in range(Mn-1, Mx, 1):
ans.append(P[j]-P[j+1])
print(ans)
for k in range(0,len(ans)):
if ans[k] == max(ans):
tans.append(k)
print(tans)
print(max(tans)+Mn)
``` | instruction | 0 | 41,164 | 11 | 82,328 |
No | output | 1 | 41,164 | 11 | 82,329 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n Γ m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 Γ 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most nm operations. You don't need to minimize the number of operations.
It can be proved, that it is always possible.
Input
The first line contains a single integer t (1 β€ t β€ 5000) β the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 β€ n, m β€ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed, that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 β€ k β€ nm) β the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 β€ x_1, x_2, x_3 β€ n, 1 β€ y_1, y_2, y_3 β€ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong to some 2 Γ 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
_str = str
BUFSIZE = 8192
def str(x=b''):
return x if type(x) is bytes else _str(x).encode()
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
def inp():
return sys.stdin.readline().rstrip()
def mpint():
return map(int, inp().split(' '))
def itg():
return int(inp())
# ############################## import
class State:
def __init__(self, state, operations):
self.states_num = {state: 0}
self.states = [state]
self._path = {}
self.DIAMETER = 0
new_sts = [0]
while new_sts:
self.DIAMETER += 1
cur_sts, new_sts = new_sts, []
for i in cur_sts:
for op, f in enumerate(operations):
state = f(self.states[i])
if state not in self.states_num:
j = self.states_num[state] = len(self.states)
self.states.append(state)
new_sts.append(j)
else:
j = self.states_num[state]
self._path[(i, j)] = (i, op)
self.SIZE = n = len(self.states_num)
self.distance = dis = [[0 if i == j else 10 ** 6 for i in range(n)] for j in range(n)]
for i, j in self._path.keys():
self.distance[i][j] = 1
for k in range(n):
for i in range(n):
for j in range(n):
if dis[i][k] + dis[k][j] < dis[i][j]:
dis[i][j] = dis[i][k] + dis[k][j]
self._path[(i, j)] = self._path[(k, j)]
def path(self, st1, st2):
u = self.states_num[st1]
v = self.states_num[st2]
result = []
while u != v:
v, op = self._path[(u, v)]
result.append(op)
return result[::-1]
def min_path(self, st1, states):
result = [-1] * self.DIAMETER
choice = -1
for i, st2 in enumerate(states):
path = self.path(st1, st2)
if len(path) < len(result):
result = path
choice = i
return result, choice
# ############################## main
def op0(st):
# left top
return st[0], st[1] ^ 1, st[2] ^ 1, st[3] ^ 1
def op1(st):
# right top
return st[0] ^ 1, st[1], st[2] ^ 1, st[3] ^ 1
def op2(st):
# left bottom
return st[0] ^ 1, st[1] ^ 1, st[2], st[3] ^ 1
def op3(st):
# right bottom
return st[0] ^ 1, st[1] ^ 1, st[2] ^ 1, st[3]
zero = (0, 0, 0, 0)
ST = State(zero, (op0, op1, op2, op3))
right_zero = (zero, (0, 0, 1, 0), (1, 0, 0, 0), (1, 0, 1, 0))
bottom_zero = (zero, (0, 1, 0, 0), (1, 0, 0, 0), (1, 1, 0, 0))
def solve():
n, m = mpint()
matrix = [list(map(int, inp())) for _ in range(n)]
output = []
if m & 1:
# deal with right column
for i in range(n - 1):
y, x = i, m - 2
st = (matrix[y][x], matrix[y][x + 1], matrix[y + 1][x], matrix[y + 1][x + 1])
path, choice = ST.min_path(st, right_zero)
matrix[y][x], matrix[y][x + 1], matrix[y + 1][x], matrix[y + 1][x + 1] = right_zero[choice]
y += 1
x += 1
for op in path:
pos = [y, x, y, x + 1, y + 1, x, y + 1, x + 1]
del pos[op << 1], pos[op << 1]
output.append(pos)
# for l in matrix:
# print(*l)
# print()
if n & 1:
# deal with bottom row
for j in range(m - 1 - (m & 1)):
y, x = n - 2, j
st = (matrix[y][x], matrix[y][x + 1], matrix[y + 1][x], matrix[y + 1][x + 1])
path, choice = ST.min_path(st, bottom_zero)
matrix[y][x], matrix[y][x + 1], matrix[y + 1][x], matrix[y + 1][x + 1] = bottom_zero[choice]
y += 1
x += 1
for op in path:
pos = [y, x, y, x + 1, y + 1, x, y + 1, x + 1]
del pos[op << 1], pos[op << 1]
output.append(pos)
# for l in matrix:
# print(*l)
# print()
for i in range(n >> 1):
for j in range(m >> 1):
# left top position
y, x = i << 1, j << 1
st = (matrix[y][x], matrix[y][x + 1], matrix[y + 1][x], matrix[y + 1][x + 1])
pos = [y, x, y, x + 1, y + 1, x, y + 1, x + 1]
for k in range(4):
matrix[pos[k * 2]][pos[k * 2 + 1]] = 0
y += 1
x += 1
for op in ST.path(st, zero):
pos = [y, x, y, x + 1, y + 1, x, y + 1, x + 1]
del pos[op << 1], pos[op << 1]
output.append(pos)
assert len(output) <= n * m
# for l in matrix:
# print(*l)
# assert not any(l)
print(len(output))
for out in output:
print(*out)
def main():
# solve()
# print(solve())
for _ in range(itg()):
solve()
# print("YES" if solve() else "NO")
# print("yes" if solve() else "no")
DEBUG = 0
URL = ''
if __name__ == '__main__':
if DEBUG == 1:
import requests # ImportError: cannot import name 'md5' from 'sys' (unknown location)
from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
runner = TestCaseRunner(main, URL)
inp = runner.input_stream
print = runner.output_stream
runner.checking()
elif DEBUG == 2:
main()
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
main()
# Please check!
``` | instruction | 0 | 41,473 | 11 | 82,946 |
Yes | output | 1 | 41,473 | 11 | 82,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n Γ m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 Γ 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most nm operations. You don't need to minimize the number of operations.
It can be proved, that it is always possible.
Input
The first line contains a single integer t (1 β€ t β€ 5000) β the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 β€ n, m β€ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed, that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 β€ k β€ nm) β the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 β€ x_1, x_2, x_3 β€ n, 1 β€ y_1, y_2, y_3 β€ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong to some 2 Γ 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
Submitted Solution:
```
import io
import os
#input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
def solve():
n, m = map(int, input().split())
vals = []
for _ in range(n):
vals.append(list(map(int, input())))
ops = []
def flip(x1, y1, x2, y2, x3, y3):
for a, b in ([x1, y1], [x2, y2], [x3, y3]):
vals[b][a] = 1 - vals[b][a]
ops.append((y1+1, x1+1, y2+1, x2+1, y3+1, x3+1))
for y in range(n-2):
for x in range(m):
if x == m-1:
if vals[y][x]:
flip(x, y, x, y+1, x-1, y+1)
else:
if vals[y][x]:
flip(x, y, x, y+1, x+1, y+1)
for x in range(m-2):
if vals[n-2][x]:
flip(x, n-2, x+1, n-2, x+1, n-1)
if vals[n-1][x]:
flip(x, n-1, x+1, n-2, x+1, n-1)
# a b
# c d
a = m-2, n-2
b = m-1, n-2
c = m-2, n-1
d = m-1, n-1
def last():
return [vals[y][x] for x, y in [a, b, c, d]]
if sum(last()) == 4:
flip(*a, *b, *c)
if sum(last()) == 1:
i = last().index(1)
if i == 0:
flip(*a, *b, *c)
elif i == 1:
flip(*b, *d, *c)
elif i == 2:
flip(*a, *c, *d)
else:
flip(*b, *d, *c)
if sum(last()) == 2:
if last() == [1, 1, 0, 0]:
flip(*a, *c, *d)
elif last() == [1, 0, 1, 0]:
flip(*a, *b, *d)
elif last() == [1, 0, 0, 1]:
flip(*a, *b, *c)
elif last() == [0, 1, 1, 0]:
flip(*a, *b, *d)
elif last() == [0, 1, 0, 1]:
flip(*a, *b, *c)
else:
flip(*a, *b, *c)
if sum(last()) == 3:
i = last().index(0)
if i == 0:
flip(*b, *c, *d)
elif i == 1:
flip(*a, *c, *d)
elif i == 2:
flip(*a, *b, *d)
else:
flip(*a, *b, *c)
for row in vals:
assert(not any(row))
print(len(ops))
for op in ops:
print(*op)
t = int(input())
for _ in range(t):
solve()
``` | instruction | 0 | 41,474 | 11 | 82,948 |
Yes | output | 1 | 41,474 | 11 | 82,949 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n Γ m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 Γ 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most nm operations. You don't need to minimize the number of operations.
It can be proved, that it is always possible.
Input
The first line contains a single integer t (1 β€ t β€ 5000) β the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 β€ n, m β€ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed, that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 β€ k β€ nm) β the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 β€ x_1, x_2, x_3 β€ n, 1 β€ y_1, y_2, y_3 β€ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong to some 2 Γ 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
Submitted Solution:
```
import math
a=int(input())
arr=[]
n,m=0,0
def flip(i):
if(i==0):
return 1
return 0
def p(ans):
print(len(ans))
for i in range(0,len(ans)):
for j in range(0,len(ans[0])):
ans[i][j]=ans[i][j]+1
for i in ans:
print(' '.join(map(str,i)))
def o1(temp):
temp.append([n-2,m-2,n-2,m-1,n-1,m-1])
arr[n-2][m-2]=flip(arr[n-2][m-2])
arr[n-2][m-1]=flip(arr[n-2][m-1])
arr[n-1][m-1]=flip(arr[n-1][m-1])
def o2(temp):
temp.append([n-1,m-1,n-2,m-1,n-1,m-2])
arr[n-1][m-1]=flip(arr[n-1][m-1])
arr[n-2][m-1]=flip(arr[n-2][m-1])
arr[n-1][m-2]=flip(arr[n-1][m-2])
def o3(temp):
temp.append([n-1,m-1,n-1,m-2,n-2,m-2])
arr[n-1][m-1]=flip(arr[n-1][m-1])
arr[n-1][m-2]=flip(arr[n-1][m-2])
arr[n-2][m-2]=flip(arr[n-2][m-2])
def o4(temp):
temp.append([n-2,m-2,n-1,m-2,n-2,m-1])
arr[n-2][m-2]=flip(arr[n-2][m-2])
arr[n-1][m-2]=flip(arr[n-1][m-2])
arr[n-2][m-1]=flip(arr[n-2][m-1])
for i in range(a):
n,m=map(int,input().split())
arr=[]
for i in range(n):
s=input()
arr.append([int(i) for i in s])
ans=[]
for i in range(0,n-2):
for j in range(0,m):
if(arr[i][j]==1 and j<m-1):
ans.append([i,j,i,j+1,i+1,j])
arr[i][j]=flip(arr[i][j])
arr[i][j+1]=flip(arr[i][j+1])
arr[i+1][j]=flip(arr[i+1][j])
elif(arr[i][j]==1):
ans.append([i,j,i+1,j,i+1,j-1])
arr[i][j]=flip(arr[i][j])
arr[i+1][j]=flip(arr[i+1][j])
arr[i+1][j-1]=flip(arr[i+1][j-1])
for j in range(0,m-2):
for i in range(n-2,n):
if(arr[i][j]==1):
if(i==n-2):
ans.append([i,j,i,j+1,i+1,j+1])
arr[i][j]=flip(arr[i][j])
arr[i][j+1]=flip(arr[i][j+1])
arr[i+1][j+1]=flip(arr[i+1][j+1])
else:
ans.append([i,j,i,j+1,i-1,j+1])
arr[i][j]=flip(arr[i][j])
arr[i][j+1]=flip(arr[i][j+1])
arr[i-1][j+1]=flip(arr[i-1][j+1])
su=0
for i in range(n-2,n):
for j in range(m-2,m):
su=su+arr[i][j]
if(su==0):
p(ans)
if(su==1):
if(arr[n-2][m-2]==1):
o1(ans)
o3(ans)
o4(ans)
p(ans)
if(arr[n-1][m-1]==1):
o1(ans)
o2(ans)
o3(ans)
p(ans)
if(arr[n-2][m-1]==1):
o2(ans)
o1(ans)
o4(ans)
p(ans)
if(arr[n-1][m-2]==1):
o4(ans)
o2(ans)
o3(ans)
p(ans)
if(su==2):
if(arr[n-2][m-2]==1 and arr[n-2][m-1]==1):
o2(ans)
o3(ans)
if(arr[n-2][m-2]==1 and arr[n-1][m-2]==1):
o1(ans)
o2(ans)
if(arr[n-1][m-1]==1 and arr[n-2][m-1]==1):
o3(ans)
o4(ans)
if(arr[n-1][m-1]==1 and arr[n-1][m-2]==1):
o4(ans)
o1(ans)
if(arr[n-1][m-1]==1 and arr[n-2][m-2]==1):
o2(ans)
o4(ans)
if(arr[n-2][m-1]==1 and arr[n-1][m-2]==1):
o1(ans)
o3(ans)
p(ans)
if(su==4):
o2(ans)
o1(ans)
o3(ans)
o4(ans)
p(ans)
if(su==3):
temp=[]
for i in range(n-2,n):
for j in range(m-2,m):
if(arr[i][j]==1):
temp.append(i)
temp.append(j)
ans.append(temp)
p(ans)
``` | instruction | 0 | 41,475 | 11 | 82,950 |
Yes | output | 1 | 41,475 | 11 | 82,951 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n Γ m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 Γ 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most nm operations. You don't need to minimize the number of operations.
It can be proved, that it is always possible.
Input
The first line contains a single integer t (1 β€ t β€ 5000) β the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 β€ n, m β€ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed, that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 β€ k β€ nm) β the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 β€ x_1, x_2, x_3 β€ n, 1 β€ y_1, y_2, y_3 β€ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong to some 2 Γ 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
Submitted Solution:
```
import copy
def two_two_solver(mat, i, j, ans):
oneind = []
zeroind = []
for x in range(i, i+2):
for y in range(j, j+2):
if mat[x][y] == '1':
oneind += [[x, y]]
else:
zeroind += [[x, y]]
if len(oneind) == 0:
return
if len(oneind) == 4:
newoneind = [oneind[0][:]]
newzeroind = [oneind[1][:], oneind[2][:], oneind[3][:]]
ans += [[oneind[1][:], oneind[2][:], oneind[3][:]]]
oneind = copy.deepcopy(newoneind)
zeroind = copy.deepcopy(newzeroind)
if len(oneind) == 1:
newoneind = [zeroind[0][:], zeroind[1][:]]
newzeroind = [zeroind[2][:], oneind[0][:]]
ans += [[zeroind[0][:], zeroind[1][:], oneind[0][:]]]
oneind = copy.deepcopy(newoneind)
zeroind = copy.deepcopy(newzeroind)
if len(oneind) == 2:
newoneind = [zeroind[0][:], zeroind[1][:], oneind[0][:]]
newzeroind = [oneind[1][:]]
ans += [[zeroind[0][:], zeroind[1][:], oneind[1][:]]]
oneind = copy.deepcopy(newoneind)
zeroind = copy.deepcopy(newzeroind)
if len(oneind) == 3:
ans += [[oneind[0][:], oneind[1][:], oneind[2][:]]]
for x in range(i, i+2):
for y in range(j, j+2):
mat[x][y] = '0'
def three_two_solver(mat, i, j, ans):
oneind = []
zeroind = []
for x in range(i, i+2):
for y in range(j, j+2):
if mat[x][y] == '1':
oneind += [[x, y]]
else:
zeroind += [[x, y]]
oneind2 = []
zeroind2 = []
for x in range(i, i+2):
for y in range(j+1, j+3):
if mat[x][y] == '1':
oneind2 += [[x, y]]
else:
zeroind2 += [[x, y]]
if len(oneind2) < len(oneind):
two_two_solver(mat, i, j+1, ans)
two_two_solver(mat, i, j, ans)
else:
two_two_solver(mat, i, j, ans)
two_two_solver(mat, i, j+1, ans)
def two_three_solver(mat, i, j, ans):
oneind = []
zeroind = []
for x in range(i, i+2):
for y in range(j, j+2):
if mat[x][y] == '1':
oneind += [[x, y]]
else:
zeroind += [[x, y]]
oneind2 = []
zeroind2 = []
for x in range(i+1, i+3):
for y in range(j, j+2):
if mat[x][y] == '1':
oneind2 += [[x, y]]
else:
zeroind2 += [[x, y]]
if len(oneind2) < len(oneind):
two_two_solver(mat, i+1, j, ans)
two_two_solver(mat, i, j, ans)
else:
two_two_solver(mat, i, j, ans)
two_two_solver(mat, i+1, j, ans)
t = int(input())
for _ in range(t):
n, m = map(int, input().split())
mat = []
for i in range(n):
s = input()
mat += [[x for x in s]]
# print(mat)
ans = []
if n%2 == 0 and m%2 == 0:
for i in range(0, n-1, 2):
for j in range(0, m-1, 2):
two_two_solver(mat, i, j, ans)
elif n%2 == 0 and m%2 == 1:
for i in range(0, n-1, 2):
for j in range(0, m-3, 2):
two_two_solver(mat, i, j, ans)
three_two_solver(mat, i, m-3, ans)
elif n%2 == 1 and m%2 == 0:
for i in range(0, n-3, 2):
for j in range(0, m-1, 2):
two_two_solver(mat, i, j, ans)
for j in range(0, m-1, 2):
two_three_solver(mat, n-3, j, ans)
else:
if mat[n-1][m-1] == '1':
ans += [[[n-1, m-1], [n-2, m-1], [n-1, m-2]]]
mat[n-1][m-1] = '0'
if mat[n-2][m-1] == '1':
mat[n-2][m-1] = '0'
else:
mat[n-2][m-1] = '1'
if mat[n-1][m-2] == '1':
mat[n-1][m-2] = '0'
else:
mat[n-1][m-2] = '1'
if mat[n-1][m-2] == '1':
ans += [[[n-1, m-2], [n-2, m-2], [n-1, m-3]]]
mat[n-1][m-2] = '0'
if mat[n-2][m-2] == '1':
mat[n-2][m-2] = '0'
else:
mat[n-2][m-2] = '1'
if mat[n-1][m-3] == '1':
mat[n-1][m-3] = '0'
else:
mat[n-1][m-3] = '1'
if mat[n-1][m-3] == '1':
ans += [[[n-1, m-3], [n-2, m-3], [n-2, m-2]]]
mat[n-1][m-3] = '0'
if mat[n-2][m-3] == '1':
mat[n-2][m-3] = '0'
else:
mat[n-2][m-3] = '1'
if mat[n-2][m-2] == '1':
mat[n-2][m-2] = '0'
else:
mat[n-2][m-2] = '1'
for i in range(0, n-3, 2):
for j in range(0, m-3, 2):
two_two_solver(mat, i, j, ans)
for i in range(0, n-1, 2):
three_two_solver(mat, i, m-3, ans)
for j in range(0, m-1, 2):
two_three_solver(mat, n-3, j, ans)
# three_two_solver(mat,n-3, m-3,)
print(len(ans))
for x in ans:
# print(*x)
for y in x:
print(y[0]+1, y[1]+1, end=' ')
print('')
``` | instruction | 0 | 41,476 | 11 | 82,952 |
Yes | output | 1 | 41,476 | 11 | 82,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n Γ m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 Γ 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most nm operations. You don't need to minimize the number of operations.
It can be proved, that it is always possible.
Input
The first line contains a single integer t (1 β€ t β€ 5000) β the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 β€ n, m β€ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed, that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 β€ k β€ nm) β the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 β€ x_1, x_2, x_3 β€ n, 1 β€ y_1, y_2, y_3 β€ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong to some 2 Γ 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
Submitted Solution:
```
for _ in range(int(input())):
m, n = map(int, input().split())
A = [[0] * (n + 1)] + [[0] + list(map(int, list(input()))) for _ in range(m)]
ans = []
for i in range(1, m, 2):
for j in range(1, n):
tmp = [A[i][j], A[i + 1][j]]
if tmp == [0, 0]: continue
if tmp == [1, 1]:
ans.append([i, j, i, j + 1, i + 1, j])
A[i][j] ^= 1
A[i][j + 1] ^= 1
A[i + 1][j] ^= 1
elif tmp == [1, 0]:
ans.append([i, j, i, j + 1, i + 1, j])
A[i][j] ^= 1
A[i][j + 1] ^= 1
A[i + 1][j] ^= 1
ans.append([i + 1, j, i + 1, j + 1, i, j + 1])
A[i + 1][j] ^= 1
A[i + 1][j + 1] ^= 1
A[i][j + 1] ^= 1
elif tmp == [0, 1]:
ans.append([i, j, i, j + 1, i + 1, j])
A[i][j] ^= 1
A[i][j + 1] ^= 1
A[i + 1][j] ^= 1
ans.append([i, j, i, j + 1, i + 1, j + 1])
A[i][j] ^= 1
A[i][j + 1] ^= 1
A[i + 1][j + 1] ^= 1
tmp = [A[i][n], A[i + 1][n]]
if tmp == [0, 1]:
ans.append([i, n - 1, i, n, i + 1, n])
ans.append([i, n, i + 1, n, i + 1, n - 1])
ans.append([i, n - 1, i + 1, n - 1, i + 1, n])
elif tmp == [1, 0]:
ans.append([i, n - 1, i, n, i + 1, n])
ans.append([i, n, i + 1, n, i + 1, n - 1])
ans.append([i, n - 1, i + 1, n - 1, i, n - 1])
elif tmp == [1, 1]:
ans.append([i, n - 1, i, n, i + 1, n])
ans.append([i + 1, n - 1, i + 1, n, i, n])
A[i][n] = A[i + 1][n] = 0
if m % 2:
for j in range(1, n, 2):
tmp = [A[m][j], A[m][j + 1]]
if tmp == [1, 0]:
ans.append([m - 1, j, m, j, m, j + 1])
ans.append([m, j, m, j + 1, m - 1, j + 1])
ans.append([m - 1, j, m - 1, j + 1, m, j])
elif tmp == [0, 1]:
ans.append([m - 1, j, m, j, m, j + 1])
ans.append([m, j, m, j + 1, m - 1, j + 1])
ans.append([m - 1, j, m - 1, j + 1, m, j + 1])
elif tmp == [1, 1]:
ans.append([m - 1, j, m - 1, j + 1, m, j])
ans.append([m - 1, j, m - 1, j + 1, m, j + 1])
A[m][j] = A[m][j + 1] = 0
if n % 2 and m % 2 and A[-1][-1]:
ans.append([m, n, m - 1, n, m, n - 1])
ans.append([m - 1, n - 1, m - 1, n, m, n])
ans.append([m - 1, n - 1, m, n - 1, m, n])
A[-1][-1] = 0
print(len(ans))
for a in ans: print(*a)
``` | instruction | 0 | 41,477 | 11 | 82,954 |
No | output | 1 | 41,477 | 11 | 82,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n Γ m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 Γ 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most nm operations. You don't need to minimize the number of operations.
It can be proved, that it is always possible.
Input
The first line contains a single integer t (1 β€ t β€ 5000) β the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 β€ n, m β€ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed, that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 β€ k β€ nm) β the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 β€ x_1, x_2, x_3 β€ n, 1 β€ y_1, y_2, y_3 β€ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong to some 2 Γ 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
_str = str
BUFSIZE = 8192
def str(x=b''):
return x if type(x) is bytes else _str(x).encode()
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
def inp():
return sys.stdin.readline().rstrip()
def mpint():
return map(int, inp().split(' '))
def itg():
return int(inp())
# ############################## import
class State:
def __init__(self, state, operations):
self.states_num = {state: 0}
self.states = [state]
self._path = {}
self.DIAMETER = 0
new_sts = [0]
while new_sts:
self.DIAMETER += 1
cur_sts, new_sts = new_sts, []
for i in cur_sts:
for op, f in enumerate(operations):
state = f(self.states[i])
if state not in self.states_num:
j = self.states_num[state] = len(self.states)
self.states.append(state)
new_sts.append(j)
else:
j = self.states_num[state]
self._path[(i, j)] = (i, op)
self.SIZE = n = len(self.states_num)
self.distance = dis = [[0 if i == j else 10 ** 6 for i in range(n)] for j in range(n)]
for i, j in self._path.keys():
self.distance[i][j] = 1
for k in range(n):
for i in range(n):
for j in range(n):
if dis[i][k] + dis[k][j] < dis[i][j]:
dis[i][j] = dis[i][k] + dis[k][j]
self._path[(i, j)] = self._path[(k, j)]
def path(self, st1, st2):
u = self.states_num[st1]
v = self.states_num[st2]
result = []
while u != v:
v, op = self._path[(u, v)]
result.append(op)
return result[::-1]
# ############################## main
def op0(st):
# left top
return st[0], st[1] ^ 1, st[2] ^ 1, st[3] ^ 1
def op1(st):
# right top
return st[0] ^ 1, st[1], st[2] ^ 1, st[3] ^ 1
def op2(st):
# left bottom
return st[0] ^ 1, st[1] ^ 1, st[2], st[3] ^ 1
def op3(st):
# right bottom
return st[0] ^ 1, st[1] ^ 1, st[2] ^ 1, st[3]
zero = (0, 0, 0, 0)
ST = State(zero, (op0, op1, op2, op3))
def solve():
n, m = mpint()
matrix = [list(map(int, inp())) for _ in range(n)]
output = []
for i in range(n):
for j in range(m):
# left top position
if matrix[i][j] == 0:
continue
y, x = i, j
if y + 1 >= n:
y = n - 2
if x + 1 >= m:
x = m - 2
st = (matrix[y][x], matrix[y][x + 1], matrix[y + 1][x], matrix[y + 1][x + 1])
pos = [y, x, y, x + 1, y + 1, x, y + 1, x + 1]
for k in range(4):
matrix[pos[k * 2]][pos[k * 2 + 1]] = 0
y += 1
x += 1
for op in ST.path(st, zero):
pos = [y, x, y, x + 1, y + 1, x, y + 1, x + 1]
del pos[op << 1], pos[op << 1]
output.append(pos)
print(len(output))
for out in output:
print(*out)
def main():
# solve()
# print(solve())
for _ in range(itg()):
solve()
# print("YES" if solve() else "NO")
# print("yes" if solve() else "no")
DEBUG = 0
URL = ''
if __name__ == '__main__':
if DEBUG == 1:
import requests # ImportError: cannot import name 'md5' from 'sys' (unknown location)
from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
runner = TestCaseRunner(main, URL)
inp = runner.input_stream
print = runner.output_stream
runner.checking()
elif DEBUG == 2:
main()
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
main()
# Please check!
``` | instruction | 0 | 41,478 | 11 | 82,956 |
No | output | 1 | 41,478 | 11 | 82,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n Γ m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 Γ 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most nm operations. You don't need to minimize the number of operations.
It can be proved, that it is always possible.
Input
The first line contains a single integer t (1 β€ t β€ 5000) β the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 β€ n, m β€ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed, that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 β€ k β€ nm) β the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 β€ x_1, x_2, x_3 β€ n, 1 β€ y_1, y_2, y_3 β€ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong to some 2 Γ 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
Submitted Solution:
```
def revab(b):
for i in range(3):
rev(b[2*i],b[2*i+1])
def rev(x,y):
global c
if c[x-1][y-1]=="1":
c[x-1][y-1]="0"
else:
c[x-1][y-1]="1"
import sys
for _ in range(int(sys.stdin.readline())):
a= list(map(int,sys.stdin.readline().strip().split(" ")))
c=[]
for i in range(a[0]):
c.append(list(sys.stdin.readline().strip()))
opn=0
ops=[]
a[0]-=1
while a[0]>1:
for i in range(a[1]-1):
if c[a[0]][i]=="1":
opn+=1
ops.append([a[0]+1,i+1,a[0],i+1,a[0],i+2])
revab(ops[-1])
if c[a[0]][a[1]-1]=="1":
opn+=1
ops.append([a[0]+1,a[1],a[0],a[1]-1,a[0],a[1]])
revab(ops[-1])
a[0]-=1
a[1]-=1
while a[1]>1:
if c[0][a[1]]=="1" and c[1][a[1]]=="1":
opn+=1
ops.append([1,a[1]+1,2,a[1]+1,1,a[1]])
revab(ops[-1])
elif c[0][a[1]]=="1":
opn+=1
ops.append([1,a[1],2,a[1],1,a[1]+1])
revab(ops[-1])
elif c[1][a[1]]=="1":
opn+=1
ops.append([2,a[1],1,a[1],2,a[1]+1])
revab(ops[-1])
a[1]-=1
if c[0][0]=="0":
opn+=1
ops.append([1,2,2,1,2,2])
if c[1][0]=="0":
opn+=1
ops.append([1,2,1,1,2,2])
if c[0][1]=="0":
opn+=1
ops.append([1,1,2,1,2,2])
if c[1][1]=="0":
opn+=1
ops.append([1,2,2,1,1,1])
print(opn)
for i in ops:
print(" ".join(list(map(str,i))))
``` | instruction | 0 | 41,479 | 11 | 82,958 |
No | output | 1 | 41,479 | 11 | 82,959 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n Γ m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 Γ 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most nm operations. You don't need to minimize the number of operations.
It can be proved, that it is always possible.
Input
The first line contains a single integer t (1 β€ t β€ 5000) β the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 β€ n, m β€ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed, that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 β€ k β€ nm) β the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 β€ x_1, x_2, x_3 β€ n, 1 β€ y_1, y_2, y_3 β€ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong to some 2 Γ 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
Submitted Solution:
```
def correct(x, y):
a[x][y] = 0
ans.append([x+1, y+1, x+2, y+1, x+2, y+2])
a[x+1][y+1] = 1 - a[x+1][y+1]
a[x+1][y] = 1 - a[x+1][y]
def makeone(i):
a[-1][i] = a[-1][i+1] = a[-2][i] = a[-2][i+1] = 0
def one(i):
if a[-2][i]:
ans.append([n-1, i+2, n, i+1, n-1, i+1])
a[-2][i] = 0
a[-2][i+1] = a[-1][i] = 1
elif a[-2][i+1]:
ans.append([n-1, i+1, n, i+1, n-1, i+2])
a[-2][i+1] = 0
a[-2][i] = a[-1][i] = 1
elif a[-1][i]:
ans.append([n-1, i+1, n-1, i+2, n, i+1])
a[-1][i] = 0
a[-2][i] = a[-2][i+1] = 1
else:
ans.append([n-1, i+1, n-1, i+2, n, i+2])
a[-1][i+1] = 0
a[-2][i] = a[-2][i+1] = 1
two(i)
def two(i):
if a[-1][i]:
if a[-1][i+1]:
ans.append([n-1, i+1, n-1, i+2, n, i+1])
ans.append([n-1, i+1, n-1, i+2, n, i+2])
elif a[-2][i+1]:
ans.append([n-1, i+2, n, i+2, n, i+1])
ans.append([n-1, i+2, n, i+1, n, i+2])
elif a[-2][i+2]:
ans.append([n-1, i+1, n-1, i+2, n, i+2])
ans.append([n-1, i+1, n, i+1, n, i+2])
elif a[-2][i]:
if a[-2][i+1]:
ans.append([n-1, i+2, n, i+2, n, i+1])
ans.append([n-1, i+2, n, i+1, n, i+2])
elif a[-1][i+1]:
ans.append([n-1, i+2, n, i+2, n, i+1])
ans.append([n-1, i+1, n-1, i+2, n, i+1])
else:
ans.append([n-1, i+1, n-1, i+2, n, i+1])
ans.append([n-1, i+1, n, i+1, n, i+2])
makeone(i)
def final(i, c):
if c==1:
one(i)
elif c==4:
ans.append([n-1, i+2, n, i+1, n, i+2])
a[n-2][i+1] = a[n-1][i] = a[n-1][i+1] = 0
one(i)
elif c==3:
if not a[-2][i]:
ans.append([n-1, i+2, n, i+1, n, i+2])
elif not a[-2][i+1]:
ans.append([n-1, i+1, n, i+1, n, i+2])
elif not a[-1][i]:
ans.append([n-1, i+1, n-1, i+2, n, i+2])
else:
ans.append([n-1, i+1, n-1, i+2, n, i+1])
makeone(i)
elif c==2:
two(i)
def count(i):
c = 0
if a[-1][i]:
c += 1
if a[-1][i+1]:
c += 1
if a[-2][i]:
c += 1
if a[-2][i+1]:
c += 1
final(i, c)
for nt in range(int(input())):
n,m = map(int,input().split())
a, ans = [], []
for i in range(n):
a.append(list(map(int,list(input()))))
for i in range(n-2):
for j in range(m-1):
if a[i][j]==1:
correct(i, j)
if a[i][-1] == 1:
ans.append([i+1, m, i+2, m, i+2, m-1])
a[i][-1] = 0
a[i+1][-1] = 1 - a[i+1][-1]
a[i+1][-2] = 1 - a[i+1][-2]
# print (a)
if m%2:
if a[-1][-1] and a[-2][-1]:
for i in range(0, m-1, 2):
count(i)
count(m-2)
elif not a[-1][-1] and not a[-2][-1]:
for i in range(0, m-1, 2):
count(i)
else:
for i in range(0, m-3, 2):
count(i)
# print (a)
if a[-1][-1]:
ans.append([n-1, m-1, n, m-1, n, m])
a[-2][-2] = 1 - a[-2][-2]
a[-1][-2] = 1 - a[-1][-2]
a[-1][-1] = 0
count(m-3)
else:
ans.append([n-1, m-1, n, m-1, n-1, m])
a[-2][-2] = 1 - a[-2][-2]
a[-1][-2] = 1 - a[-1][-2]
a[-2][-1] = 0
count(m-3)
else:
for i in range(0, m, 2):
count(i)
# print (a)
print (len(ans))
for i in ans:
print (*i)
``` | instruction | 0 | 41,480 | 11 | 82,960 |
No | output | 1 | 41,480 | 11 | 82,961 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a puzzle to complete by combining 14 numbers from 1 to 9. Complete by adding another number to the given 13 numbers.
The conditions for completing the puzzle are
* You must have one combination of the same numbers.
* The remaining 12 numbers are 4 combinations of 3 numbers.
The combination of three numbers is either three of the same numbers or three consecutive numbers. However, sequences such as 9 1 2 are not considered consecutive numbers.
* The same number can be used up to 4 times.
Create a program that reads a string of 13 numbers and outputs all the numbers that can complete the puzzle in ascending order. If you cannot complete the puzzle by adding any number from 1 to 9, output 0.
For example, if the given string is 3456666777999
If there is a "2", 234 567 666 77 999
If there is a "3", then 33 456 666 777 999
If there is a "5", then 345 567 666 77 999
If there is an "8", then 345 666 678 77 999
And so on, the puzzle is complete when one of the numbers 2 3 5 8 is added. Note that "6" is fine, but it will be used for the 5th time, so it cannot be used in this example.
Input
The input consists of multiple datasets. For each dataset, 13 numbers are given on one line. The number of datasets does not exceed 50.
Output
For each dataset, the numbers that can complete the puzzle are output on one line in ascending order, separated by blanks.
Example
Input
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
Output
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
Submitted Solution:
```
def is_hora(lst):
for i in range(1,10):
if lst[i] >= 2:
if(is_4chunk(lst,i)): return True
return False
def is_4chunk(lst,atama):
searchlist = [0]*10
for i in range(10):
searchlist[i] = lst[i]
searchlist[atama] -= 2
for i in range(1,8):
if searchlist[i] < 0: return False
if searchlist[i] >=3: searchlist[i]-=3
if searchlist[i] ==1:
searchlist[i]-=1
searchlist[i+1]-=1
searchlist[i+2]-=1
elif searchlist[i] ==2:
searchlist[i]-=2
searchlist[i+1]-=2
searchlist[i+2]-=2
return (searchlist[8] == 0 or searchlist[8] == 3) and (searchlist[9] == 0 or searchlist[9] == 3)
while True:
try:
instr = input()
pai = [0]*10
ans = []
for i in range(13):
pai[(int(instr[i]))] += 1
for i in range(1,10):
if pai[i] == 4: continue
pai[i] += 1
if is_hora(pai): ans.append(i)
pai[i] -= 1
if len(ans)!=0:
print(" ".join(list(map(str,ans))))
else: print(0)
except EOFError: break
``` | instruction | 0 | 41,973 | 11 | 83,946 |
Yes | output | 1 | 41,973 | 11 | 83,947 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a puzzle to complete by combining 14 numbers from 1 to 9. Complete by adding another number to the given 13 numbers.
The conditions for completing the puzzle are
* You must have one combination of the same numbers.
* The remaining 12 numbers are 4 combinations of 3 numbers.
The combination of three numbers is either three of the same numbers or three consecutive numbers. However, sequences such as 9 1 2 are not considered consecutive numbers.
* The same number can be used up to 4 times.
Create a program that reads a string of 13 numbers and outputs all the numbers that can complete the puzzle in ascending order. If you cannot complete the puzzle by adding any number from 1 to 9, output 0.
For example, if the given string is 3456666777999
If there is a "2", 234 567 666 77 999
If there is a "3", then 33 456 666 777 999
If there is a "5", then 345 567 666 77 999
If there is an "8", then 345 666 678 77 999
And so on, the puzzle is complete when one of the numbers 2 3 5 8 is added. Note that "6" is fine, but it will be used for the 5th time, so it cannot be used in this example.
Input
The input consists of multiple datasets. For each dataset, 13 numbers are given on one line. The number of datasets does not exceed 50.
Output
For each dataset, the numbers that can complete the puzzle are output on one line in ascending order, separated by blanks.
Example
Input
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
Output
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
Submitted Solution:
```
import sys
def f(c):
if sum(c)in c:return 1
if 5 in c:return 0
if 4 in c:
k=c.index(4);c[k]-=3
if f(c):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
n='123456789'
for e in sys.stdin:
e=list(e)
a=[i for i in n if f([(e+[i]).count(j)for j in n])]
if a:print(*a)
else:print(0)
``` | instruction | 0 | 41,974 | 11 | 83,948 |
Yes | output | 1 | 41,974 | 11 | 83,949 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a puzzle to complete by combining 14 numbers from 1 to 9. Complete by adding another number to the given 13 numbers.
The conditions for completing the puzzle are
* You must have one combination of the same numbers.
* The remaining 12 numbers are 4 combinations of 3 numbers.
The combination of three numbers is either three of the same numbers or three consecutive numbers. However, sequences such as 9 1 2 are not considered consecutive numbers.
* The same number can be used up to 4 times.
Create a program that reads a string of 13 numbers and outputs all the numbers that can complete the puzzle in ascending order. If you cannot complete the puzzle by adding any number from 1 to 9, output 0.
For example, if the given string is 3456666777999
If there is a "2", 234 567 666 77 999
If there is a "3", then 33 456 666 777 999
If there is a "5", then 345 567 666 77 999
If there is an "8", then 345 666 678 77 999
And so on, the puzzle is complete when one of the numbers 2 3 5 8 is added. Note that "6" is fine, but it will be used for the 5th time, so it cannot be used in this example.
Input
The input consists of multiple datasets. For each dataset, 13 numbers are given on one line. The number of datasets does not exceed 50.
Output
For each dataset, the numbers that can complete the puzzle are output on one line in ascending order, separated by blanks.
Example
Input
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
Output
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
Submitted Solution:
```
def check(nums):
for i in range(9):
if(nums[i]>4):return False
for head in range(9):
anums=nums[:]
if(anums[head]<2):continue
anums[head]-=2
for i in range(9):
if(anums[i]>=3):
anums[i]-=3
while(anums[i]>0):
if i>=7:break
ok=True
for j in range(i,i+3):
if anums[j]<=0:
ok=True
if not ok:
break
for j in range(i,i+3):
anums[j]-=1
if not any(anums):
return True
return False
while True:
st=""
try:
st=input()
if st=="":break
except:break
nums=[0 for i in range(9)]
for c in st:
nums[int(c)-1]+=1
anss=[]
for n in range(0,9):
nums[n]+=1
if(check(nums[:])):anss.append(n+1)
nums[n]-=1
if(len(anss)==0):anss.append(0)
print(" ".join(map(str,anss)))
``` | instruction | 0 | 41,975 | 11 | 83,950 |
Yes | output | 1 | 41,975 | 11 | 83,951 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a puzzle to complete by combining 14 numbers from 1 to 9. Complete by adding another number to the given 13 numbers.
The conditions for completing the puzzle are
* You must have one combination of the same numbers.
* The remaining 12 numbers are 4 combinations of 3 numbers.
The combination of three numbers is either three of the same numbers or three consecutive numbers. However, sequences such as 9 1 2 are not considered consecutive numbers.
* The same number can be used up to 4 times.
Create a program that reads a string of 13 numbers and outputs all the numbers that can complete the puzzle in ascending order. If you cannot complete the puzzle by adding any number from 1 to 9, output 0.
For example, if the given string is 3456666777999
If there is a "2", 234 567 666 77 999
If there is a "3", then 33 456 666 777 999
If there is a "5", then 345 567 666 77 999
If there is an "8", then 345 666 678 77 999
And so on, the puzzle is complete when one of the numbers 2 3 5 8 is added. Note that "6" is fine, but it will be used for the 5th time, so it cannot be used in this example.
Input
The input consists of multiple datasets. For each dataset, 13 numbers are given on one line. The number of datasets does not exceed 50.
Output
For each dataset, the numbers that can complete the puzzle are output on one line in ascending order, separated by blanks.
Example
Input
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
Output
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
Submitted Solution:
```
def Solve(c,s):
if s:
if max(c)>4:return False
for i in range(9):
if c[i]>=2:
cc=c[:]
cc[i]-=2
if Solve(cc,False):return True
else:
check=0
for i in range(4):check+=c.count(3*i)
if check==9:return True
else:
for i in range(7):
if c[i]>=1:
cc=c[:]
isneg=False
for j in range(3):
cc[i+j]-=1
if cc[i+j]<0:
isneg=True
break
if isneg==False and Solve(cc,False):return True
_in=""
while True:
ans=[]
try:_in=input()
except EOFError:break
for i in range(9):
l=(_in+str(i+1))[::1]
count=[l.count(str(j+1))for j in range(9)]
if Solve(count,True):ans.append(str(i+1))
print(0 if len(ans)==0 else " ".join(ans))
``` | instruction | 0 | 41,976 | 11 | 83,952 |
Yes | output | 1 | 41,976 | 11 | 83,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a puzzle to complete by combining 14 numbers from 1 to 9. Complete by adding another number to the given 13 numbers.
The conditions for completing the puzzle are
* You must have one combination of the same numbers.
* The remaining 12 numbers are 4 combinations of 3 numbers.
The combination of three numbers is either three of the same numbers or three consecutive numbers. However, sequences such as 9 1 2 are not considered consecutive numbers.
* The same number can be used up to 4 times.
Create a program that reads a string of 13 numbers and outputs all the numbers that can complete the puzzle in ascending order. If you cannot complete the puzzle by adding any number from 1 to 9, output 0.
For example, if the given string is 3456666777999
If there is a "2", 234 567 666 77 999
If there is a "3", then 33 456 666 777 999
If there is a "5", then 345 567 666 77 999
If there is an "8", then 345 666 678 77 999
And so on, the puzzle is complete when one of the numbers 2 3 5 8 is added. Note that "6" is fine, but it will be used for the 5th time, so it cannot be used in this example.
Input
The input consists of multiple datasets. For each dataset, 13 numbers are given on one line. The number of datasets does not exceed 50.
Output
For each dataset, the numbers that can complete the puzzle are output on one line in ascending order, separated by blanks.
Example
Input
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
Output
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
Submitted Solution:
```
def Solve(c,s):
if s:
for i in range(9):
if c[i]>4:return False
elif c[i]>=2:
cc=c[:]
cc[i]-=2
if Solve(cc,False):return True
else:
if c.count(0)+c.count(3)==9:return True
else:
for i in range(9):
if c[i]<0:return False
elif c[i]>=1 and i<7:
cc=c[:]
for j in range(3):
cc[i+j]-=1
if Solve(cc,False):return True
_in=""
while True:
ans=[]
try:_in="9118992346175"
except EOFError:break
for i in range(9):
l=sorted((_in+str(i+1))[::1])
count=[l.count(str(j+1))for j in range(9)]
if Solve(count,True):ans.append(str(i+1))
print(0 if len(ans)==0 else " ".join(ans))
``` | instruction | 0 | 41,977 | 11 | 83,954 |
No | output | 1 | 41,977 | 11 | 83,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a puzzle to complete by combining 14 numbers from 1 to 9. Complete by adding another number to the given 13 numbers.
The conditions for completing the puzzle are
* You must have one combination of the same numbers.
* The remaining 12 numbers are 4 combinations of 3 numbers.
The combination of three numbers is either three of the same numbers or three consecutive numbers. However, sequences such as 9 1 2 are not considered consecutive numbers.
* The same number can be used up to 4 times.
Create a program that reads a string of 13 numbers and outputs all the numbers that can complete the puzzle in ascending order. If you cannot complete the puzzle by adding any number from 1 to 9, output 0.
For example, if the given string is 3456666777999
If there is a "2", 234 567 666 77 999
If there is a "3", then 33 456 666 777 999
If there is a "5", then 345 567 666 77 999
If there is an "8", then 345 666 678 77 999
And so on, the puzzle is complete when one of the numbers 2 3 5 8 is added. Note that "6" is fine, but it will be used for the 5th time, so it cannot be used in this example.
Input
The input consists of multiple datasets. For each dataset, 13 numbers are given on one line. The number of datasets does not exceed 50.
Output
For each dataset, the numbers that can complete the puzzle are output on one line in ascending order, separated by blanks.
Example
Input
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
Output
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
Submitted Solution:
```
import sys
def f(c,h=0):
if 2 in c and sum(c)==2:return 1
if 5 in c:return 0 # sum(c)==2
if 4 in c:
k=c.index(4);c[k]-=3
if f(c,h+1):return 1
c[k]+=3
if 3 in c:
k=c.index(3);c[k]-=3
if f(c,h+1):return 1
c[k]+=3
for i in range(7):
if c[i]and c[i+1]and c[i+2]:
c[i]-=1;c[i+1]-=1;c[i+2]-=1
if f(c,h+1):return 1
c[i]+=1;c[i+1]+=1;c[i+2]+=1
n='123456789'
for e in sys.stdin:
e=list(e)
a=[i for i in n if f([(e+[i]).count(j)for j in n])]
print(*a if a else 0)
``` | instruction | 0 | 41,978 | 11 | 83,956 |
No | output | 1 | 41,978 | 11 | 83,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a puzzle to complete by combining 14 numbers from 1 to 9. Complete by adding another number to the given 13 numbers.
The conditions for completing the puzzle are
* You must have one combination of the same numbers.
* The remaining 12 numbers are 4 combinations of 3 numbers.
The combination of three numbers is either three of the same numbers or three consecutive numbers. However, sequences such as 9 1 2 are not considered consecutive numbers.
* The same number can be used up to 4 times.
Create a program that reads a string of 13 numbers and outputs all the numbers that can complete the puzzle in ascending order. If you cannot complete the puzzle by adding any number from 1 to 9, output 0.
For example, if the given string is 3456666777999
If there is a "2", 234 567 666 77 999
If there is a "3", then 33 456 666 777 999
If there is a "5", then 345 567 666 77 999
If there is an "8", then 345 666 678 77 999
And so on, the puzzle is complete when one of the numbers 2 3 5 8 is added. Note that "6" is fine, but it will be used for the 5th time, so it cannot be used in this example.
Input
The input consists of multiple datasets. For each dataset, 13 numbers are given on one line. The number of datasets does not exceed 50.
Output
For each dataset, the numbers that can complete the puzzle are output on one line in ascending order, separated by blanks.
Example
Input
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
Output
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
Submitted Solution:
```
def Solve(c,s):
if s:
for i in range(9):
if c[i]>4:return False
elif c[i]>=2:
cc=c[:]
cc[i]-=2
if Solve(cc,False):return True
else:
if c.count(0)+c.count(3)==9:return True
else:
for i in range(9):
if c[i]<0:return False
elif c[i]>=1 and i<7:
cc=c[:]
for j in range(3):
cc[i+j]-=1
if Solve(cc,False):return True
_in=""
while True:
ans=[]
try:_in=input()
except EOFError:break
for i in range(9):
l=sorted((_in+str(i+1))[::1])
count=[l.count(str(j+1))for j in range(9)]
if Solve(count,True):ans.append(str(i+1))
print(0 if len(ans)==0 else " ".join(ans))
``` | instruction | 0 | 41,979 | 11 | 83,958 |
No | output | 1 | 41,979 | 11 | 83,959 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a puzzle to complete by combining 14 numbers from 1 to 9. Complete by adding another number to the given 13 numbers.
The conditions for completing the puzzle are
* You must have one combination of the same numbers.
* The remaining 12 numbers are 4 combinations of 3 numbers.
The combination of three numbers is either three of the same numbers or three consecutive numbers. However, sequences such as 9 1 2 are not considered consecutive numbers.
* The same number can be used up to 4 times.
Create a program that reads a string of 13 numbers and outputs all the numbers that can complete the puzzle in ascending order. If you cannot complete the puzzle by adding any number from 1 to 9, output 0.
For example, if the given string is 3456666777999
If there is a "2", 234 567 666 77 999
If there is a "3", then 33 456 666 777 999
If there is a "5", then 345 567 666 77 999
If there is an "8", then 345 666 678 77 999
And so on, the puzzle is complete when one of the numbers 2 3 5 8 is added. Note that "6" is fine, but it will be used for the 5th time, so it cannot be used in this example.
Input
The input consists of multiple datasets. For each dataset, 13 numbers are given on one line. The number of datasets does not exceed 50.
Output
For each dataset, the numbers that can complete the puzzle are output on one line in ascending order, separated by blanks.
Example
Input
3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246
Output
2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0
Submitted Solution:
```
def Solve(c,s):
if s:
if max(c)>4:return False
for i in range(9):
if c[i]>=2:
cc=c[:]
cc[i]-=2
if Solve(cc,False):return True
else:
check=0
for i in range(4):check+=c.count(3*i)
if check==9:return True
else:
for i in range(7):
if c[i]>=1:
cc=c[:]
for j in range(3):
cc[i+j]-=1
if cc[i+j]<0:break
if Solve(cc,False):return True
_in=""
while True:
ans=[]
try:_in="1123345567799"
except EOFError:break
for i in range(9):
l=(_in+str(i+1))[::1]
count=[l.count(str(j+1))for j in range(9)]
if Solve(count,True):ans.append(str(i+1))
print(0 if len(ans)==0 else " ".join(ans))
``` | instruction | 0 | 41,980 | 11 | 83,960 |
No | output | 1 | 41,980 | 11 | 83,961 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Look for the Winner!
The citizens of TKB City are famous for their deep love in elections and vote counting. Today they hold an election for the next chairperson of the electoral commission. Now the voting has just been closed and the counting is going to start. The TKB citizens have strong desire to know the winner as early as possible during vote counting.
The election candidate receiving the most votes shall be the next chairperson. Suppose for instance that we have three candidates A, B, and C and ten votes. Suppose also that we have already counted six of the ten votes and the vote counts of A, B, and C are four, one, and one, respectively. At this moment, every candidate has a chance to receive four more votes and so everyone can still be the winner. However, if the next vote counted is cast for A, A is ensured to be the winner since A already has five votes and B or C can have at most four votes at the end. In this example, therefore, the TKB citizens can know the winner just when the seventh vote is counted.
Your mission is to write a program that receives every vote counted, one by one, identifies the winner, and determines when the winner gets ensured.
Input
The input consists of at most 1500 datasets, each consisting of two lines in the following format.
n
c1 c2 β¦ cn
n in the first line represents the number of votes, and is a positive integer no greater than 100. The second line represents the n votes, separated by a space. Each ci (1 β€ i β€ n) is a single uppercase letter, i.e. one of 'A' through 'Z'. This represents the election candidate for which the i-th vote was cast. Counting shall be done in the given order from c1 to cn.
You should assume that at least two stand as candidates even when all the votes are cast for one candidate.
The end of the input is indicated by a line containing a zero.
Output
For each dataset, unless the election ends in a tie, output a single line containing an uppercase letter c and an integer d separated by a space: c should represent the election winner and d should represent after counting how many votes the winner is identified. Otherwise, that is, if the election ends in a tie, output a single line containing `TIE'.
Sample Input
1
A
4
A A B B
5
L M N L N
6
K K K K K K
6
X X X Y Z X
10
A A A B A C A C C B
10
U U U U U V V W W W
0
Output for the Sample Input
A 1
TIE
TIE
K 4
X 5
A 7
U 8
Example
Input
1
A
4
A A B B
5
L M N L N
6
K K K K K K
6
X X X Y Z X
10
A A A B A C A C C B
10
U U U U U V V W W W
0
Output
A 1
TIE
TIE
K 4
X 5
A 7
U 8
Submitted Solution:
```
from collections import Counter
while True:
N = int(input())
if not N:
break
C = input().split()
for i in range(N):
cnt = Counter(C[:i+1]).most_common()
if (len(cnt) == 1 and cnt[0][1] * 2 > N) or (len(cnt) > 1 and cnt[0][1] > cnt[1][1] + N - i - 1):
print(cnt[0][0], i + 1)
break
else:
print("TIE")
``` | instruction | 0 | 42,029 | 11 | 84,058 |
Yes | output | 1 | 42,029 | 11 | 84,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Look for the Winner!
The citizens of TKB City are famous for their deep love in elections and vote counting. Today they hold an election for the next chairperson of the electoral commission. Now the voting has just been closed and the counting is going to start. The TKB citizens have strong desire to know the winner as early as possible during vote counting.
The election candidate receiving the most votes shall be the next chairperson. Suppose for instance that we have three candidates A, B, and C and ten votes. Suppose also that we have already counted six of the ten votes and the vote counts of A, B, and C are four, one, and one, respectively. At this moment, every candidate has a chance to receive four more votes and so everyone can still be the winner. However, if the next vote counted is cast for A, A is ensured to be the winner since A already has five votes and B or C can have at most four votes at the end. In this example, therefore, the TKB citizens can know the winner just when the seventh vote is counted.
Your mission is to write a program that receives every vote counted, one by one, identifies the winner, and determines when the winner gets ensured.
Input
The input consists of at most 1500 datasets, each consisting of two lines in the following format.
n
c1 c2 β¦ cn
n in the first line represents the number of votes, and is a positive integer no greater than 100. The second line represents the n votes, separated by a space. Each ci (1 β€ i β€ n) is a single uppercase letter, i.e. one of 'A' through 'Z'. This represents the election candidate for which the i-th vote was cast. Counting shall be done in the given order from c1 to cn.
You should assume that at least two stand as candidates even when all the votes are cast for one candidate.
The end of the input is indicated by a line containing a zero.
Output
For each dataset, unless the election ends in a tie, output a single line containing an uppercase letter c and an integer d separated by a space: c should represent the election winner and d should represent after counting how many votes the winner is identified. Otherwise, that is, if the election ends in a tie, output a single line containing `TIE'.
Sample Input
1
A
4
A A B B
5
L M N L N
6
K K K K K K
6
X X X Y Z X
10
A A A B A C A C C B
10
U U U U U V V W W W
0
Output for the Sample Input
A 1
TIE
TIE
K 4
X 5
A 7
U 8
Example
Input
1
A
4
A A B B
5
L M N L N
6
K K K K K K
6
X X X Y Z X
10
A A A B A C A C C B
10
U U U U U V V W W W
0
Output
A 1
TIE
TIE
K 4
X 5
A 7
U 8
Submitted Solution:
```
printedlater = []
while True:
n = int(input())
if (n == 0): # the end of input
break
c = [x for x in input().split()]
voteNum = {}
for cand in list("ABCDEFGHIJKLMNOPQRSTUVWXYZ"):
voteNum[cand] = 0
while True:
if (len(c) == 0):
voteMax = max(voteNum.values())
winners = [x for x in voteNum.keys() if voteNum[x] == voteMax]
if (len(winners) == 1):
printedlater.append(winners[0] + " " + str(n))
else:
printedlater.append("TIE")
break
voteNum[c.pop(0)] += 1
vote2ndMax, voteMax = sorted(voteNum.values())[-2:]
if voteMax - vote2ndMax > len(c):
printedlater.append([x for x in voteNum.keys() if voteNum[x] == voteMax][0] + " " + str(n - len(c)))
break
for line in printedlater:
print(line)
``` | instruction | 0 | 42,030 | 11 | 84,060 |
Yes | output | 1 | 42,030 | 11 | 84,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Look for the Winner!
The citizens of TKB City are famous for their deep love in elections and vote counting. Today they hold an election for the next chairperson of the electoral commission. Now the voting has just been closed and the counting is going to start. The TKB citizens have strong desire to know the winner as early as possible during vote counting.
The election candidate receiving the most votes shall be the next chairperson. Suppose for instance that we have three candidates A, B, and C and ten votes. Suppose also that we have already counted six of the ten votes and the vote counts of A, B, and C are four, one, and one, respectively. At this moment, every candidate has a chance to receive four more votes and so everyone can still be the winner. However, if the next vote counted is cast for A, A is ensured to be the winner since A already has five votes and B or C can have at most four votes at the end. In this example, therefore, the TKB citizens can know the winner just when the seventh vote is counted.
Your mission is to write a program that receives every vote counted, one by one, identifies the winner, and determines when the winner gets ensured.
Input
The input consists of at most 1500 datasets, each consisting of two lines in the following format.
n
c1 c2 β¦ cn
n in the first line represents the number of votes, and is a positive integer no greater than 100. The second line represents the n votes, separated by a space. Each ci (1 β€ i β€ n) is a single uppercase letter, i.e. one of 'A' through 'Z'. This represents the election candidate for which the i-th vote was cast. Counting shall be done in the given order from c1 to cn.
You should assume that at least two stand as candidates even when all the votes are cast for one candidate.
The end of the input is indicated by a line containing a zero.
Output
For each dataset, unless the election ends in a tie, output a single line containing an uppercase letter c and an integer d separated by a space: c should represent the election winner and d should represent after counting how many votes the winner is identified. Otherwise, that is, if the election ends in a tie, output a single line containing `TIE'.
Sample Input
1
A
4
A A B B
5
L M N L N
6
K K K K K K
6
X X X Y Z X
10
A A A B A C A C C B
10
U U U U U V V W W W
0
Output for the Sample Input
A 1
TIE
TIE
K 4
X 5
A 7
U 8
Example
Input
1
A
4
A A B B
5
L M N L N
6
K K K K K K
6
X X X Y Z X
10
A A A B A C A C C B
10
U U U U U V V W W W
0
Output
A 1
TIE
TIE
K 4
X 5
A 7
U 8
Submitted Solution:
```
ans_list = []
while True:
n = int(input())
if n == 0:
break
C = input().split()
al = [0]*26
ans = "TIE"
for i, c in enumerate(C):
al[ord(c)-65] += 1
tmp = sorted(al,reverse=True)
one = tmp[0]
two = tmp[1]
remain = n - i - 1
if one > two + remain:
win = chr(al.index(one) + 65)
ans = "{} {}".format(win, i+1)
break
ans_list.append(ans)
for ans in ans_list:
print(ans)
``` | instruction | 0 | 42,031 | 11 | 84,062 |
Yes | output | 1 | 42,031 | 11 | 84,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Look for the Winner!
The citizens of TKB City are famous for their deep love in elections and vote counting. Today they hold an election for the next chairperson of the electoral commission. Now the voting has just been closed and the counting is going to start. The TKB citizens have strong desire to know the winner as early as possible during vote counting.
The election candidate receiving the most votes shall be the next chairperson. Suppose for instance that we have three candidates A, B, and C and ten votes. Suppose also that we have already counted six of the ten votes and the vote counts of A, B, and C are four, one, and one, respectively. At this moment, every candidate has a chance to receive four more votes and so everyone can still be the winner. However, if the next vote counted is cast for A, A is ensured to be the winner since A already has five votes and B or C can have at most four votes at the end. In this example, therefore, the TKB citizens can know the winner just when the seventh vote is counted.
Your mission is to write a program that receives every vote counted, one by one, identifies the winner, and determines when the winner gets ensured.
Input
The input consists of at most 1500 datasets, each consisting of two lines in the following format.
n
c1 c2 β¦ cn
n in the first line represents the number of votes, and is a positive integer no greater than 100. The second line represents the n votes, separated by a space. Each ci (1 β€ i β€ n) is a single uppercase letter, i.e. one of 'A' through 'Z'. This represents the election candidate for which the i-th vote was cast. Counting shall be done in the given order from c1 to cn.
You should assume that at least two stand as candidates even when all the votes are cast for one candidate.
The end of the input is indicated by a line containing a zero.
Output
For each dataset, unless the election ends in a tie, output a single line containing an uppercase letter c and an integer d separated by a space: c should represent the election winner and d should represent after counting how many votes the winner is identified. Otherwise, that is, if the election ends in a tie, output a single line containing `TIE'.
Sample Input
1
A
4
A A B B
5
L M N L N
6
K K K K K K
6
X X X Y Z X
10
A A A B A C A C C B
10
U U U U U V V W W W
0
Output for the Sample Input
A 1
TIE
TIE
K 4
X 5
A 7
U 8
Example
Input
1
A
4
A A B B
5
L M N L N
6
K K K K K K
6
X X X Y Z X
10
A A A B A C A C C B
10
U U U U U V V W W W
0
Output
A 1
TIE
TIE
K 4
X 5
A 7
U 8
Submitted Solution:
```
while True:
n = int(input())
if n == 0:
break
C = input().split()
D = {}
for x in [chr(i) for i in range(65, 65+26)]:
D[x] = 0
for i in range(n):
D[C[i]] += 1
E = sorted(D.items(), key=lambda x: x[1], reverse=True)
if E[0][1] > E[1][1] + n - i - 1:
print(E[0][0], i + 1)
break
if E[0][1] == E[1][1]:
print("TIE")
``` | instruction | 0 | 42,032 | 11 | 84,064 |
Yes | output | 1 | 42,032 | 11 | 84,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Look for the Winner!
The citizens of TKB City are famous for their deep love in elections and vote counting. Today they hold an election for the next chairperson of the electoral commission. Now the voting has just been closed and the counting is going to start. The TKB citizens have strong desire to know the winner as early as possible during vote counting.
The election candidate receiving the most votes shall be the next chairperson. Suppose for instance that we have three candidates A, B, and C and ten votes. Suppose also that we have already counted six of the ten votes and the vote counts of A, B, and C are four, one, and one, respectively. At this moment, every candidate has a chance to receive four more votes and so everyone can still be the winner. However, if the next vote counted is cast for A, A is ensured to be the winner since A already has five votes and B or C can have at most four votes at the end. In this example, therefore, the TKB citizens can know the winner just when the seventh vote is counted.
Your mission is to write a program that receives every vote counted, one by one, identifies the winner, and determines when the winner gets ensured.
Input
The input consists of at most 1500 datasets, each consisting of two lines in the following format.
n
c1 c2 β¦ cn
n in the first line represents the number of votes, and is a positive integer no greater than 100. The second line represents the n votes, separated by a space. Each ci (1 β€ i β€ n) is a single uppercase letter, i.e. one of 'A' through 'Z'. This represents the election candidate for which the i-th vote was cast. Counting shall be done in the given order from c1 to cn.
You should assume that at least two stand as candidates even when all the votes are cast for one candidate.
The end of the input is indicated by a line containing a zero.
Output
For each dataset, unless the election ends in a tie, output a single line containing an uppercase letter c and an integer d separated by a space: c should represent the election winner and d should represent after counting how many votes the winner is identified. Otherwise, that is, if the election ends in a tie, output a single line containing `TIE'.
Sample Input
1
A
4
A A B B
5
L M N L N
6
K K K K K K
6
X X X Y Z X
10
A A A B A C A C C B
10
U U U U U V V W W W
0
Output for the Sample Input
A 1
TIE
TIE
K 4
X 5
A 7
U 8
Example
Input
1
A
4
A A B B
5
L M N L N
6
K K K K K K
6
X X X Y Z X
10
A A A B A C A C C B
10
U U U U U V V W W W
0
Output
A 1
TIE
TIE
K 4
X 5
A 7
U 8
Submitted Solution:
```
def secMax(a):
mx = 0
smx = 0
for i in range(0,len(a)):
if a[i] > mx:
smx = mx
mx = a[i]
elif a[i] > smx:
smx = a[i]
else:
return smx
while True:
n = int(input())
if n == 0:
break
c = list(map(str,input().split()))
##alphabet = char('a')##charεγγγγ£γ¦θ¨γγγ(Β΄γ»Ογ»`)
alph = ["A","B","C","D","E","F","G","H",
"I","J","K","L","M","N","O","P","Q",
"R","S","T","U","V","W","X","Y","Z"]
abcCount = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
for i in range(0, n):
for j in range(0, 26):
if c[i] == alph[j]:
abcCount[j] = abcCount[j] + 1
break
print(abcCount)
if max(abcCount) > n-1-i+secMax(abcCount):
print(alph[abcCount.index(max(abcCount))], sum(abcCount))
break
else:
print("TIE")
``` | instruction | 0 | 42,033 | 11 | 84,066 |
No | output | 1 | 42,033 | 11 | 84,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem. | instruction | 0 | 42,141 | 11 | 84,282 |
Tags: data structures, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
N,M=map(int,input().split())
A=[int(x) for x in input().split()]
K=[0]*(N+1)
H=set()
S=''
for a in A:
H.add(a)
K[a]+=1
if len(H)==N:
S+='1'
H=set()
for i in range(1,N+1):
K[i]-=1
if K[i]>=1:
H.add(i)
else:
S+='0'
print(S)
``` | output | 1 | 42,141 | 11 | 84,283 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem. | instruction | 0 | 42,142 | 11 | 84,284 |
Tags: data structures, implementation
Correct Solution:
```
n,m=map(int,input().split())
arr=list(map(int,input().split()))
d={}
res = ""
for i in arr:
if i in d:
d[i]+=1
else:
d[i]=1
is_round = (len(d) == n)
res+=str(int(is_round))
if is_round:
d2= {}
for k, v in d.items():
if v > 1:
d2[k] = v - 1
d = d2
print(res)
``` | output | 1 | 42,142 | 11 | 84,285 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem. | instruction | 0 | 42,143 | 11 | 84,286 |
Tags: data structures, implementation
Correct Solution:
```
N, M = map(int, input().split())
A = [int(a) for a in input().split()]
X = [0] * N
s = 0
sc = N
def cts():
global s
global sc
# print(X)
s = min(X)
sc = 0
# print("CTS1", s, sc)
for i in range(N):
if X[i] == s:
sc += 1
# print("CTS2", s, sc)
for i in range(M):
X[A[i]-1] += 1
if X[A[i]-1] == s+1:
sc -= 1
if sc == 0:
cts()
if s == 1:
print(1, end = "")
for j in range(N):
X[j] -= 1
s -= 1
else:
print(0, end = "")
print("")
``` | output | 1 | 42,143 | 11 | 84,287 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem. | instruction | 0 | 42,144 | 11 | 84,288 |
Tags: data structures, implementation
Correct Solution:
```
def main():
t = 1
for _ in range(t):
n,m = map(int,input().split())
tab = list(map(int,input().split()))
se = {}
inc = 0
for x in range(m):
if tab[x] in se:
if se[tab[x]]==0:
inc+=1
se[tab[x]]+=1
else:
se[tab[x]]=1
inc += 1
if inc==n:
for x in range(1,n+1):
se[x] -= 1
if se[x] == 0:
inc -= 1
print(1,end="")
else:
print(0,end="")
print()
main()
``` | output | 1 | 42,144 | 11 | 84,289 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem. | instruction | 0 | 42,145 | 11 | 84,290 |
Tags: data structures, implementation
Correct Solution:
```
import sys
input=sys.stdin.readline
f=lambda :list(map(int, input().split()))
n, m=f()
cnt=[0]*(n+1)
num=[0]*(m+1)
ans=[0]*m
for i, v in enumerate(f()):
cnt[v]+=1
num[cnt[v]]+=1
ans[i]=1 if num[cnt[v]]==n else 0
print(''.join(map(str, ans)))
``` | output | 1 | 42,145 | 11 | 84,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem. | instruction | 0 | 42,146 | 11 | 84,292 |
Tags: data structures, implementation
Correct Solution:
```
n, m = map(int, input().split())
a = list(map(int, input().split()))
mn = 1
cnt, cnt2 = [0 for i in range(n + 1)], [0 for i in range(m + 1)]
for i in range(m):
cnt[a[i]] += 1
cnt2[cnt[a[i]]] += 1
if cnt2[mn] == n:
print(1, end = "")
mn += 1
else:
print(0, end = "")
print()
``` | output | 1 | 42,146 | 11 | 84,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem. | instruction | 0 | 42,147 | 11 | 84,294 |
Tags: data structures, implementation
Correct Solution:
```
n,m = map(int,input().split())
l1 = list(map(int,input().split()))
freq = {}
diff = 0
ans = ""
def update():
global diff
for i in range(1,n+1):
freq[i] -= 1
if(freq[i] == 0):
diff -= 1
return
for i in range(m):
atual = l1[i]
if((atual not in freq) or freq[atual] == 0):
diff += 1
freq[atual] = 1
else:
freq[atual] += 1
if(diff==n):
ans += "1"
update()
else:
ans += "0"
print(ans)
``` | output | 1 | 42,147 | 11 | 84,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem. | instruction | 0 | 42,148 | 11 | 84,296 |
Tags: data structures, implementation
Correct Solution:
```
from collections import Counter
c = Counter()
n,m = list(map(int, input().split()))
t = list(map(int, input().split()))
s = ''
for i in t:
if i in c:
c[i]+=1
else:
c[i]=1
#print(i, len(c), c)
if len(c)==n:
for i in range(1,n+1):
if c[i]==1:
del c[i]
else:
c[i]-=1
#print('Deleted', c)
s += '1'
else:
s += '0'
print(s)
``` | output | 1 | 42,148 | 11 | 84,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem.
Submitted Solution:
```
from fractions import gcd
from datetime import date
from math import factorial
import functools
from heapq import*
from collections import deque
import collections
import math
from collections import defaultdict, Counter
import sys
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7
inf = float("inf")
def main():
n, m = map(int, input().split())
a = list(map(int, input().split()))
l = set()
ans = ""
d = defaultdict(int)
c = 0
for v in a:
if d[v] == 0:
c += 1
d[v] += 1
if c == n:
ans += "1"
for ke in d.keys():
d[ke] -= 1
if d[ke] == 0:
c -= 1
else:
ans += "0"
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 42,149 | 11 | 84,298 |
Yes | output | 1 | 42,149 | 11 | 84,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem.
Submitted Solution:
```
## Soru 1
# nk = list(map(int, input().split()))
# n = nk[0]
# k = nk[1]
#
# lst = list(map(int, input().split()))
#
# e = 0
# s = 0
# for i in lst:
# if i == 1:
# e += 1
# else:
# s += 1
# larg = 0
# for b in range(1,k+1):
# a = 0
# x = e
# y = s
# while a*k + b <= n:
# if lst[a*k+b-1] == 1:
# x -= 1
# else:
# y -= 1
# a += 1
# if abs(x-y)>larg:
# larg = abs(x-y)
# print(larg)
## Soru 2
nm = list(map(int, input().split()))
n = nm[0]
lst = list(map(int, input().split()))
s = set()
result = ""
dct = {}
for i in lst:
x = len(s)
s.add(i)
if x == len(s):
dct[i] = dct.get(i, 0) + 1
result = result + "0"
elif len(s) == n:
result = result + "1"
s = set(dct.keys())
for i in s:
dct[i] -= 1
if dct[i] == 0:
dct.pop(i)
else:
result = result + "0"
print(result)
## Soru 3
# import math
# nr = list(map(int, input().split()))
# n = nr[0]
# inner_r = nr[1]
# alfa = 180/n
# alfa = math.radians(alfa)
# sinus = math.sin(alfa)
# outer_r = sinus*inner_r / (1-sinus)
# print(outer_r)
``` | instruction | 0 | 42,150 | 11 | 84,300 |
Yes | output | 1 | 42,150 | 11 | 84,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem.
Submitted Solution:
```
N, M = map(int, input().split())
a = list(map(lambda x: int(x)-1, input().split()))
problems = [0]*N
count = 0
ans = []
append = ans.append
for n in a:
if not problems[n]:
count += 1
problems[n] += 1
append(1 if count == N else 0)
if count == N:
count = 0
for i in range(N):
problems[i] -= 1
if problems[i] > 0:
count += 1
print(*ans, sep="")
``` | instruction | 0 | 42,151 | 11 | 84,302 |
Yes | output | 1 | 42,151 | 11 | 84,303 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem.
Submitted Solution:
```
n, m = map(int, input().split())
ls, d,c,currmin =list(map(lambda x: int(x)-1, input().split())), [0]*n,0,0
for i in range(min(n, m)-1):
d[ls[i]]+=1
print(0,end="")
for i in range(min(n, m)-1, m):
d[ls[i]]+=1
while currmin < n and d[currmin] > c: currmin+=1
if currmin == n:
currmin,c = 0,c+1
print(1,end="")
else:
print(0,end="")
print()
``` | instruction | 0 | 42,152 | 11 | 84,304 |
Yes | output | 1 | 42,152 | 11 | 84,305 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem.
Submitted Solution:
```
a,b=map(int,input().split())
c=list(map(int,input().split()))
d=[i for i in range(1,a+1)]
e=set(d)
f=[]
h=''
for i in c:
f.append(i)
f.sort()
g=set(f)
if g==e:
h+='1'
f=[]
g=set(f)
else:
h+='0'
print(h)
``` | instruction | 0 | 42,153 | 11 | 84,306 |
No | output | 1 | 42,153 | 11 | 84,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem.
Submitted Solution:
```
"""
____ _ _____
/ ___|___ __| | ___| ___|__ _ __ ___ ___ ___
| | / _ \ / _` |/ _ \ |_ / _ \| '__/ __/ _ \/ __|
| |__| (_) | (_| | __/ _| (_) | | | (_| __/\__ \
\____\___/ \__,_|\___|_| \___/|_| \___\___||___/
"""
"""
βββββββββββββββββββ
ββββββββββββββββββββ
ββββββββββββββββββββ
ββββββββββββββββββββ
ββββββββββββββββββββ
ββββββββββββββββββββ
ββββββββββββββββββββ
ββββββββββββββββββββ
ββββββββββββββββββββ
ββββββββββββββββββββ
ββββββββββββββββββββ
ββββββββββββββββββββ
ββββββββββββββββββββ
"""
import sys
import math
import collections
import operator as op
from collections import deque
from math import gcd, inf, sqrt
from bisect import bisect_right, bisect_left
#sys.stdin = open('input.txt', 'r')
#sys.stdout = open('output.txt', 'w')
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2**20)
def factorial(n):
if n == 0:
return 1
return n * factorial(n - 1)
def ncr(n, r):
r = min(r, n - r)
numer = reduce(op.mul, range(n, n - r, -1), 1)
denom = reduce(op.mul, range(1, r + 1), 1)
return numer // denom # or / in Python 2
def prime_factors(n):
i = 2
factors = []
while i * i <= n:
if n % i:
i += 1
else:
n //= i
factors.append(i)
if n > 1:
factors.append(n)
return len(set(factors))
def isPowerOfTwo(x):
return (x and (not(x & (x - 1))))
def factors(n):
return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def printp(p):
for i in p:
print(i)
MOD = 10**9 + 7
T = 1
# T = int(stdin.readline())
for _ in range(T):
# n, k = list(map(int, stdin.readline().split()))
# s1 = list(stdin.readline().strip('\n'))
# s = str(stdin.readline().strip('\n'))
# n = int(stdin.readline())
n, k = list(map(int, stdin.readline().split()))
# s = list(stdin.readline().strip('\n'))
a = list(map(int, stdin.readline().split()))
d = {}
ans = ''
for i in range(k):
if a[i] not in d:
d[a[i]] = 1
else:
d[a[i]] += 1
if len(d) != n:
ans += '0'
else:
ans += '1'
d = {}
print(ans)
``` | instruction | 0 | 42,154 | 11 | 84,308 |
No | output | 1 | 42,154 | 11 | 84,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem.
Submitted Solution:
```
#Try 1+1
#Unsuccessful
from collections import defaultdict
n,m = map(int, input().split())
List = [int(x) for x in input().split()]
Dict = defaultdict(bool)
Numbers = defaultdict(int)
Ans = str()
count = 0
for i in range(m):
if(Dict[List[i]]==False):
Dict[List[i]]=True
count+=1
Numbers[List[i]]+=1
else:
Numbers[List[i]]+=1
if(count==n):
Ans+="1"
count = 0
Dict = defaultdict(int)
for i in range(1,n+1):
Numbers[i]-=1
if(Numbers[i]>0):
Dict[i] = True
else:
Ans+="0"
print(Ans)
``` | instruction | 0 | 42,155 | 11 | 84,310 |
No | output | 1 | 42,155 | 11 | 84,311 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Arkady coordinates rounds on some not really famous competitive programming platform. Each round features n problems of distinct difficulty, the difficulties are numbered from 1 to n.
To hold a round Arkady needs n new (not used previously) problems, one for each difficulty. As for now, Arkady creates all the problems himself, but unfortunately, he can't just create a problem of a desired difficulty. Instead, when he creates a problem, he evaluates its difficulty from 1 to n and puts it into the problems pool.
At each moment when Arkady can choose a set of n new problems of distinct difficulties from the pool, he holds a round with these problems and removes them from the pool. Arkady always creates one problem at a time, so if he can hold a round after creating a problem, he immediately does it.
You are given a sequence of problems' difficulties in the order Arkady created them. For each problem, determine whether Arkady held the round right after creating this problem, or not. Initially the problems pool is empty.
Input
The first line contains two integers n and m (1 β€ n, m β€ 10^5) β the number of difficulty levels and the number of problems Arkady created.
The second line contains m integers a_1, a_2, β¦, a_m (1 β€ a_i β€ n) β the problems' difficulties in the order Arkady created them.
Output
Print a line containing m digits. The i-th digit should be 1 if Arkady held the round after creation of the i-th problem, and 0 otherwise.
Examples
Input
3 11
2 3 1 2 2 2 3 2 2 3 1
Output
00100000001
Input
4 8
4 1 3 3 2 3 3 3
Output
00001000
Note
In the first example Arkady held the round after the first three problems, because they are of distinct difficulties, and then only after the last problem.
Submitted Solution:
```
a = list(input().split(" "))
b = list(input().split(" "))
aux = set()
for x in range(len(b)):
aux.add(b[x])
if len(aux)==int(a[0]):
a.append("1")
aux = set()
continue
a.append("0")
if(int(a[1])!=0):
del a[0]
del a[0]
b = ""
for x in a:
b += x + " "
print((b))
``` | instruction | 0 | 42,156 | 11 | 84,312 |
No | output | 1 | 42,156 | 11 | 84,313 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n Γ m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 Γ 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most nm operations. You don't need to minimize the number of operations.
It can be proved, that it is always possible.
Input
The first line contains a single integer t (1 β€ t β€ 5000) β the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 β€ n, m β€ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed, that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 β€ k β€ nm) β the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 β€ x_1, x_2, x_3 β€ n, 1 β€ y_1, y_2, y_3 β€ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong to some 2 Γ 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
Submitted Solution:
```
def flip(x,y):
global mat
if mat[x][y]:
mat[x][y]=0
else:
mat[x][y]=1
def func(x1,y1,x2,y2):
global mat,k
ones,z=[],[]
if mat[x1][y1]==1:
ones.append((x1+1,y1+1))
else:
z.append((x1+1,y1+1))
if mat[x2][y1]==1:
ones.append((x2+1,y1+1))
else:
z.append((x2+1,y1+1))
if mat[x1][y2]==1:
ones.append((x1+1,y2+1))
else:
z.append((x1+1,y2+1))
if mat[x2][y2]==1:
ones.append((x2+1,y2+1))
else:
z.append((x2+1,y2+1))
while len(ones)!=0:
if len(ones)==4:
k+=1
t=[]
for x,y in ones[:-1]:
mat[x-1][y-1]=0
t.append(x)
t.append(y)
out.append(t)
elif len(ones)==3:
k+=1
t=[]
for x,y in ones:
mat[x-1][y-1]=0
t.append(x)
t.append(y)
out.append(t)
elif len(ones)==2:
k+=1
t=[]
for x,y in ones[:-1]:
mat[x-1][y-1]=0
t.append(x)
t.append(y)
for x,y in z:
mat[x-1][y-1]=1
t.append(x)
t.append(y)
out.append(t)
else:
k+=1
t=[]
for x,y in ones:
mat[x-1][y-1]=0
t.append(x)
t.append(y)
for x,y in z[:-1]:
mat[x-1][y-1]=1
t.append(x)
t.append(y)
out.append(t)
ones,z=[],[]
if mat[x1][y1]==1:
ones.append((x1+1,y1+1))
else:
z.append((x1+1,y1+1))
if mat[x2][y1]==1:
ones.append((x2+1,y1+1))
else:
z.append((x2+1,y1+1))
if mat[x1][y2]==1:
ones.append((x1+1,y2+1))
else:
z.append((x1+1,y2+1))
if mat[x2][y2]==1:
ones.append((x2+1,y2+1))
else:
z.append((x2+1,y2+1))
for _ in range(int(input())):
n,m=map(int,input().split())
mat=[]
for i in range(n):
mat.append(list(map(int,list(input()))))
k=0
out=[]
i=0
if n%2:
j=0
if m%2:
func(n-2,m-2,n-1,m-1)
while j<m-1:
if mat[n-1][j]==1:
flip(n-1,j)
flip(n-2,j)
flip(n-2,j+1)
k+=1
out.append([n,j+1,n-1,j+1,n-1,j+2])
if mat[n-1][j+1]==1:
flip(n-1,j+1)
flip(n-2,j)
flip(n-2,j+1)
k+=1
out.append([n,j+2,n-1,j+1,n-1,j+2])
j+=2
while i<n-1:
j=0
if m%2:
if mat[i][m-1]:
flip(i,m-1)
flip(i,m-2)
flip(i+1,m-2)
k+=1
out.append([i+1,m,i+1,m-1,i+2,m-1])
if mat[i+1][m-1]:
flip(i+1,m-1)
flip(i,m-2)
flip(i+1,m-2)
k+=1
out.append([i+2,m,i+1,m-1,i+2,m-1])
while j<m-1:
func(i,j,i+1,j+1)
j+=2
i+=2
print(k)
for i in out:
print(*i)
``` | instruction | 0 | 42,301 | 11 | 84,602 |
Yes | output | 1 | 42,301 | 11 | 84,603 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is the hard version of the problem. The difference between the versions is in the number of possible operations that can be made. You can make hacks if and only if you solved both versions of the problem.
You are given a binary table of size n Γ m. This table consists of symbols 0 and 1.
You can make such operation: select 3 different cells that belong to one 2 Γ 2 square and change the symbols in these cells (change 0 to 1 and 1 to 0).
Your task is to make all symbols in the table equal to 0. You are allowed to make at most nm operations. You don't need to minimize the number of operations.
It can be proved, that it is always possible.
Input
The first line contains a single integer t (1 β€ t β€ 5000) β the number of test cases. The next lines contain descriptions of test cases.
The first line of the description of each test case contains two integers n, m (2 β€ n, m β€ 100).
Each of the next n lines contains a binary string of length m, describing the symbols of the next row of the table.
It is guaranteed, that the sum of nm for all test cases does not exceed 20000.
Output
For each test case print the integer k (0 β€ k β€ nm) β the number of operations.
In the each of the next k lines print 6 integers x_1, y_1, x_2, y_2, x_3, y_3 (1 β€ x_1, x_2, x_3 β€ n, 1 β€ y_1, y_2, y_3 β€ m) describing the next operation. This operation will be made with three cells (x_1, y_1), (x_2, y_2), (x_3, y_3). These three cells should be different. These three cells should belong to some 2 Γ 2 square.
Example
Input
5
2 2
10
11
3 3
011
101
110
4 4
1111
0110
0110
1111
5 5
01011
11001
00010
11011
10000
2 3
011
101
Output
1
1 1 2 1 2 2
2
2 1 3 1 3 2
1 2 1 3 2 3
4
1 1 1 2 2 2
1 3 1 4 2 3
3 2 4 1 4 2
3 3 4 3 4 4
4
1 2 2 1 2 2
1 4 1 5 2 5
4 1 4 2 5 1
4 4 4 5 3 4
2
1 3 2 2 2 3
1 2 2 1 2 2
Note
In the first test case, it is possible to make only one operation with cells (1, 1), (2, 1), (2, 2). After that, all symbols will be equal to 0.
In the second test case:
* operation with cells (2, 1), (3, 1), (3, 2). After it the table will be:
011
001
000
* operation with cells (1, 2), (1, 3), (2, 3). After it the table will be:
000
000
000
In the fifth test case:
* operation with cells (1, 3), (2, 2), (2, 3). After it the table will be:
010
110
* operation with cells (1, 2), (2, 1), (2, 2). After it the table will be:
000
000
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def main():
for _ in range(int(input())):
n, m = [int(x) for x in input().split()]
t = [[int(x) for x in input()] for i in range(n)]
ans = []
def op(a, b, c):
t[a[0]][a[1]] ^= 1
t[b[0]][b[1]] ^= 1
t[c[0]][c[1]] ^= 1
ans.append([a[0]+1, a[1]+1, b[0]+1, b[1]+1, c[0]+1, c[1]+1])
for i in range(n-1, 1, -1):
for j in range(m):
if t[i][j]:
if j + 1 < m:
op((i, j), (i-1, j), (i-1, j+1))
else:
op((i, j), (i-1, j), (i-1, j-1))
for j in range(m-1, 1, -1):
for i in range(2):
if t[i][j]:
op((i, j), (0, j-1), (1, j-1))
for i in range(2):
for j in range(2):
tot = t[0][0] + t[0][1] + t[1][0] + t[1][1]
if (tot + t[i][j]) % 2:
op((1-i, j), (1-i, 1-j), (i, 1-j))
print(len(ans))
for op in ans:
print(*op)
main()
``` | instruction | 0 | 42,302 | 11 | 84,604 |
Yes | output | 1 | 42,302 | 11 | 84,605 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.