text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
In a building where Polycarp lives there are equal number of flats on each floor. Unfortunately, Polycarp don't remember how many flats are on each floor, but he remembers that the flats are numbered from 1 from lower to upper floors. That is, the first several flats are on the first floor, the next several flats are on the second and so on. Polycarp don't remember the total number of flats in the building, so you can consider the building to be infinitely high (i.e. there are infinitely many floors). Note that the floors are numbered from 1.
Polycarp remembers on which floors several flats are located. It is guaranteed that this information is not self-contradictory. It means that there exists a building with equal number of flats on each floor so that the flats from Polycarp's memory have the floors Polycarp remembers.
Given this information, is it possible to restore the exact floor for flat n?
Input
The first line contains two integers n and m (1 β€ n β€ 100, 0 β€ m β€ 100), where n is the number of the flat you need to restore floor for, and m is the number of flats in Polycarp's memory.
m lines follow, describing the Polycarp's memory: each of these lines contains a pair of integers ki, fi (1 β€ ki β€ 100, 1 β€ fi β€ 100), which means that the flat ki is on the fi-th floor. All values ki are distinct.
It is guaranteed that the given information is not self-contradictory.
Output
Print the number of the floor in which the n-th flat is located, if it is possible to determine it in a unique way. Print -1 if it is not possible to uniquely restore this floor.
Examples
Input
10 3
6 2
2 1
7 3
Output
4
Input
8 4
3 1
6 2
5 2
2 1
Output
-1
Note
In the first example the 6-th flat is on the 2-nd floor, while the 7-th flat is on the 3-rd, so, the 6-th flat is the last on its floor and there are 3 flats on each floor. Thus, the 10-th flat is on the 4-th floor.
In the second example there can be 3 or 4 flats on each floor, so we can't restore the floor for the 8-th flat.
Tags: brute force, implementation
Correct Solution:
```
import sys, os
n, m = map(int, input().split())
mi = []
ma = []
if m == 0:
if n == 1:
print(1)
else:
print(-1)
exit(0)
sys.exit()
os.abort()
for i in range(m):
a, b = map(int, input().split())
if b == 1:
ma.append(1000000000)
mi.append(a)
if n <= a:
print(1)
exit(0)
sys.exit()
os.abort()
else:
mak = (a - 1) // (b - 1)
ma.append(mak)
if a % b == 0:
mi.append(a // b)
else:
mi.append((a // b ) + 1)
#print(mi, ma)
mik = min(ma)
mak = max(mi)
if n % mik == 0:
a = n // mik
else:
a = (n // mik) + 1
if n % mak == 0:
b = n // mak
else:
b = (n // mak) + 1
if a == b:
print(b)
else:
print(-1)
```
| 100,000 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a building where Polycarp lives there are equal number of flats on each floor. Unfortunately, Polycarp don't remember how many flats are on each floor, but he remembers that the flats are numbered from 1 from lower to upper floors. That is, the first several flats are on the first floor, the next several flats are on the second and so on. Polycarp don't remember the total number of flats in the building, so you can consider the building to be infinitely high (i.e. there are infinitely many floors). Note that the floors are numbered from 1.
Polycarp remembers on which floors several flats are located. It is guaranteed that this information is not self-contradictory. It means that there exists a building with equal number of flats on each floor so that the flats from Polycarp's memory have the floors Polycarp remembers.
Given this information, is it possible to restore the exact floor for flat n?
Input
The first line contains two integers n and m (1 β€ n β€ 100, 0 β€ m β€ 100), where n is the number of the flat you need to restore floor for, and m is the number of flats in Polycarp's memory.
m lines follow, describing the Polycarp's memory: each of these lines contains a pair of integers ki, fi (1 β€ ki β€ 100, 1 β€ fi β€ 100), which means that the flat ki is on the fi-th floor. All values ki are distinct.
It is guaranteed that the given information is not self-contradictory.
Output
Print the number of the floor in which the n-th flat is located, if it is possible to determine it in a unique way. Print -1 if it is not possible to uniquely restore this floor.
Examples
Input
10 3
6 2
2 1
7 3
Output
4
Input
8 4
3 1
6 2
5 2
2 1
Output
-1
Note
In the first example the 6-th flat is on the 2-nd floor, while the 7-th flat is on the 3-rd, so, the 6-th flat is the last on its floor and there are 3 flats on each floor. Thus, the 10-th flat is on the 4-th floor.
In the second example there can be 3 or 4 flats on each floor, so we can't restore the floor for the 8-th flat.
Tags: brute force, implementation
Correct Solution:
```
def rec(i):
global a
return i
import sys
from collections import Counter
sys.setrecursionlimit(10**6)
#n=int(input())
n,m=list(map(int,input().split()))
a=[[] for i in range(100)]
b=[i for i in range(1,101)]
for i in range(m):
x,y=list(map(int,input().split()))
z=b.copy()
for i0 in z:
if not(((x-1)>=(y-1)*i0)and((x-1)<y*i0)):
b.remove(i0)
a=set()
for i0 in b:
a.add((n-1)//i0)
if len(a)==1:
print(a.pop()+1)
else:
print(-1)
```
| 100,001 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a building where Polycarp lives there are equal number of flats on each floor. Unfortunately, Polycarp don't remember how many flats are on each floor, but he remembers that the flats are numbered from 1 from lower to upper floors. That is, the first several flats are on the first floor, the next several flats are on the second and so on. Polycarp don't remember the total number of flats in the building, so you can consider the building to be infinitely high (i.e. there are infinitely many floors). Note that the floors are numbered from 1.
Polycarp remembers on which floors several flats are located. It is guaranteed that this information is not self-contradictory. It means that there exists a building with equal number of flats on each floor so that the flats from Polycarp's memory have the floors Polycarp remembers.
Given this information, is it possible to restore the exact floor for flat n?
Input
The first line contains two integers n and m (1 β€ n β€ 100, 0 β€ m β€ 100), where n is the number of the flat you need to restore floor for, and m is the number of flats in Polycarp's memory.
m lines follow, describing the Polycarp's memory: each of these lines contains a pair of integers ki, fi (1 β€ ki β€ 100, 1 β€ fi β€ 100), which means that the flat ki is on the fi-th floor. All values ki are distinct.
It is guaranteed that the given information is not self-contradictory.
Output
Print the number of the floor in which the n-th flat is located, if it is possible to determine it in a unique way. Print -1 if it is not possible to uniquely restore this floor.
Examples
Input
10 3
6 2
2 1
7 3
Output
4
Input
8 4
3 1
6 2
5 2
2 1
Output
-1
Note
In the first example the 6-th flat is on the 2-nd floor, while the 7-th flat is on the 3-rd, so, the 6-th flat is the last on its floor and there are 3 flats on each floor. Thus, the 10-th flat is on the 4-th floor.
In the second example there can be 3 or 4 flats on each floor, so we can't restore the floor for the 8-th flat.
Tags: brute force, implementation
Correct Solution:
```
n,m=map(int,input().split())
n-=1
k=[]
f=[]
p=0
for i in range(m):
q=list(map(int,input().split()))
k.append(q[0])
f.append(q[1])
for i in range(1,101):
for j in range(m):
if ((k[j]-1)//i)+1!=f[j]:
break
else:
if not p:
p=n//i+1
else:
q=n//i+1
if p!=q:
print(-1)
exit()
print(p)
```
| 100,002 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a building where Polycarp lives there are equal number of flats on each floor. Unfortunately, Polycarp don't remember how many flats are on each floor, but he remembers that the flats are numbered from 1 from lower to upper floors. That is, the first several flats are on the first floor, the next several flats are on the second and so on. Polycarp don't remember the total number of flats in the building, so you can consider the building to be infinitely high (i.e. there are infinitely many floors). Note that the floors are numbered from 1.
Polycarp remembers on which floors several flats are located. It is guaranteed that this information is not self-contradictory. It means that there exists a building with equal number of flats on each floor so that the flats from Polycarp's memory have the floors Polycarp remembers.
Given this information, is it possible to restore the exact floor for flat n?
Input
The first line contains two integers n and m (1 β€ n β€ 100, 0 β€ m β€ 100), where n is the number of the flat you need to restore floor for, and m is the number of flats in Polycarp's memory.
m lines follow, describing the Polycarp's memory: each of these lines contains a pair of integers ki, fi (1 β€ ki β€ 100, 1 β€ fi β€ 100), which means that the flat ki is on the fi-th floor. All values ki are distinct.
It is guaranteed that the given information is not self-contradictory.
Output
Print the number of the floor in which the n-th flat is located, if it is possible to determine it in a unique way. Print -1 if it is not possible to uniquely restore this floor.
Examples
Input
10 3
6 2
2 1
7 3
Output
4
Input
8 4
3 1
6 2
5 2
2 1
Output
-1
Note
In the first example the 6-th flat is on the 2-nd floor, while the 7-th flat is on the 3-rd, so, the 6-th flat is the last on its floor and there are 3 flats on each floor. Thus, the 10-th flat is on the 4-th floor.
In the second example there can be 3 or 4 flats on each floor, so we can't restore the floor for the 8-th flat.
Tags: brute force, implementation
Correct Solution:
```
from math import ceil
n, m = map(int, input().split())
k = [0 for i in range(m)]
f = [0 for i in range(m)]
x = -1
for i in range(m):
k[i], f[i] = map(int, input().split())
i = 0
while i < m:
j = i
while j < m:
if abs(k[i] - k[j]) == 1 and abs(f[i] - f[j]) == 1:
if f[i] < f[j]:
x = ceil(n / ceil(k[i] / f[i]))
else:
x = ceil(n / ceil(k[j] / f[j]))
i = m - 1
j = i
j += 1
i += 1
if x > 0:
print(x)
else:
c = []
for i in range(1, 101):
j = 0
b = True
while j < m and b:
if not (ceil(k[j] / i) == f[j]):
b = False
j += 1
if b:
c.append(i)
x = ceil(n / c[0])
for i in range(len(c)):
if ceil(n / c[i]) != x:
x = -1
break
print(x)
```
| 100,003 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a building where Polycarp lives there are equal number of flats on each floor. Unfortunately, Polycarp don't remember how many flats are on each floor, but he remembers that the flats are numbered from 1 from lower to upper floors. That is, the first several flats are on the first floor, the next several flats are on the second and so on. Polycarp don't remember the total number of flats in the building, so you can consider the building to be infinitely high (i.e. there are infinitely many floors). Note that the floors are numbered from 1.
Polycarp remembers on which floors several flats are located. It is guaranteed that this information is not self-contradictory. It means that there exists a building with equal number of flats on each floor so that the flats from Polycarp's memory have the floors Polycarp remembers.
Given this information, is it possible to restore the exact floor for flat n?
Input
The first line contains two integers n and m (1 β€ n β€ 100, 0 β€ m β€ 100), where n is the number of the flat you need to restore floor for, and m is the number of flats in Polycarp's memory.
m lines follow, describing the Polycarp's memory: each of these lines contains a pair of integers ki, fi (1 β€ ki β€ 100, 1 β€ fi β€ 100), which means that the flat ki is on the fi-th floor. All values ki are distinct.
It is guaranteed that the given information is not self-contradictory.
Output
Print the number of the floor in which the n-th flat is located, if it is possible to determine it in a unique way. Print -1 if it is not possible to uniquely restore this floor.
Examples
Input
10 3
6 2
2 1
7 3
Output
4
Input
8 4
3 1
6 2
5 2
2 1
Output
-1
Note
In the first example the 6-th flat is on the 2-nd floor, while the 7-th flat is on the 3-rd, so, the 6-th flat is the last on its floor and there are 3 flats on each floor. Thus, the 10-th flat is on the 4-th floor.
In the second example there can be 3 or 4 flats on each floor, so we can't restore the floor for the 8-th flat.
Tags: brute force, implementation
Correct Solution:
```
def xor(a,b,i):
if (((a-1)//i)==(b-1)):
return True
elif(a<i) and (b==1):
return True
else:
return False
dannie = input()
dannie = dannie.split(' ')
level = int(dannie[0])
n = int(dannie[1])
levels = []
if level == 1:
print(1)
elif n == 0:
print(-1)
else:
for i in range(0,n):
info = input()
info = info.split(' ')
levels.append(info)
fl = True
i = 1
count = 0
while (i<=100) and (fl):
for etaz in levels:
fl2 = True
flat = int(etaz[0])
floor = int(etaz[1])
if xor(flat, floor, i):
continue
else:
fl2 = False
if not(fl2):
break
if not(fl2):
i = i + 1
elif (count==0) and fl2:
count += 1
if level%i==0:
answer = int(level/i)
i = i + 1
else:
answer = int((level//i) + 1)
i = i + 1
elif fl2 and count!=0:
if level%i==0:
answer1 = level/i
else:
answer1 = level//i + 1
if answer1 == answer:
i = i + 1
continue
else:
print(-1)
fl = False
else:
i +=1
if fl :
try:
print(answer)
except NameError:
print(-1)
```
| 100,004 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a building where Polycarp lives there are equal number of flats on each floor. Unfortunately, Polycarp don't remember how many flats are on each floor, but he remembers that the flats are numbered from 1 from lower to upper floors. That is, the first several flats are on the first floor, the next several flats are on the second and so on. Polycarp don't remember the total number of flats in the building, so you can consider the building to be infinitely high (i.e. there are infinitely many floors). Note that the floors are numbered from 1.
Polycarp remembers on which floors several flats are located. It is guaranteed that this information is not self-contradictory. It means that there exists a building with equal number of flats on each floor so that the flats from Polycarp's memory have the floors Polycarp remembers.
Given this information, is it possible to restore the exact floor for flat n?
Input
The first line contains two integers n and m (1 β€ n β€ 100, 0 β€ m β€ 100), where n is the number of the flat you need to restore floor for, and m is the number of flats in Polycarp's memory.
m lines follow, describing the Polycarp's memory: each of these lines contains a pair of integers ki, fi (1 β€ ki β€ 100, 1 β€ fi β€ 100), which means that the flat ki is on the fi-th floor. All values ki are distinct.
It is guaranteed that the given information is not self-contradictory.
Output
Print the number of the floor in which the n-th flat is located, if it is possible to determine it in a unique way. Print -1 if it is not possible to uniquely restore this floor.
Examples
Input
10 3
6 2
2 1
7 3
Output
4
Input
8 4
3 1
6 2
5 2
2 1
Output
-1
Note
In the first example the 6-th flat is on the 2-nd floor, while the 7-th flat is on the 3-rd, so, the 6-th flat is the last on its floor and there are 3 flats on each floor. Thus, the 10-th flat is on the 4-th floor.
In the second example there can be 3 or 4 flats on each floor, so we can't restore the floor for the 8-th flat.
Submitted Solution:
```
import math
n,q = map(int,input().split())
lst = [ ]
for i in range(q):
x,y = map(int,input().split())
lst.append((x,y))
ans = set()
for no_of_floors in range(1,101):
flag = 1
for k,f in lst:
temp_floor = math.ceil(k/no_of_floors)
if(temp_floor!=f):
flag = 0
if(flag):
temp = math.ceil(n/no_of_floors)
ans.add(temp)
if(len(ans)!=1):
print(-1)
else:
print(*ans)
```
Yes
| 100,005 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a building where Polycarp lives there are equal number of flats on each floor. Unfortunately, Polycarp don't remember how many flats are on each floor, but he remembers that the flats are numbered from 1 from lower to upper floors. That is, the first several flats are on the first floor, the next several flats are on the second and so on. Polycarp don't remember the total number of flats in the building, so you can consider the building to be infinitely high (i.e. there are infinitely many floors). Note that the floors are numbered from 1.
Polycarp remembers on which floors several flats are located. It is guaranteed that this information is not self-contradictory. It means that there exists a building with equal number of flats on each floor so that the flats from Polycarp's memory have the floors Polycarp remembers.
Given this information, is it possible to restore the exact floor for flat n?
Input
The first line contains two integers n and m (1 β€ n β€ 100, 0 β€ m β€ 100), where n is the number of the flat you need to restore floor for, and m is the number of flats in Polycarp's memory.
m lines follow, describing the Polycarp's memory: each of these lines contains a pair of integers ki, fi (1 β€ ki β€ 100, 1 β€ fi β€ 100), which means that the flat ki is on the fi-th floor. All values ki are distinct.
It is guaranteed that the given information is not self-contradictory.
Output
Print the number of the floor in which the n-th flat is located, if it is possible to determine it in a unique way. Print -1 if it is not possible to uniquely restore this floor.
Examples
Input
10 3
6 2
2 1
7 3
Output
4
Input
8 4
3 1
6 2
5 2
2 1
Output
-1
Note
In the first example the 6-th flat is on the 2-nd floor, while the 7-th flat is on the 3-rd, so, the 6-th flat is the last on its floor and there are 3 flats on each floor. Thus, the 10-th flat is on the 4-th floor.
In the second example there can be 3 or 4 flats on each floor, so we can't restore the floor for the 8-th flat.
Submitted Solution:
```
import math
def find_3():
etazh = []
for p in range(1, 101):
if all((memory[0] + p - 1) // p == memory[1] for memory in mass):
etazh.append(p)
return etazh
def find_2():
etazh = []
p = 1
while p < 100:
for i in range (m):
if math.ceil(mass[i][0]/p) != mass[i][1]:
p += 1
break
elif i==(m-1):
etazh.append(p)
p += 1
return etazh
def find_1():
etazh = []
for p in range(100):
suit = True
for i in range(m):
if math.ceil(mass[i][0]/p) != mass[i][1]:
suit = False
break
if suit:
etazh.append(p)
return etazh
n, m = map(int, input().split())
mass = []
for i in range (m):
mass.append(list(map(int, input().split())))
etazh = find_3()
if all((n+x-1)//x == (n+etazh[0]-1)//etazh[0] for x in etazh):
print((n+etazh[0]-1)//etazh[0])
else:
print(-1)
```
Yes
| 100,006 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a building where Polycarp lives there are equal number of flats on each floor. Unfortunately, Polycarp don't remember how many flats are on each floor, but he remembers that the flats are numbered from 1 from lower to upper floors. That is, the first several flats are on the first floor, the next several flats are on the second and so on. Polycarp don't remember the total number of flats in the building, so you can consider the building to be infinitely high (i.e. there are infinitely many floors). Note that the floors are numbered from 1.
Polycarp remembers on which floors several flats are located. It is guaranteed that this information is not self-contradictory. It means that there exists a building with equal number of flats on each floor so that the flats from Polycarp's memory have the floors Polycarp remembers.
Given this information, is it possible to restore the exact floor for flat n?
Input
The first line contains two integers n and m (1 β€ n β€ 100, 0 β€ m β€ 100), where n is the number of the flat you need to restore floor for, and m is the number of flats in Polycarp's memory.
m lines follow, describing the Polycarp's memory: each of these lines contains a pair of integers ki, fi (1 β€ ki β€ 100, 1 β€ fi β€ 100), which means that the flat ki is on the fi-th floor. All values ki are distinct.
It is guaranteed that the given information is not self-contradictory.
Output
Print the number of the floor in which the n-th flat is located, if it is possible to determine it in a unique way. Print -1 if it is not possible to uniquely restore this floor.
Examples
Input
10 3
6 2
2 1
7 3
Output
4
Input
8 4
3 1
6 2
5 2
2 1
Output
-1
Note
In the first example the 6-th flat is on the 2-nd floor, while the 7-th flat is on the 3-rd, so, the 6-th flat is the last on its floor and there are 3 flats on each floor. Thus, the 10-th flat is on the 4-th floor.
In the second example there can be 3 or 4 flats on each floor, so we can't restore the floor for the 8-th flat.
Submitted Solution:
```
n, m = map(int, input().split())
k = [0] * 500
f = [0] * 500
for i in range(m):
k[i], f[i] = map(int, input().split())
vars = set()
for cnt in range(1, 201):
flag = 1
for i in range(m):
if (k[i] - 1) // cnt != f[i] - 1:
flag = 0
break
if flag:
vars.add((n - 1) // cnt + 1)
if n == 1:
ans = 1
else:
ans = -1 if len(vars) > 1 else max(vars)
print(ans)
```
Yes
| 100,007 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a building where Polycarp lives there are equal number of flats on each floor. Unfortunately, Polycarp don't remember how many flats are on each floor, but he remembers that the flats are numbered from 1 from lower to upper floors. That is, the first several flats are on the first floor, the next several flats are on the second and so on. Polycarp don't remember the total number of flats in the building, so you can consider the building to be infinitely high (i.e. there are infinitely many floors). Note that the floors are numbered from 1.
Polycarp remembers on which floors several flats are located. It is guaranteed that this information is not self-contradictory. It means that there exists a building with equal number of flats on each floor so that the flats from Polycarp's memory have the floors Polycarp remembers.
Given this information, is it possible to restore the exact floor for flat n?
Input
The first line contains two integers n and m (1 β€ n β€ 100, 0 β€ m β€ 100), where n is the number of the flat you need to restore floor for, and m is the number of flats in Polycarp's memory.
m lines follow, describing the Polycarp's memory: each of these lines contains a pair of integers ki, fi (1 β€ ki β€ 100, 1 β€ fi β€ 100), which means that the flat ki is on the fi-th floor. All values ki are distinct.
It is guaranteed that the given information is not self-contradictory.
Output
Print the number of the floor in which the n-th flat is located, if it is possible to determine it in a unique way. Print -1 if it is not possible to uniquely restore this floor.
Examples
Input
10 3
6 2
2 1
7 3
Output
4
Input
8 4
3 1
6 2
5 2
2 1
Output
-1
Note
In the first example the 6-th flat is on the 2-nd floor, while the 7-th flat is on the 3-rd, so, the 6-th flat is the last on its floor and there are 3 flats on each floor. Thus, the 10-th flat is on the 4-th floor.
In the second example there can be 3 or 4 flats on each floor, so we can't restore the floor for the 8-th flat.
Submitted Solution:
```
n, m = map(int, input().split())
ans = -1
k = []
f = []
for i in range(m):
flat, level = map(int, input().split())
k.append(flat)
f.append(level)
mainflag = True
for count in range(1, 101):
flag = True
for i in range(m):
if (k[i] + count - 1) // count != f[i]:
flag = False
break
if flag and ans != -1 and (n + count - 1) // count != (n + ans - 1) // ans:
mainflag = False
elif flag:
ans = count
if mainflag:
print((n + ans - 1) // ans)
else:
print(-1)
```
Yes
| 100,008 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a building where Polycarp lives there are equal number of flats on each floor. Unfortunately, Polycarp don't remember how many flats are on each floor, but he remembers that the flats are numbered from 1 from lower to upper floors. That is, the first several flats are on the first floor, the next several flats are on the second and so on. Polycarp don't remember the total number of flats in the building, so you can consider the building to be infinitely high (i.e. there are infinitely many floors). Note that the floors are numbered from 1.
Polycarp remembers on which floors several flats are located. It is guaranteed that this information is not self-contradictory. It means that there exists a building with equal number of flats on each floor so that the flats from Polycarp's memory have the floors Polycarp remembers.
Given this information, is it possible to restore the exact floor for flat n?
Input
The first line contains two integers n and m (1 β€ n β€ 100, 0 β€ m β€ 100), where n is the number of the flat you need to restore floor for, and m is the number of flats in Polycarp's memory.
m lines follow, describing the Polycarp's memory: each of these lines contains a pair of integers ki, fi (1 β€ ki β€ 100, 1 β€ fi β€ 100), which means that the flat ki is on the fi-th floor. All values ki are distinct.
It is guaranteed that the given information is not self-contradictory.
Output
Print the number of the floor in which the n-th flat is located, if it is possible to determine it in a unique way. Print -1 if it is not possible to uniquely restore this floor.
Examples
Input
10 3
6 2
2 1
7 3
Output
4
Input
8 4
3 1
6 2
5 2
2 1
Output
-1
Note
In the first example the 6-th flat is on the 2-nd floor, while the 7-th flat is on the 3-rd, so, the 6-th flat is the last on its floor and there are 3 flats on each floor. Thus, the 10-th flat is on the 4-th floor.
In the second example there can be 3 or 4 flats on each floor, so we can't restore the floor for the 8-th flat.
Submitted Solution:
```
n, m = map(int, input().split())
a = []
for i in range(m):
k, f = map(int, input().split())
a.append((k, f))
cnt = 0
num = 0
for e in range(1, 101):
can = True
for k, f in a:
if f != (k + e - 1) // e:
can = False
break
if can:
cnt += 1
num = e
if cnt == 1:
print((n + num - 1) // num)
else:
print(-1)
```
No
| 100,009 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a building where Polycarp lives there are equal number of flats on each floor. Unfortunately, Polycarp don't remember how many flats are on each floor, but he remembers that the flats are numbered from 1 from lower to upper floors. That is, the first several flats are on the first floor, the next several flats are on the second and so on. Polycarp don't remember the total number of flats in the building, so you can consider the building to be infinitely high (i.e. there are infinitely many floors). Note that the floors are numbered from 1.
Polycarp remembers on which floors several flats are located. It is guaranteed that this information is not self-contradictory. It means that there exists a building with equal number of flats on each floor so that the flats from Polycarp's memory have the floors Polycarp remembers.
Given this information, is it possible to restore the exact floor for flat n?
Input
The first line contains two integers n and m (1 β€ n β€ 100, 0 β€ m β€ 100), where n is the number of the flat you need to restore floor for, and m is the number of flats in Polycarp's memory.
m lines follow, describing the Polycarp's memory: each of these lines contains a pair of integers ki, fi (1 β€ ki β€ 100, 1 β€ fi β€ 100), which means that the flat ki is on the fi-th floor. All values ki are distinct.
It is guaranteed that the given information is not self-contradictory.
Output
Print the number of the floor in which the n-th flat is located, if it is possible to determine it in a unique way. Print -1 if it is not possible to uniquely restore this floor.
Examples
Input
10 3
6 2
2 1
7 3
Output
4
Input
8 4
3 1
6 2
5 2
2 1
Output
-1
Note
In the first example the 6-th flat is on the 2-nd floor, while the 7-th flat is on the 3-rd, so, the 6-th flat is the last on its floor and there are 3 flats on each floor. Thus, the 10-th flat is on the 4-th floor.
In the second example there can be 3 or 4 flats on each floor, so we can't restore the floor for the 8-th flat.
Submitted Solution:
```
n, m = map(int, input().split())
k, f = map(int, input().split())
omin=(k-1)//f+1
omax = -1
if f > 1:
omax=(k-1)//(f-1)
for i in range(m-1):
k, f = map(int, input().split())
localmin = (k-1) // f + 1
if f > 1:
localmax = (k-1) // (f - 1)
else:
localmax = -1
omin = max(localmin, omin)
if localmax != -1 and (localmax < omax or omax == -1):
omax = localmax
if omax == omin:
print((n - 1) // omin + 1)
elif omax == -1:
print(1)
else:
print(-1)
```
No
| 100,010 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a building where Polycarp lives there are equal number of flats on each floor. Unfortunately, Polycarp don't remember how many flats are on each floor, but he remembers that the flats are numbered from 1 from lower to upper floors. That is, the first several flats are on the first floor, the next several flats are on the second and so on. Polycarp don't remember the total number of flats in the building, so you can consider the building to be infinitely high (i.e. there are infinitely many floors). Note that the floors are numbered from 1.
Polycarp remembers on which floors several flats are located. It is guaranteed that this information is not self-contradictory. It means that there exists a building with equal number of flats on each floor so that the flats from Polycarp's memory have the floors Polycarp remembers.
Given this information, is it possible to restore the exact floor for flat n?
Input
The first line contains two integers n and m (1 β€ n β€ 100, 0 β€ m β€ 100), where n is the number of the flat you need to restore floor for, and m is the number of flats in Polycarp's memory.
m lines follow, describing the Polycarp's memory: each of these lines contains a pair of integers ki, fi (1 β€ ki β€ 100, 1 β€ fi β€ 100), which means that the flat ki is on the fi-th floor. All values ki are distinct.
It is guaranteed that the given information is not self-contradictory.
Output
Print the number of the floor in which the n-th flat is located, if it is possible to determine it in a unique way. Print -1 if it is not possible to uniquely restore this floor.
Examples
Input
10 3
6 2
2 1
7 3
Output
4
Input
8 4
3 1
6 2
5 2
2 1
Output
-1
Note
In the first example the 6-th flat is on the 2-nd floor, while the 7-th flat is on the 3-rd, so, the 6-th flat is the last on its floor and there are 3 flats on each floor. Thus, the 10-th flat is on the 4-th floor.
In the second example there can be 3 or 4 flats on each floor, so we can't restore the floor for the 8-th flat.
Submitted Solution:
```
from sys import stdout
from sys import stdin
def get():
return stdin.readline().strip()
def getf():
return [int(i) for i in get().split()]
def put(a, end = "\n"):
stdout.write(str(a) + end)
def putf(a, sep = " ", end = "\n"):
stdout.write(sep.join(map(str, a)) + end)
from math import ceil
def main():
n, m = getf()
fl = [[] for i in range(101)]
for i in range(m):
k, f = getf()
fl[f] += [k]
ans = -1
fl1 = -1
for i in range(1, 101):
if(min(fl[i] or [-1]) <= n <= max(fl[i] or [-1])):
ans = i
for i in range(1, 100):
f1, f2 = fl[i], fl[i + 1]
if not(f1 and f2):
continue
k1, k2 = max(f1), min(f2)
if(k2 - k1 == 1):
fl1 = k1 // i
if(ans == -1):
if(fl1 != -1):
put(int(ceil(n / fl1)))
else:
put(-1)
else:
put(ans)
main()
```
No
| 100,011 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a building where Polycarp lives there are equal number of flats on each floor. Unfortunately, Polycarp don't remember how many flats are on each floor, but he remembers that the flats are numbered from 1 from lower to upper floors. That is, the first several flats are on the first floor, the next several flats are on the second and so on. Polycarp don't remember the total number of flats in the building, so you can consider the building to be infinitely high (i.e. there are infinitely many floors). Note that the floors are numbered from 1.
Polycarp remembers on which floors several flats are located. It is guaranteed that this information is not self-contradictory. It means that there exists a building with equal number of flats on each floor so that the flats from Polycarp's memory have the floors Polycarp remembers.
Given this information, is it possible to restore the exact floor for flat n?
Input
The first line contains two integers n and m (1 β€ n β€ 100, 0 β€ m β€ 100), where n is the number of the flat you need to restore floor for, and m is the number of flats in Polycarp's memory.
m lines follow, describing the Polycarp's memory: each of these lines contains a pair of integers ki, fi (1 β€ ki β€ 100, 1 β€ fi β€ 100), which means that the flat ki is on the fi-th floor. All values ki are distinct.
It is guaranteed that the given information is not self-contradictory.
Output
Print the number of the floor in which the n-th flat is located, if it is possible to determine it in a unique way. Print -1 if it is not possible to uniquely restore this floor.
Examples
Input
10 3
6 2
2 1
7 3
Output
4
Input
8 4
3 1
6 2
5 2
2 1
Output
-1
Note
In the first example the 6-th flat is on the 2-nd floor, while the 7-th flat is on the 3-rd, so, the 6-th flat is the last on its floor and there are 3 flats on each floor. Thus, the 10-th flat is on the 4-th floor.
In the second example there can be 3 or 4 flats on each floor, so we can't restore the floor for the 8-th flat.
Submitted Solution:
```
from math import ceil
def check(flats_on_level):
for fl in flats:
after = ceil(fl[0] / flats_on_level)
if fl[1] != after:
return False
return True
n, m = map(int, input().split())
flats = []
for _ in range(m):
ki, fi = map(int, input().split())
flats.append((ki, fi))
answer = -1
cf = -1
if m == 0 and n == 1:
print(1)
exit(0)
for i in range(1, 101):
if check(i):
if answer == -1:
answer = i
else:
cf == i
if ceil(n / answer) != ceil(n / cf):
print(-1)
else:
print(ceil(n / answer))
```
No
| 100,012 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Tags: brute force, implementation, strings
Correct Solution:
```
# -*- coding: utf-8 -*-
import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
"""
created by shhuan at 2017/10/22 18:15
"""
N = int(input())
S = input()
def split(s, wc, pl, n):
ans = []
if pl % 2 == 0:
if any([x % 2 == 1 for x in wc.values()]):
return []
for i in range(0, len(s), pl):
t = s[i:i + pl]
ans.append(t[::2] + t[::-1][::2])
return ans
mid = [w for w, c in wc.items() if c % 2 == 1]
if len(mid) > n:
return []
midindex = 0
while len(ans) < n:
t = ''
u = mid[midindex] if midindex < len(mid) else ''
midindex += 1
if not u:
u = list([w for w, c in wc.items() if c > 0])[0]
wc[u] -= 1
need = pl-1
while need > 0:
pneed = need
for w, c in [(w, c) for w, c in wc.items()]:
if c > need:
t += str(w) * (need//2)
wc[w] -= need
need = 0
break
elif c > 1:
c //= 2
t += str(w) * c
wc[w] -= c * 2
need -= c*2
if need == pneed:
return []
t = t + u + t[::-1]
if len(t) < pl:
return []
ans.append(t)
return ans
S = "".join(sorted(list(S)))
WC = collections.Counter(S)
for parts in range(1, N+1):
if N % parts == 0:
wc = {k: v for k, v in WC.items()}
ans = split(S, wc, N//parts, parts)
if ans:
print(parts)
print(" ".join(ans))
exit(0)
```
| 100,013 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Tags: brute force, implementation, strings
Correct Solution:
```
import sys
import math
from collections import defaultdict,deque
def is_possible(odd,even):
each = odd*2
if even % each == 0:
return True
return False
n=int(sys.stdin.readline())
s=sys.stdin.readline()[:-1]
dic=defaultdict(int)
for i in range(n):
dic[s[i]]+=1
odd,even = 0,0
for i in dic:
if dic[i]%2 != 0:
odd += 1
even += dic[i] - 1
else:
even += dic[i]
if odd == 0:
#print(0)
ans = [0 for x in range(even)]
cnt = 0
for i in dic:
while dic[i] > 0:
ans[cnt] = i
ans[even - cnt - 1] = i
cnt += 1
dic[i] -= 2
#print(ans)
print(1)
print(''.join(x for x in ans))
sys.exit()
while even >= 0:
if is_possible(odd,even):
break
odd += 2
even -= 2
length = 1 + (even) // (odd)
#print(length, 'length')
ans = [deque() for _ in range(odd)]
ansb = [[] for _ in range(odd)]
ansa = [[] for _ in range(odd)]
cnt = 0
#print(dic,'dic')
for i in dic:
if dic[i] % 2 !=0:
ans[cnt].append(i)
dic[i] -= 1
cnt += 1
#print()
#print(ans,' after odd',cnt)
for i in dic:
while dic[i] > 0:
if cnt >= odd:
break
ans[cnt].append(i)
ans[cnt + 1].append(i)
cnt += 2
dic[i] -= 2
if cnt >= odd:
break
cnt = 0
#print(ans,'ans')
for i in dic:
#print(cnt,'cnt',i,'i')
#print(ans[cnt])
if dic[i] > 0:
x = len(ans[cnt])
while dic[i] > 0:
ans[cnt].appendleft(i)
ans[cnt].append(i)
#ans[cnt] = [i] + ans[cnt] + [i]
dic[i] -= 2
x += 2
if x < length:
pass
else:
cnt += 1
if cnt < odd:
x = len(ans[cnt])
#print(ans,'ans')
#print(odd,'odd')
n = len(ans)
#print(n)
l =[]
for i in range(n):
l.append(''.join(x for x in ans[i]))
print(n)
print(*l)
```
| 100,014 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Tags: brute force, implementation, strings
Correct Solution:
```
n = int(input())
s = list(input())
d = {}
for char in s:
if char not in d.keys():
d[char] = 1
else:
d[char] += 1
odd = []
even = []
for char in d.keys():
for i in range(d[char] // 2):
even.append(char)
even.append(char)
for i in range(d[char] % 2):
odd.append(char)
# print(len(even), len(odd))
if len(odd) <= 1:
x = ''.join([even[i] for i in range(1, len(even), 2)])
y = ''.join(odd)
print(1)
print(x + y + x[::-1])
elif len(even) % len(odd) == 0 and (len(even) // len(odd)) % 2 == 0 and (len(even) // len(odd)) > 0:
print(len(odd))
x = []
ratio = len(even) // len(odd)
indx = 0
for i in range(len(odd)):
tail = ''
while len(tail) < ratio // 2:
tail += even[indx]
indx += 2
x.append(tail + odd[i] + tail[::-1])
print(' '.join(x))
else:
ratio = len(even)//len(odd)
max_length = 1
for i in range(1,ratio+1,2):
if (len(even)+len(odd)) % i == 0 and max_length < i:
max_length = i
parts = (len(even) + len(odd))//max_length
print(parts)
x = []
indx = 0
for i in range(len(odd)):
tail = ''
while len(tail) < max_length // 2:
tail += even[indx]
indx += 2
x.append(tail + odd[i] + tail[::-1])
middle = []
for i in range(parts - len(odd)):
middle.append(even.pop())
for i in range(len(middle)):
tail = ''
while len(tail) < max_length // 2:
tail += even[indx]
indx += 2
x.append(tail + middle[i] + tail[::-1])
print(' '.join(x))
```
| 100,015 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Tags: brute force, implementation, strings
Correct Solution:
```
mp,a,p={},[],[]
n=int(input())
for i in input():
if i in mp:mp[i]+=1
else:mp[i]=1
odd=0
for i in mp:
if mp[i]&1:
a.append(i)
mp[i]-=1
odd+=1
if mp[i]:
p.append(i)
m=max(1,odd)
for i in range(m,n+1):
if not n%i:
d=n//i
if odd and not d&1:continue
print(i)
for K in range(i-m):
a.append(p[-1])
if mp[p[-1]]>1:mp[p[-1]]-=1
else:p.pop()
for k in range(i):
s=''
for j in range(d//2):
s+=p[-1]
mp[p[-1]]-=2
if not mp[p[-1]]:p.pop()
if odd:print(s+a.pop()+s[::-1],end=' ')
else:print(s+s[::-1],end=' ')
exit()
```
| 100,016 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Tags: brute force, implementation, strings
Correct Solution:
```
#!/usr/bin/env python3
def main():
import collections
n = int(input())
s = input()
alph = collections.Counter(s)
odd = sum(x & 0x1 for x in alph.values())
dq = collections.deque()
if odd == 0:
print(1)
for c, x in alph.items():
dq.append(c * (x >> 1))
dq.appendleft(c * (x >> 1))
print(*dq, sep="")
else:
for odd in range(odd, n):
if (n - odd) % (odd << 1) == 0:
print(odd)
odds = [c for c, x in alph.items() if x & 0x1]
items = list(alph.items())
while len(odds) != odd:
for i, x in enumerate(items):
if x[1] > 1:
items[i] = (x[0], x[1] - 2)
odds.append(x[0])
odds.append(x[0])
break
req_length = (n - odd) // odd + 1
cur_length = 0
while odd > 0:
if cur_length == 0:
dq.append(odds[-1])
cur_length += 1
odds.pop()
x = min(items[-1][1] >> 1, (req_length - cur_length) >> 1)
dq.append(items[-1][0] * x)
dq.appendleft(items[-1][0] * x)
cur_length += x << 1
if items[-1][1] - (x << 1) <= 1:
items.pop()
else:
items[-1] = (items[-1][0], items[-1][1] - (x << 1))
if cur_length == req_length:
print(*dq, sep="", end=' ')
odd -= 1
dq.clear()
cur_length = 0
print()
break
else:
print(n)
print(*s)
try:
while True:
main()
except EOFError:
pass
```
| 100,017 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Tags: brute force, implementation, strings
Correct Solution:
```
n=int(input())
s=list(input())
lets={}
for i in s:
try:
lets[i]+=1
except:
lets[i]=1
count=0
centre=[]
rest=[]
for i in lets.keys():
if(lets[i]%2):
centre.append(i)
count+=1
rest+=[i]*(lets[i]//2)
if(count==0):
t=''
for i in lets.keys():
t=i*(lets[i]//2) + t + i*(lets[i]//2)
print(1)
print(t)
else:
extra=0
while(n%count!=0 or (n//count)%2==0):
count+=2
extra+=1
for i in range(extra):
centre+=[rest.pop()]*2
amt=len(rest)//(count)
temp=rest.copy()
rest=''
for i in temp:
rest+=i
print(count)
print(rest[0:amt] + centre[0] + rest[(1)*(amt)-1::-1],end=' ')
for i in range(1,count):
print(rest[i*(amt):(i+1)*amt] + centre[i] + rest[(i+1)*(amt)-1:(i)*amt-1:-1],end=' ')
print()
```
| 100,018 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Tags: brute force, implementation, strings
Correct Solution:
```
n = int(input())
s = list(input())
d = {}
for char in s:
if char not in d.keys():
d[char] = 1
else:
d[char] += 1
odd = []
even = []
for char in d.keys():
for i in range(d[char] // 2):
even.append(char)
even.append(char)
for i in range(d[char] % 2):
odd.append(char)
if len(odd) <= 1:
x = ''.join([even[i] for i in range(1, len(even), 2)])
y = ''.join(odd)
print(1)
print(x + y + x[::-1])
else:
ratio = len(even)//len(odd)
max_length = 1
for i in range(1,ratio+2,2):
if n % i == 0 and max_length < i:
max_length = i
parts = n//max_length
print(parts)
x = []
indx = 0
for i in range(len(odd)):
tail = ''
while len(tail) < max_length // 2:
tail += even[indx]
indx += 2
x.append(tail + odd[i] + tail[::-1])
middle = []
for i in range(parts - len(odd)):
middle.append(even.pop())
for i in range(len(middle)):
tail = ''
while len(tail) < max_length // 2:
tail += even[indx]
indx += 2
x.append(tail + middle[i] + tail[::-1])
print(' '.join(x))
```
| 100,019 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Tags: brute force, implementation, strings
Correct Solution:
```
from collections import Counter
n = int(input())
cnt = Counter(input())
odd = []
even = []
for s, c in cnt.items():
if c % 2 == 1:
odd.append([s, c])
else:
even.append([s, c])
k = max(1, len(odd))
for i in range(k, n + 1):
h = n // i
if i * h == n and (not odd and h % 2 == 0 or odd and h % 2 == 1):
k = i
break
h = n // k
res = []
while len(res) < k:
if odd:
s, c = odd.pop()
res.append(s)
c -= 1
if c:
even.append([s, c])
elif h % 2:
res.append(even[0][0])
res.append(even[0][0])
even[0][1] -= 2
if not even[0][1]:
even.pop(0)
else:
res.append('')
for i in range(k):
s = res[i]
while len(s) < h:
t = (h - len(s)) // 2
a, c = even[0]
if c <= 2 * t:
c //= 2
s = a*c + s + a*c
even.pop(0)
else:
s = a*t + s + a*t
even[0][1] -= 2 * t
res[i] = s
print(len(res))
print(' '.join(res))
```
| 100,020 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
from collections import Counter
n = int(input())
inp = input()
c = Counter(inp)
t = len(list(filter(lambda x: x % 2 == 1, list(c.values()))))
if t == 0:
temp = sum([[list(c.items())[j][0]] * (list(c.items())[j][1] // 2) for j in range(len(c.items()))], [])
print(1)
print(''.join(temp) + ''.join(temp[::-1]))
else:
ones = list()
for j in range(len(c.items())):
i = list(c.items())[j]
if i[1] % 2 == 1:
c[list(c.keys())[j]] -= 1
ones.append(i[0])
others = sum([[list(c.items())[j][0]] * (list(c.items())[j][1] // 2) for j in range(len(c.items()))], [])
while n % t != 0 or n // t % 2 == 0:
t += 2
o = others.pop()
ones.append(o)
ones.append(o)
L = n // t
ans = list()
ot = 0
for i in range(t):
mid = str()
if L % 2 == 1:
mid = ones[i]
ln = L // 2
ans.append(''.join(others[ot: ot + ln]) + mid + ''.join(others[ot: ot + ln][::-1]))
ot += ln
print(t)
print(' '.join(ans))
```
Yes
| 100,021 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
n = int(input())
s = input()
d = {}
for c in s:
if c not in d:
d[c] = 0
d[c] += 1
odd = []
sum = 0
for key in d:
if d[key] % 2 == 1:
odd.append(key)
d[key] -= 1
sum += d[key]
if sum // 2 < len(odd):
print(len(s))
for c in s:
print(c+' ', end='')
exit(0)
while True:
if len(odd) == 0 or (sum // 2) % len(odd) == 0:
break
sum -= 2
if sum // 2 < len(odd):
print(len(s))
for c in s:
print(c + ' ', end='')
exit(0)
for key in d:
odd.append(key)
odd.append(key)
d[key] -= 2
if d[key] == 0:
d.pop(key, None)
break
if len(odd) == 0:
odd.append('')
even = []
for key in d:
even += [key] * (d[key] // 2)
l = (sum // 2) // len(odd)
print(len(odd))
for i in range(len(odd)):
s = odd[i]
for j in range(i * l, (i + 1) * l):
s = even[j] + s + even[j]
print(s + ' ', end='')
```
Yes
| 100,022 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
n = int(input())
string = input()
char = []
charPair = []
charImpair = []
for car in string:
if car not in char:
z = string.count(car)
while z>1:
charPair.append(car)
z-=2
if(z==1):
charImpair.append(car)
char.append(car)
if len(charImpair) ==0 :
String1 = ''
for x in charPair:
String1+= x
if len(charImpair) ==1 :
String1 += charImpair[0]
for x in charPair[::-1]:
String1 += x
print('1')
print(String1)
else :
nbPalin = len(charImpair)
while len(charPair)%nbPalin != 0 :
nbPalin += 2
charImpair.append(charPair[-1])
charImpair.append(charPair[-1])
del(charPair[-1])
lenPalindrome = n/nbPalin
Palin = []
for i in range(nbPalin):
String2 = ''
indice = i * int(((lenPalindrome-1)/2))
for x in charPair[indice : int(indice + ((lenPalindrome-1)/2))]:
String2 += x
String2 += charImpair[i]
for x in range(indice + int(((lenPalindrome-1)/2))-1, indice-1 ,-1): # charPair[i + int(((lenPalindrome-1)/2))-1: i-1 :-1]:
String2 += charPair[x]
Palin.append(String2)
print(nbPalin)
String3 = ' '.join(Palin)
print(String3)
```
Yes
| 100,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
import sys
from collections import Counter
def gen(counter, skip):
for c, n in counter:
has = n // 2
if skip > has:
skip -= has
has = 0
elif skip > 0:
has -= skip
skip = 0
for i in range(has):
yield c
def gen_o(counter, take):
for c, n in counter:
for i in range(n % 2):
yield c
for c, n in counter:
has = (n // 2) * 2
if take > has:
take -= has
elif take > 0:
has = take
take = 0
for i in range(has):
yield c
N = int(next(sys.stdin))
s = next(sys.stdin).strip()
c = Counter(s)
even = 0
odd = 0
items = list(c.items())
for _, n in items:
even += n // 2
odd += n % 2
generator = gen(items, 0)
generator_o = gen_o(items, 0)
odd_c = odd
if odd == 0:
print(1)
front = [next(generator) for i in range(len(s) // 2)]
fs = "".join(front)
print(fs + fs[::-1])
else:
skip = 0
while even != 0 and even % odd != 0:
skip += 1
odd += 2
even -= 1
generator = gen(items, skip)
generator_o = gen_o(items, skip * 2)
print(odd)
per = even // odd
strs = []
for i in range(odd):
front = [next(generator) for i in range(per)]
fs = "".join(front)
strs.append(fs + next(generator_o) + fs[::-1])
print(" ".join(strs))
```
Yes
| 100,024 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
nlet = int(input())
let = [x for x in input()]
uno = [x for x in let if let.count(x)==1]
due = sorted([x for x in let if let.count(x)>1])[::2]
palin = len(uno)
totale = ""
if palin == 0:
totale += "".join(due+due[::-1])
else:
grup = len(due)//palin
j = 0
for i in range(1,palin+1):
f = i*grup
ini = due[j:f]
fin = ini[::-1]
totale += "".join(ini+[uno[i-1]]+fin+[" "])
j = f
print (totale)
```
No
| 100,025 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
n = int(input())
s = list(input())[:n]
d = {}
for char in s:
if char not in d.keys():
d[char] = 1
else:
d[char] += 1
odd = []
even = []
for char in d.keys():
for i in range(d[char] // 2):
even.append(char)
even.append(char)
for i in range(d[char] % 2):
odd.append(char)
if len(odd) <= 1:
x = ''.join([even[i] for i in range(1,len(even),2)])
y = ''.join(odd)
print(1)
print(x+y+x[::-1])
elif (len(even)//len(odd)) % 2 == 0 and (len(even)//len(odd)) > 0:
print(len(odd))
x = []
ratio = len(even)//len(odd)
indx = 0
for i in range(len(odd)):
tail = ''
while len(tail) < ratio//2:
tail += even[indx]
indx += 2
x.append(tail+odd[i]+tail[::-1])
print(' '.join(x))
else:
print(len(even)//2 + len(odd))
print((' '.join(even)+' '+ ' '.join(odd)).strip())
```
No
| 100,026 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
from collections import Counter
import sys
n = int(input())
s = input()
c = Counter(s)
a = []
odd = 0
for i in c:
if c[i] % 2:
odd += 1
a.append(i)
c[i] -= 1
even = n - odd
oddawal = odd
if odd != 0:
while even > 0:
if (even//2) % odd:
even -= 2
odd += 2
else:
break
else:
s = ''
for i in c:
s += i * (c[i]//2)
s += s[::-1]
print(1)
print(s)
sys.exit()
ubah = odd-oddawal
d = {}
for i in c:
if ubah > 0:
if c[i] % 2 == 0:
if ubah >= c[i]:
for _ in range(c[i]):
a.append(i)
ubah -= c[i]
d[i] = 0
else:
for _ in range(c[i]-ubah):
a.append(i)
ubah = 0
d[i] = c[i]-ubah
else:
break
for i in d:
c[i] = d[i]
print(len(a))
s = ''
for i in c:
s += i * (c[i]//2)
su = (len(s)//2)//len(a)
for i in range(len(a)):
a[i] = s[:su+1] + a[i] + s[:su+1][::-1]
s = s[su+1:]
print(*a)
```
No
| 100,027 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Kolya has a string s of length n consisting of lowercase and uppercase Latin letters and digits.
He wants to rearrange the symbols in s and cut it into the minimum number of parts so that each part is a palindrome and all parts have the same lengths. A palindrome is a string which reads the same backward as forward, such as madam or racecar.
Your task is to help Kolya and determine the minimum number of palindromes of equal lengths to cut s into, if it is allowed to rearrange letters in s before cuttings.
Input
The first line contains an integer n (1 β€ n β€ 4Β·105) β the length of string s.
The second line contains a string s of length n consisting of lowercase and uppercase Latin letters and digits.
Output
Print to the first line an integer k β minimum number of palindromes into which you can cut a given string.
Print to the second line k strings β the palindromes themselves. Separate them by a space. You are allowed to print palindromes in arbitrary order. All of them should have the same length.
Examples
Input
6
aabaac
Output
2
aba aca
Input
8
0rTrT022
Output
1
02TrrT20
Input
2
aA
Output
2
a A
Submitted Solution:
```
n = int(input())
s = input()
let = list(set(list(s)))
m = len(let)
cnt = []
for c in let:
cn = [0]
for sc in s:
cn.append(cn[-1] + (sc == c))
cnt.append(cn)
def check(i, j):
c = 0
for p in range(m):
c += (cnt[p][j + 1] - cnt[p][i]) % 2 == 1
return c < 2
def create(i, j):
c = []
mid = None
for p in range(m):
h = cnt[p][j + 1] - cnt[p][i]
if h and h % 2 == 0:
c.append((let[p], h))
if h % 2:
mid = let[p], h
res = []
for l, h in c:
res.extend([l]*(h//2))
if mid:
res.extend([mid[0]]*mid[1])
for l, h in reversed(c):
res.extend([l]*(h//2))
return ''.join(res)
for c in range(1, n + 1):
if n % c == 0:
ch = True
l = n // c
for p in range(c):
ch = ch and check(p * l, (p + 1) * l - 1)
if ch:
res = []
for p in range(c):
res.append(create(p * l, (p + 1) * l - 1))
print(' '.join(res))
break
```
No
| 100,028 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Tags: implementation, strings
Correct Solution:
```
n = int(input())
alpha = [0]*(26)
c = 0
flag = 0
for i in range(n):
a,b = input().split()
if a=='.' :
b = list(set(b))
for i in b:
alpha[ord(i)-97] = -1
elif a=='!':
if alpha.count(max(alpha))==1:
if flag:
c+=1
else:
flag = 1
elif not flag:
b = list(set(b))
for i in b:
if alpha[ord(i)-97] !=-1:
alpha[ord(i)-97] += 1
else:
if flag :
if (ord(b)-97)!=alpha.index(max(alpha)) :
c+=1
else:
alpha[ord(b)-97] = -1
if alpha.count(max(alpha))==1 and not flag:
flag = 1
print(c)
```
| 100,029 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Tags: implementation, strings
Correct Solution:
```
from collections import *
import os, sys
from io import BytesIO, IOBase
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")
BUFSIZE = 8192
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
rstr = lambda: input().strip()
rstrs = lambda: [str(x) for x in input().split()]
rstr_2d = lambda n: [rstr() for _ in range(n)]
rint = lambda: int(input())
rints = lambda: [int(x) for x in input().split()]
rint_2d = lambda n: [rint() for _ in range(n)]
rints_2d = lambda n: [rints() for _ in range(n)]
ceil1 = lambda a, b: (a + b - 1) // b
mem, ans = set('abcdefghijklmnopqrstuvwxyz'), 0
for _ in range(rint() - 1):
ch, word = rstrs()
if ch == '.':
mem -= set(word)
elif ch == '?':
if len(mem) > 1:
mem.discard(word)
elif mem:
ans += 1
else:
if len(mem) == 1:
ans += 1
else:
mem &= set(word)
print(ans)
```
| 100,030 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Tags: implementation, strings
Correct Solution:
```
n = int(input())
d = set()
for i in range(26):
d.add(chr(ord('a')+i))
chocks = 0
done = -1
for i in range(n):
s = input().split()
toR = []
if s[0] == '!':
chocks += 1
for x in d:
if not x in s[1]: toR.append(x)
for x in toR: d.remove(x)
if s[0] == '.':
for x in d:
if x in s[1]: toR.append(x)
for x in toR: d.remove(x)
if s[0] == '?':
if i!=n-1: chocks += 1
if s[1] in d: d.remove(s[1])
if len(d) == 1 and done == -1:
done = chocks
if done == -1:
print(0)
else:
print(chocks-done)
```
| 100,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Tags: implementation, strings
Correct Solution:
```
'''input
5
! abc
. ad
. b
! cd
? c
'''
t = [0] * 26
e = 0
n = int(input())
if n == 1:
print(0)
quit()
for i in range(n-1):
x, y = input().split()
if x == '!':
if 1 in t:
c = [ord(p) - 97 for p in set(y)]
for x in range(26):
if not(t[x] == 1 and x in c):
t[x] = -1
else:
for l in set(y):
if t[ord(l) - 97] == 0:
t[ord(l) - 97] = 1
elif x == '.':
for l in set(y):
t[ord(l) - 97] = -1
else:
t[ord(y) - 97] = -1
if t.count(1) == 1 or (t.count(0) == 1 and max(t) == 0):
break
g = [False] * 26
for _ in range(i+1, n-1):
x, y = input().split()
if x == '!' or x == '?':
e += 1
print(e)
```
| 100,032 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Tags: implementation, strings
Correct Solution:
```
n = int(input())
flag = False
ans = 0
curr = set([chr(x) for x in range(ord('a'), ord('z')+1)])
for i in range(n):
c,s = input().split(' ')
if c[0] == '.':
letters = set(s)
curr = curr - letters
if len(curr) == 1: flag = True
continue
if c[0] == '!':
if flag: ans += 1
else:
letters = set(s)
curr = curr & letters
if len(curr) == 1: flag = True
continue
if c[0] == '?':
guess = s[0]
if flag: ans += 1
else:
curr = curr - set(guess)
if len(curr) == 1: flag = True
if i == n-1 and len(curr) == 1 and guess in curr: ans -= 1
continue
print(ans)
```
| 100,033 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Tags: implementation, strings
Correct Solution:
```
# reading input from stdin
numActions = int(input())
actions = []
for i in range(numActions):
tempStr = input()
if tempStr[0] == '!':
action = 'shock'
elif tempStr[0] == '.':
action = 'none'
else:
action = 'guess'
string = tempStr[2:len(tempStr)]
actions.append([action, string])
# algorithm
shockList = set()
cleanList = set()
numExtraShocks = 0
firstShock = True
for i in range(len(actions)):
action = actions[i][0]
string = actions[i][1]
if action == 'shock':
if len(shockList) == 1 or len(cleanList) == 25:
numExtraShocks += 1
for letter in string:
if firstShock == True:
if letter not in cleanList:
shockList.add(letter)
elif letter not in cleanList and letter not in shockList:
cleanList.add(letter)
if firstShock == True:
firstShock = False
newShockList = shockList.copy()
for i in range(len(list(shockList))):
string1 = list(shockList)[i]
for letter1 in string1:
if letter1 not in string:
newShockList.remove(letter1)
cleanList.add(letter1)
shockList = newShockList.copy()
elif action == 'none':
for letter in string:
if letter in shockList:
shockList.remove(letter)
cleanList.add(letter)
elif action == 'guess':
if (len(shockList) == 1 or len(cleanList) == 25) and i != len(actions) - 1:
numExtraShocks += 1
if i != len(actions) - 1:
if string[0] in shockList:
shockList.remove(string[0])
cleanList.add(string[0])
print(numExtraShocks)
```
| 100,034 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Tags: implementation, strings
Correct Solution:
```
n = int(input())
q = []
for _ in range(n):
q.append(input().split())
s = set('abcdefghijklmnopqrstuvwxyz')
letter = q[-1][-1]
for i in range(n-1):
if q[i][0] == '!':
s &= set(q[i][1])
else:
s -= set(q[i][1])
if len(s) == 1:
cnt = 0
for j in range(i+1, n-1):
if q[j][0] != '.':
cnt += 1
print(cnt)
exit(0)
print(0)
```
| 100,035 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Tags: implementation, strings
Correct Solution:
```
n = int(input())
s = set ('abcdefghijklmnopqrstuvwxyz')
count = 0
for i in range (n):
strg = input().split()
if strg[0] == "?":
if len(s)==1 and i != n - 1:
count += 1
s -= set(strg[1])
if strg[0] == "!":
if len(s)==1:
count += 1
s = s & set(strg[1])
if strg[0] == ".":
s -= set(strg[1])
print (count)
```
| 100,036 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Submitted Solution:
```
n = int(input())
candidates = {'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'}
count = 0
for i in range(n - 1):
action, word = input().split()
if len(candidates) == 1:
if action != '.':
count += 1
else:
if action == '?':
candidates.discard(word)
elif action == '.':
for letter in word:
candidates.discard(letter)
else:
toremove = set()
for letter in candidates:
if letter not in word:
toremove.add(letter)
candidates = candidates.difference(toremove)
print(count)
```
Yes
| 100,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Submitted Solution:
```
n = int(input())
sym = []
word = []
dict = {}
for z in range(26):
dict[chr(97 + z)] = 1
for x in range(n):
a, b = input().split()
sym.append(a)
word.append(b)
q = -1
flag = 0
for x in range(n):
if sym[x] == '!':
flag = 1
sety = set()
for i in range(26):
if (dict[chr(97 + i)] == 0):
sety.add(chr(97 + i))
dict[chr(97 + i)] = 0
for s in word[x]:
dict[s] = 1
for s in sety:
dict[s] = 0
if sym[x] == '.':
for s in word[x]:
dict[s] = 0
if sym[x] == '?':
for s in word[x]:
dict[s] = 0
j = 0
for i in range(26):
j += dict[chr(97 + i)]
if j == 1:
q = x
break
count = 0
if q==-1:
print(0)
else:
for p in range(q+1,n-1):
if sym[p] == '!' or sym[p]=='?':
count+=1
print(count)
```
Yes
| 100,038 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Submitted Solution:
```
from collections import *
import os, sys
from io import BytesIO, IOBase
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")
BUFSIZE = 8192
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
rstr = lambda: input().strip()
rstrs = lambda: [str(x) for x in input().split()]
rstr_2d = lambda n: [rstr() for _ in range(n)]
rint = lambda: int(input())
rints = lambda: [int(x) for x in input().split()]
rint_2d = lambda n: [rint() for _ in range(n)]
rints_2d = lambda n: [rints() for _ in range(n)]
ceil1 = lambda a, b: (a + b - 1) // b
mem, ans = set('abcdefghijklmnopqrstuvwxyz'), 0
for _ in range(rint() - 1):
ch, word = rstrs()
if ch == '.':
mem.difference_update(list(word))
elif ch == '?':
if len(mem) > 1:
mem.discard(word)
elif mem:
ans += 1
else:
if len(mem) == 1:
ans += 1
else:
mem.intersection_update(list(word))
print(ans)
```
Yes
| 100,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Submitted Solution:
```
import math,sys,bisect,heapq
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
#sys.setrecursionlimit(200000000)
int1 = lambda x: int(x) - 1
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda: map(int,input().split())
alele = lambda: list(map(int, input().split()))
ilelec = lambda: map(int1,input().split())
alelec = lambda: list(map(int1, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
#MOD = 1000000000 + 7
def Y(c): print(["NO","YES"][c])
def y(c): print(["no","yes"][c])
def Yy(c): print(["No","Yes"][c])
extra = -1;s = set();mark = {}
for _ in range(int(input())):
a,b = input().split(" ")
if len(s) == 1 or len(mark) == 25:
if a!='.':
extra += 1
continue
if a == '!':
if not(s):
s = set(b)
else:
c = set(b)
l = []
for i in c:
if i in s:
l.append(i)
new_s = set()
#print(l)
for i in s:
if i in l:
new_s.add(i)
else:
mark[i] = 1
s = new_s.copy()
elif a == '.':
c = set(b)
l = []
for i in c:
mark[i] = 1
if i in s:
l.append(i)
new_s = set()
#print(l)
for i in s:
if i not in l:
new_s.add(i)
s = new_s.copy()
else:
mark[b] = 1
t = set()
for i in s:
if mark.get(i,-1) == -1:
t.add(i)
s = t.copy()
#print(s,mark,len(mark))
print(max(0,extra))
```
Yes
| 100,040 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Submitted Solution:
```
# reading input from stdin
numActions = int(input())
actions = []
for i in range(numActions):
tempStr = input()
if tempStr[0] == '!':
action = 'shock'
elif tempStr[0] == '.':
action = 'none'
else:
action = 'guess'
string = tempStr[2:len(tempStr)]
actions.append([action, string])
# algorithm
shockList = set()
cleanList = set()
numExtraShocks = 0
for i in range(len(actions)):
action = actions[i][0]
string = actions[i][1]
if action == 'shock':
if len(shockList) == 1:
numExtraShocks += 1
for letter in string:
if i == 0:
shockList.add(letter)
elif letter not in cleanList and letter not in shockList:
cleanList.add(letter)
newShockList = shockList.copy()
for i in range(len(list(shockList))):
string1 = list(shockList)[i]
for letter1 in string1:
if letter1 not in string:
newShockList.remove(letter1)
cleanList.add(letter1)
shockList = newShockList.copy()
elif action == 'none':
for letter in string:
if letter in shockList:
shockList.remove(letter)
cleanList.add(letter)
elif action == 'guess':
if i != len(actions) - 1:
if string[0] in shockList:
shockList.remove(string[0])
cleanList.add(string[0])
if len(shockList) == 1 and i != len(actions) - 1:
numExtraShocks += 1
print(numExtraShocks)
```
No
| 100,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Submitted Solution:
```
def main():
n = int(input())
yes = set(list(map(chr, range(97, 123))))
no = set()
cnt = 0
for i in range(n):
mark, word = [x for x in input().split()]
tmp_yes = set()
tmp_no = set()
if (mark == '!'):
if (len(yes) == 1):
cnt += 1
for c in word:
tmp_yes.add(c)
yes = yes & tmp_yes
elif (mark == '.'):
for c in word:
tmp_no.add(c)
no = no | tmp_no
elif (mark == '?' and i != n-1):
if (len(yes) == 1):
cnt += 1
tmp_no.add(word)
no = no | tmp_no
for c in (yes & no):
yes.remove(c)
no.add(c)
print(yes)
print(no)
print(cnt)
main()
```
No
| 100,042 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Submitted Solution:
```
from sys import stdin
n = int(stdin.readline().rstrip('\n'))
not_in_ans = set()
in_ans = set()
count = 0
f = False
for i in range(n):
line = stdin.readline().rstrip('\n').split()
if line[0] == chr(46): # .
if len(in_ans) == 0:
not_in_ans |= set(line[1])
else:
in_ans -= set(line[1])
in_ans -= not_in_ans
not_in_ans = set()
if len(in_ans) == 1:
f = True
elif line[0] == chr(33): # !
if f:
count += 1
else:
if len(in_ans) == 0:
in_ans = set(line[1])
if len(in_ans) == 1:
f = True
in_ans &= set(line[1])
elif line[0] == chr(63): # ?
if f and i + 1 != n:
count += 1
else:
if i + 1 != n:
in_ans -= set(line[1])
if len(in_ans) == 1:
f = True
print(count)
```
No
| 100,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Valentin participates in a show called "Shockers". The rules are quite easy: jury selects one letter which Valentin doesn't know. He should make a small speech, but every time he pronounces a word that contains the selected letter, he receives an electric shock. He can make guesses which letter is selected, but for each incorrect guess he receives an electric shock too. The show ends when Valentin guesses the selected letter correctly.
Valentin can't keep in mind everything, so he could guess the selected letter much later than it can be uniquely determined and get excessive electric shocks. Excessive electric shocks are those which Valentin got after the moment the selected letter can be uniquely determined. You should find out the number of excessive electric shocks.
Input
The first line contains a single integer n (1 β€ n β€ 105) β the number of actions Valentin did.
The next n lines contain descriptions of his actions, each line contains description of one action. Each action can be of one of three types:
1. Valentin pronounced some word and didn't get an electric shock. This action is described by the string ". w" (without quotes), in which "." is a dot (ASCII-code 46), and w is the word that Valentin said.
2. Valentin pronounced some word and got an electric shock. This action is described by the string "! w" (without quotes), in which "!" is an exclamation mark (ASCII-code 33), and w is the word that Valentin said.
3. Valentin made a guess about the selected letter. This action is described by the string "? s" (without quotes), in which "?" is a question mark (ASCII-code 63), and s is the guess β a lowercase English letter.
All words consist only of lowercase English letters. The total length of all words does not exceed 105.
It is guaranteed that last action is a guess about the selected letter. Also, it is guaranteed that Valentin didn't make correct guesses about the selected letter before the last action. Moreover, it's guaranteed that if Valentin got an electric shock after pronouncing some word, then it contains the selected letter; and also if Valentin didn't get an electric shock after pronouncing some word, then it does not contain the selected letter.
Output
Output a single integer β the number of electric shocks that Valentin could have avoided if he had told the selected letter just after it became uniquely determined.
Examples
Input
5
! abc
. ad
. b
! cd
? c
Output
1
Input
8
! hello
! codeforces
? c
. o
? d
? h
. l
? e
Output
2
Input
7
! ababahalamaha
? a
? b
? a
? b
? a
? h
Output
0
Note
In the first test case after the first action it becomes clear that the selected letter is one of the following: a, b, c. After the second action we can note that the selected letter is not a. Valentin tells word "b" and doesn't get a shock. After that it is clear that the selected letter is c, but Valentin pronounces the word cd and gets an excessive electric shock.
In the second test case after the first two electric shocks we understand that the selected letter is e or o. Valentin tries some words consisting of these letters and after the second word it's clear that the selected letter is e, but Valentin makes 3 more actions before he makes a correct hypothesis.
In the third example the selected letter can be uniquely determined only when Valentin guesses it, so he didn't get excessive electric shocks.
Submitted Solution:
```
'''input
5
. abcdefghijklmnopqrstuvwxy
? b
? c
? d
? z
'''
t = [0] * 26
n = int(input())
if n == 1:
print(0)
quit()
for i in range(n-1):
x, y = input().split()
if x == '!':
if 1 in t:
c = [ord(p) - 97 for p in set(y)]
for i in range(26):
if t[i] != 1 or i not in c:
t[i] = -1
else:
for l in set(y):
if t[ord(l) - 97] == 0:
t[ord(l) - 97] = 1
elif x == '.':
for l in set(y):
t[ord(l) - 97] = -1
else:
t[ord(y) - 97] = -1
# print(t)
if t.count(1) == 1 or (t.count(0) == 1 and max(t) == 0):
break
e = 0
for _ in range(i+1, n-1):
x, y = input().split()
if x == '!' or x == '?':
e += 1
print(e)
```
No
| 100,044 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
import sys
n,m = [int(x) for x in input().split(' ')]
a=[]
for i in range(n):
b=[]
s = input().strip()
for j in range(m):
if s[j]=='#':
b.append(j)
if b not in a:
a.append(b)
c=[0]*m
ans=True
#print(a)
for i in a:
for j in i:
c[j]+=1
if c[j]>1:
ans=False
break
if ans:
print("Yes")
else:
print("No")
```
| 100,045 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
par = input()
par = list(map(int, par.split()))
n, m = par[0], par[1]
mat = []
for i in range(n):
row = list(input())
mat.append(row)
def posColor(n, m, mt):
for i in range(n):
for j in range(m):
if mt[i][j] == '#':
for x in range(i + 1, n):
if mt[x][j] == '#':
for y in range(m):
if mt[i][y] != mt[x][y]:
return 'No'
return 'Yes'
print(posColor(n, m, mat))
```
| 100,046 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
from collections import defaultdict
r,c=map(int,input().split())
h=defaultdict(list)
flg=[]
for i in range(r):
st=input()
st=str(st)
y=[]
for j in range(c):
if st[j]=='#':
y.append(j)
if y in list(h.values()):
flg.append(1)
# print(1)
else:
for k in y:
for item in list(h.values()):
if k in item:
flg.append(0)
# print(2)
break
h[i]=y
# print(list(h.values()),y)
if 0 in flg:
print('No')
else:
print('Yes')
```
| 100,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
N, M = map(int, input().split())
grid = []
for _ in range(N):
grid.append(input())
S = [set() for _ in range(N)]
for i in range(N):
for j in range(M):
if grid[i][j] == "#":
S[i].add(j)
solved = [False for _ in range(N)]
used = [False for _ in range(M)]
for i in range(N):
if not solved[i]:
for c in S[i]:
if used[c]:
print("No")
quit()
used[c] = True
for j in range(N):
if S[i] == S[j]:
solved[j] = True
print("Yes")
```
| 100,048 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
used =[]
a = []
def dfs(v, c):
vert = v + 100*c
if used[vert] == 0:
used[vert] = 1
a[c].append(v)
for i in range(0, len(g[vert])):
if used[g[vert][i]] == 0:
dfs(g[vert][i] - (1-c)*100, 1-c)
n,m = map(int, input().split())
r = []
for i in range(0,n):
s = input()
r.append(s)
g = []
for i in range (0,200):
g.append([])
used.append(0)
for i in range (0,n):
for j in range (0,m):
if(r[i][j] == "#"):
g[i].append(100 + j)
g[100+j].append(i)
#print(g)
for i in range(0,n):
a = [[],[]]
dfs(i,0)
#print(a)
for j in range (0, len(a[0])):
for k in range (0, len(a[1])):
if(r[a[0][j]][a[1][k]] != "#"):
print ("NO")
raise SystemExit
print("YES")
```
| 100,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
n, m = map(int, input().split())
x = []
for i in range(n):
q = []
y = input()
for j in y:
q.append(j)
x.append(q)
ind = True
for i in range(n):
for j in range(m):
if x[i][j] == "#":
for k in range(i + 1, n):
if x[k][j] == "#" and x[k] != x[i]:
ind = False
break
if ind:
print("Yes")
else:
print("No")
```
| 100,050 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
def partial_match(r1, r2):
n = len(r1)
match_found = False
mismatch_found = False
for i in range(n):
if r1[i] == '#' and r2[i] == '#':
match_found = True
if r1[i] == '#' and r2[i] == '.':
mismatch_found = True
if r2[i] == '#' and r1[i] == '.':
mismatch_found = True
return match_found and mismatch_found
n , m = tuple(map(int, input().split()))
l = []
for i in range(n):
l.append(input().strip())
invalid = False
for i in range(n):
for j in range(n):
if partial_match(l[i], l[j]):
invalid = True
break
if invalid:
print("No")
else:
print("Yes")
```
| 100,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Tags: greedy, implementation
Correct Solution:
```
def func(ss):
occured = set()
for pr, s in zip(['']+ss[:-1], ss):
if pr == s:
continue
for i, el in enumerate(s):
if el == "#":
if i in occured:
return False
occured.add(i)
return True
n, m = [int(x) for x in input().split()]
ss = [input() for _ in range(n)]
ss.sort()
print("Yes" if func(ss) else "No")
```
| 100,052 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
n, m = map(int, input().split())
st = []
for i in range(n):
s = input()
x = set()
for j in range(m):
if s[j] == '#':
x.add(j)
for i in st:
if i & x and i != x:
print('No')
exit()
st.append(x)
print('Yes')
```
Yes
| 100,053 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
n, m = map( int, input().split() )
M = []
for i in range(n):
M.append(input())
Adj = [[] for i in range(n+m)]
for i in range(n):
for j in range(m):
if M[i][j] == '#':
Adj[i].append(n+j)
Adj[n+j].append(i)
p = [-1]*(n+m)
comp = []
answer = 'Yes'
for i in range(n+m):
if p[i] != -1:
continue
L = [i]
comp.append([])
numEdges = 0
numA = 0
numB = 0
while L:
v = L.pop()
comp[-1].append((v, 'A') if v < n else (v-n, 'B'))
if v < n:
numA += 1
else:
numB += 1
for u in Adj[v]:
numEdges += 1
if p[u] == -1 and u != i:
p[u] = v
L.append(u)
#print(comp[-1], numA, numB, numEdges/2)
if numEdges//2 != numA*numB:
answer = 'No'
print(answer)
```
Yes
| 100,054 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
n,m = map(int,input().split())
a = []
f = 0
for i in range(n):a.append(input())
for i in range(n):
for j in range(i+1,n):
r1 = a[i]
r2 = a[j]
f1 = f2 = 0
for k in range(m):
if r1[k] != r2[k]:f1 = 1
if (r1[k] == '#') and (r2[k]=='#'):f2 = 1
if f1 == 1:
if f2 == 1:
f = 1
if f:print('No')
else:print('Yes')
```
Yes
| 100,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
n,m=map(int,input().split())
a=[]
b=[]
for i in range(n):
a.append(input())
s=''
for j in a[i]:
if j=='#':
s+='1'
else:
s+='0'
b.append(s)
for i in range(n):
for j in range(i,n):
if a[i]!=a[j]:
if '2' in str(int(b[i]) + int(b[j])):
print('No')
exit()
print('Yes')
```
Yes
| 100,056 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
def table(n, m, lst):
for i in range(n):
for j in range(n):
if lst[i] != lst[j]:
for k in range(m):
if lst[i][z] == lst[j][z] == "#":
return "No"
return "Yes"
n, m = [int(i) for i in input().split()]
b = list()
for i in range(n):
z = list(input())
b.append(z)
```
No
| 100,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
from collections import defaultdict as dd, deque
r,c = map(int,input().split())
A = [list(input()) for i in range(r)]
At = [[A[i][j] for i in range(r)] for j in range(c)]
R=r
C=c
def find():
for i in range(R):
for j in range(C):
if A[i][j] == "#":
return i,j
return ()
while True:
pos = find()
if pos:
i,j = pos
rows = [i]
cols = [j]
for x in range(c):
if A[i][x] == '#':
cols.append(x)
for x in range(r):
if A[x][j] == '#':
rows.append(x)
fail = False
row = A[rows[0]]
for x in range(1,len(rows)):
if row != A[rows[x]]:
fail = True
col = At[cols[0]]
for x in range(1,len(cols)):
if col != At[cols[x]]:
fail = True
if fail:
print('No')
break
#print('fill')
for r in rows:
for c in cols:
A[r][c] = '.'
At[c][r] = '.'
#print(cols)
#print(rows)
#for a in A:
# print(''.join(a))
#for a in At:
# print(''.join(a))
else:
print('Yes')
break
```
No
| 100,058 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
n, m = map(int, input().split())
array = []
state = True
for i in range(n):
string = input()
if string.find('##')!=-1:
state = False
if state==True:
print('Yes')
else:
print('No')
```
No
| 100,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a rectangular grid of n rows of m initially-white cells each.
Arkady performed a certain number (possibly zero) of operations on it. In the i-th operation, a non-empty subset of rows Ri and a non-empty subset of columns Ci are chosen. For each row r in Ri and each column c in Ci, the intersection of row r and column c is coloured black.
There's another constraint: a row or a column can only be chosen at most once among all operations. In other words, it means that no pair of (i, j) (i < j) exists such that <image> or <image>, where <image> denotes intersection of sets, and <image> denotes the empty set.
You are to determine whether a valid sequence of operations exists that produces a given final grid.
Input
The first line contains two space-separated integers n and m (1 β€ n, m β€ 50) β the number of rows and columns of the grid, respectively.
Each of the following n lines contains a string of m characters, each being either '.' (denoting a white cell) or '#' (denoting a black cell), representing the desired setup.
Output
If the given grid can be achieved by any valid sequence of operations, output "Yes"; otherwise output "No" (both without quotes).
You can print each character in any case (upper or lower).
Examples
Input
5 8
.#.#..#.
.....#..
.#.#..#.
#.#....#
.....#..
Output
Yes
Input
5 5
..#..
..#..
#####
..#..
..#..
Output
No
Input
5 9
........#
#........
..##.#...
.......#.
....#.#.#
Output
No
Note
For the first example, the desired setup can be produced by 3 operations, as is shown below.
<image>
For the second example, the desired setup cannot be produced, since in order to colour the center row, the third row and all columns must be selected in one operation, but after that no column can be selected again, hence it won't be possible to colour the other cells in the center column.
Submitted Solution:
```
n, m = map(int, input().split())
l = [input() for i in range(n)]
flag = True
for i in range(n):
if not flag:
break
for j in range(i + 1, n):
if l[i] != l[j]:
for q in range(m):
if l[j][q] == l[i][q] == '#':
print('NO')
flag = False
break
else:
print('YES')
```
No
| 100,060 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Tags: data structures, greedy, implementation
Correct Solution:
```
n = int(input())
seats = list(map(int, input().split()))
sarr = list(zip(seats, range(1, n+1)))
sarr.sort()
sarr = [i[1] for i in sarr]
ans = []
k = 0
for i in input():
if i == '0':
print(sarr[k], end = " ")
ans.append(sarr[k])
k+=1
if i == '1':
print(ans[-1], end = " ")
ans.pop()
```
| 100,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Tags: data structures, greedy, implementation
Correct Solution:
```
# -*- coding: utf-8 -*-
# Baqir Khan
# Software Engineer (Backend)
from sys import stdin
inp = stdin.readline
n = int(inp())
a = [(int(ele), i + 1) for i, ele in enumerate(inp().split())]
s = inp().strip()
ans = [0] * (2* n)
partially_filled = []
a.sort()
start = 0
for j in range(2*n):
if s[j] == "0":
partially_filled.append(a[start])
ans[j] = a[start][1]
start += 1
else:
ans[j] = partially_filled[-1][1]
partially_filled.pop()
print(*ans)
```
| 100,062 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Tags: data structures, greedy, implementation
Correct Solution:
```
n = int(input())
w = [[-int(x), i + 1] for (i, x) in enumerate(input().split(' '))]
w.sort(key = lambda x : x[0])
m = input()
e = [];
res = [];
for x in m:
if x == '0':
res.append(w[len(w) - 1][1])
e.append(w.pop()[1])
else:
res.append(e.pop());
print(' '.join(map(str, res)))
```
| 100,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Tags: data structures, greedy, implementation
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
a={}
for t in range(n):
a[l[t]]=t+1
c=a.items()
b=sorted(c,reverse=True)
f=[]
p=[]
k=input()
for i in k:
if i=="0":
x=b.pop()
f.append(x)
p.append(x[1])
else:
y=f.pop()
p.append(y[1])
print(*p)
```
| 100,064 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Tags: data structures, greedy, implementation
Correct Solution:
```
n = int(input())
widths = [(int(x), c) for c, x in enumerate(input().split())]
widths.sort()
passengers = input()
seating = ""
stack = []
i = 0
for pi in passengers:
if pi == '1':
seating += str(stack[-1][1]+1) + " "
stack.pop()
else:
stack.append(widths[i])
seating += str(stack[-1][1]+1) + " "
i += 1
print(seating[:-1])
```
| 100,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Tags: data structures, greedy, implementation
Correct Solution:
```
def main():
n = int(input())
w = input().split()
w = sorted([[int(w[i]), i + 1] for i in range(n)])
introindex = 0
result = []
introPlaces = []
for passenger in input():
if passenger == '0':
result.append(str(w[introindex][1]))
introPlaces.append(w[introindex][1])
introindex += 1
else:
result.append(str(introPlaces.pop()))
print(' '.join(result))
if __name__ == "__main__":
main()
```
| 100,066 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Tags: data structures, greedy, implementation
Correct Solution:
```
N = int(input())
Width = [int(x) for x in input().split()]
Input_Order = [int(x) for x in list(input())]
Sorted_Width = sorted(Width)
Data = {Width[x]:x for x in range(0,N)}
A = []
B = []
position = 0
for x in range(0,2*N):
if Input_Order[x]==0:
A.append(Data[Sorted_Width[position]]+1)
B.append(Data[Sorted_Width[position]]+1)
position+=1
else :
A.append(B[-1])
B.pop()
for x in A:
print(x,end =' ')
```
| 100,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Tags: data structures, greedy, implementation
Correct Solution:
```
"""Problem B - Bus of Characters.
http://codeforces.com/contest/982/problem/B
In the Bus of Characters there are `n` rows of seat, each having `2` seats.
The width of both seats in the `i`-th row is `w_i` centimeters. All integers
`w_i` are distinct.
Initially the bus is empty. On each of `2n` stops one passenger enters the
bus. There are two types of passengers:
- an introvert always chooses a row where both seats are empty. Among these
rows he chooses the one with the smallest seats width and takes one of the
seats in it;
- an extrovert always chooses a row where exactly one seat is occupied (by an
introvert). Among these rows he chooses the one with the largest seats width
and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter
the bus. Determine which row each passenger will take.
Input:
The first line contains a single integer `n` (`1 <= n <= 200000`) β the
number of rows in the bus.
The second line contains the sequence of integers `w_1, w_2, ..., w_n` (`1 <=
w_i <= 10^{9}`), where `w_i` is the width of each of the seats in the `i`-th
row. It is guaranteed that all `w_i` are distinct.
The third line contains a string of length `2n`, consisting of digits '0' and
'1' β the description of the order the passengers enter the bus. If the `j`-th
character is '0', then the passenger that enters the bus on the `j`-th stop is
an introvert. If the `j`-th character is '1', the the passenger that enters the
bus on the `j`-th stop is an extrovert. It is guaranteed that the number of
extroverts equals the number of introverts (i. e. both numbers equal `n`), and
for each extrovert there always is a suitable row.
Output:
Print `2n` integers β the rows the passengers will take. The order of
passengers should be the same as in input.
"""
def solve(w, s):
empty = sorted(enumerate(w), key=lambda x: x[1], reverse=True)
non_empty = []
result = []
for p in s:
if p == '0':
row = empty.pop()
non_empty.append(row)
else:
row = non_empty.pop()
result.append(row[0] + 1)
return result
def main():
_ = input()
w = [int(x) for x in input().strip().split()]
s = input().strip()
result = solve(w, s)
print(' '.join(map(str, result)))
if __name__ == '__main__':
main()
```
| 100,068 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Submitted Solution:
```
n = int(input())
width = [(int(w), i) for i, w in enumerate(input().split(" "))]
order = input()
width = sorted(width, key=lambda x: x[0])
no_passengers = [w[1] for w in width]
one_passenger = []
i = 0
for person in order:
if person == "0":
print(no_passengers[i] + 1, end=" ")
one_passenger.append(no_passengers[i])
i += 1
else:
print(one_passenger.pop() + 1, end=" ")
```
Yes
| 100,069 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Submitted Solution:
```
def main():
n = int(input())
w = input().split()
w = sorted([(int(w[i]), i + 1) for i in range(n)])
introindex = 0
result = []
introPlaces = []
for passenger in input():
if passenger == '0':
result.append(str(w[introindex][1]))
introPlaces.append(w[introindex][1])
introindex += 1
else:
result.append(str(introPlaces.pop()))
print(' '.join(result))
if __name__ == "__main__":
main()
```
Yes
| 100,070 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Submitted Solution:
```
class heap:
def __init__(self, maxn):
self.a = [0] * maxn
self.size = 0
def shift_down(self, i):
while 2 * i + 1 < self.size:
l = 2 * i + 1
r = 2 * i + 2
j = l
if r < self.size and self.a[r] < self.a[l]:
j = r
if self.a[i] <= self.a[j]:
break
self.a[i], self.a[j] = self.a[j], self.a[i]
i = j
def shift_up(self, i):
while i and self.a[i] < self.a[(i - 1) // 2]:
self.a[i], self.a[(i - 1) // 2] = self.a[(i - 1) // 2], self.a[i]
i = (i - 1) // 2
def erase_min(self):
mn = self.a[0]
self.a[0] = self.a[self.size - 1]
self.size -= 1
self.shift_down(0)
return mn
def insert(self, val):
self.size += 1
self.a[self.size - 1] = val
self.shift_up(self.size - 1)
n = int(input())
ar = [int(j) for j in input().split()]
s0 = heap(400000 + 100)
s1 = heap(400000 + 100)
for i in range(n):
s0.insert((ar[i], i + 1))
for c in input():
if c == '0':
v = s0.erase_min()
print(v[1], end=' ')
s1.insert((-v[0], v[1]))
else:
print(s1.erase_min()[1], end=' ')
```
Yes
| 100,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Submitted Solution:
```
import heapq
row = int(input())
width = [int(x) for x in input().split()]
Introvert = []
Extrovert = []
for i in range(row):
heapq.heappush(Introvert,(width[i],i+1))
sequence = input()
Ans = []
for i in sequence:
if(i=="0"): #Introvert
x,y = heapq.heappop(Introvert)
heapq.heappush(Extrovert,(-x,y))
Ans.append(y)
else:
x,y = heapq.heappop(Extrovert)
Ans.append(y)
print(*Ans)
```
Yes
| 100,072 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Submitted Solution:
```
n = int(input().strip())
temp = input().strip().split()
w = []
for j in range(len(temp)):
w.append([int(temp[j]),j])
w.sort()
#print(w)
passenger = input().strip()
biggest_intro = []
smallest_index = 0
for i in range(2*n):
if passenger[i] == '0':
#introvert
#smallest_empty = w[smallest_index][1] #actual index
print(w[smallest_index][1]+1, end='')
biggest_intro.append(smallest_index) #non-actual index, bigger width at the end
smallest_index+=1
elif passenger[i] == '1':
b = biggest_intro.pop()
print(w[b][1]+1,end='')
#print(biggest_intro)
```
No
| 100,073 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Submitted Solution:
```
import queue
n=int(input())
l=list(map(int,input().split()))
a={}
for t in range(n):
a[l[t]]=t+1
c=a.items()
b=sorted(c)
L=queue.Queue(maxsize=n)
for u in b:
L.put(u)
f=[]
p=[]
k=input()
for i in k:
if i=="0":
x=L.get()
f.append(x)
p.append(x[1])
else:
y=f.pop()
p.append(x[1])
print(*p)
```
No
| 100,074 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Submitted Solution:
```
n = int(input())
temp = list(zip([int(x) for x in input().split()], range(1, n+1)))
temp.sort(key=lambda x: x[0])
type1 = [int(x) for x in list(input())]
a = []
ans = []
for i in type1:
if i == 0:
ans.append(temp[0][1])
a.append(temp[0])
del temp[0]
else:
ans.append(a[-1][1])
# temp = [a[-1]] + temp
del a[-1]
print(ans)
```
No
| 100,075 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the Bus of Characters there are n rows of seat, each having 2 seats. The width of both seats in the i-th row is w_i centimeters. All integers w_i are distinct.
Initially the bus is empty. On each of 2n stops one passenger enters the bus. There are two types of passengers:
* an introvert always chooses a row where both seats are empty. Among these rows he chooses the one with the smallest seats width and takes one of the seats in it;
* an extrovert always chooses a row where exactly one seat is occupied (by an introvert). Among these rows he chooses the one with the largest seats width and takes the vacant place in it.
You are given the seats width in each row and the order the passengers enter the bus. Determine which row each passenger will take.
Input
The first line contains a single integer n (1 β€ n β€ 200 000) β the number of rows in the bus.
The second line contains the sequence of integers w_1, w_2, ..., w_n (1 β€ w_i β€ 10^{9}), where w_i is the width of each of the seats in the i-th row. It is guaranteed that all w_i are distinct.
The third line contains a string of length 2n, consisting of digits '0' and '1' β the description of the order the passengers enter the bus. If the j-th character is '0', then the passenger that enters the bus on the j-th stop is an introvert. If the j-th character is '1', the the passenger that enters the bus on the j-th stop is an extrovert. It is guaranteed that the number of extroverts equals the number of introverts (i. e. both numbers equal n), and for each extrovert there always is a suitable row.
Output
Print 2n integers β the rows the passengers will take. The order of passengers should be the same as in input.
Examples
Input
2
3 1
0011
Output
2 1 1 2
Input
6
10 8 9 11 13 5
010010011101
Output
6 6 2 3 3 1 4 4 1 2 5 5
Note
In the first example the first passenger (introvert) chooses the row 2, because it has the seats with smallest width. The second passenger (introvert) chooses the row 1, because it is the only empty row now. The third passenger (extrovert) chooses the row 1, because it has exactly one occupied seat and the seat width is the largest among such rows. The fourth passenger (extrovert) chooses the row 2, because it is the only row with an empty place.
Submitted Solution:
```
import heapq
n=int(input())
get=lambda:map(int,input().split())
w=list(get())
s=input()
intro=[(i,e) for e,i in enumerate(w)]
exto=[]
heapq.heapify(w)
for i in s:
if i=='0':
e,i=heapq.heappop(intro)
heapq.heappush(exto,(-e,i))
print(i+1,end=' ')
else:
e,i=heapq.heappop(exto)
print(i+1,end=' ')
```
No
| 100,076 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
"Correct Solution:
```
class BIT():
__slots__ = ["n", "data"]
def __init__(self, length_or_list):
if isinstance(length_or_list, int):
self.n = length_or_list + 1
self.data = [0] * self.n
else:
self.n = len(length_or_list) + 1
self.data = [0] + length_or_list
for i in range(1, self.n):
if i + (i & -i) < self.n:
self.data[i + (i & -i)] += self.data[i]
def point_append(self, index, delta):
index += 1
while index < self.n:
self.data[index] += delta
index += index & -index
def prefix_folded(self, end):
res = 0
while end > 0:
res += self.data[end]
end -= end & -end
return res
def folded(self, begin, end):
ret = 0
while begin < end:
ret += self.data[end]
end -= end & -end
while end < begin:
ret -= self.data[begin]
begin -= begin & -begin
return ret
def main():
import sys
input = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
N, Q = map(int, input().split())
seg = BIT(list(map(int, input().split())))
for _ in range(Q):
a, b, c = map(int, input().split())
if a:
print(seg.folded(b, c))
else:
seg.point_append(b, c)
if __name__ == "__main__":
main()
```
| 100,077 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
"Correct Solution:
```
class BIT:
def __init__(self, n):
self.n = n
self.bit = [0]*(self.n+1) # 1-indexed
def init(self, init_val):
for i, v in enumerate(init_val):
self.add(i, v)
def add(self, i, x):
# i: 0-indexed
i += 1 # to 1-indexed
while i <= self.n:
self.bit[i] += x
i += (i & -i)
def sum(self, i, j):
# return sum of [i, j)
# i, j: 0-indexed
return self._sum(j) - self._sum(i)
def _sum(self, i):
# return sum of [0, i)
# i: 0-indexed
res = 0
while i > 0:
res += self.bit[i]
i -= i & (-i)
return res
def lower_bound(self, x):
s = 0
pos = 0
depth = self.n.bit_length()
v = 1 << depth
for i in range(depth, -1, -1):
k = pos + v
if k <= self.n and s + self.bit[k] < x:
s += self.bit[k]
pos += v
v >>= 1
return pos
n, q = map(int, input().split())
A = list(map(int, input().split()))
bit = BIT(n)
bit.init(A)
for _ in range(q):
i, j, k = map(int, input().split())
if i == 0:
bit.add(j, k)
else:
print(bit.sum(j, k))
```
| 100,078 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
"Correct Solution:
```
import sys
class Bit:
def __init__(self, n, arr):
self.size = n
self.tree = [0] + arr
for i in range(1, n+1):
x = i + (i & -i)
if x < n + 1:
self.tree[x] += self.tree[i]
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def range_sum(self, l, r):
return self.sum(r) - self.sum(l)
def main():
n, q = map(int, sys.stdin.buffer.readline().split())
bit = Bit(n, list(map(int, sys.stdin.buffer.readline().split())))
for x in sys.stdin.buffer.readlines():
q, p, x = map(int, x.split())
if q:
print(bit.range_sum(p, x))
else:
bit.add(p+1, x)
if __name__ == "__main__":
main()
```
| 100,079 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
"Correct Solution:
```
import sys
input = lambda: sys.stdin.readline()
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.n:
self.data[i] += x
i += i & -i
n, m = map(int, input().split())
c = list(map(int, input().split()))
b = BIT(n)
for i in range(n):
b.add(i + 1, c[i])
res = []
for i in range(m):
t, x, y = map(int, input().split())
if t == 1:
res.append(b.sum(y) - b.sum(x))
else:
b.add(x + 1, y)
print("\n".join(map(str, res)))
```
| 100,080 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
"Correct Solution:
```
import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
def segfunc(x, y):
return x + y
def init(init_val):
for i in range(n):
seg[i + num - 1] = init_val[i]
for i in range(num - 2, -1, -1):
seg[i] = segfunc(seg[2 * i + 1], seg[2 * i + 2])
def update(k, x):
k += num - 1
seg[k] = x
while k:
k = (k - 1) // 2
seg[k] = segfunc(seg[k * 2 + 1], seg[k * 2 + 2])
def query(p, q):
if q <= p:
return ide_ele
p += num - 1
q += num - 2
res = ide_ele
while q - p > 1:
if p & 1 == 0:
res = segfunc(res, seg[p])
if q & 1 == 1:
res = segfunc(res, seg[q])
q -= 1
p = p // 2
q = (q - 1) // 2
if p == q:
res = segfunc(res, seg[p])
else:
res = segfunc(segfunc(res, seg[p]), seg[q])
return res
N, Q = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
# seg treeεζε€ (εδ½ε
)
n = N
ide_ele = 0
num = 2 ** (n - 1).bit_length()
seg = [ide_ele] * 2 * num
init(A)
for _ in range(Q):
q, p, x = [int(x) for x in input().split()]
if q == 0:
A[p] += x
update(p, A[p])
else:
print(query(p, x))
if __name__ == '__main__':
main()
```
| 100,081 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
"Correct Solution:
```
def main():
def f(i,x):
while i<=n:
b[i]+=x
i+=i&-i
def g(i):
s=0
while i:
s+=b[i]
i-=i&-i
return s
(n,q,*w),a,*t=[map(int,t.split())for t in open(0)]
b=[0]*-~n
*map(f,range(1,n+1),a),
for q,l,r in t:
if q:w+=g(r)-g(l),
else:f(l+1,r)
print(' '.join(map(str,w)))
main()
```
| 100,082 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
"Correct Solution:
```
class fenwick_tree():
def __init__(self, n:int):
self.__n = n
self.__data = [0] * self.__n
def add(self, p:int, x:int):
assert (0 <= p) & (p < self.__n)
p+=1
while( p<= self.__n):
self.__data[p-1] += x
p += p & -p
def sum(self, l:int, r:int):
assert (0 <= l) & (l <= r) & (r <= self.__n)
return self.__sum_mod0(r) - self.__sum_mod0(l)
def __sum_mod0(self, r:int):
s = 0
while(r > 0):
s += self.__data[r-1]
r -= r & -r
return s
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n,q = map(int,readline().split())
a = list(map(int,readline().split()))
query = list(map(int,read().split()))
ft = fenwick_tree(n)
ans = []
for i,ai in enumerate(a):
ft.add(i,ai)
i = 0
for _ in range(q):
if(query[i]==0):
p,x = query[i+1:i+3]
ft.add(p,x)
else:
l,r = query[i+1:i+3]
ans.append(ft.sum(l,r))
i += 3
print('\n'.join(map(str,ans)))
```
| 100,083 |
Provide a correct Python 3 solution for this coding contest problem.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
"Correct Solution:
```
n, q = map(int, input().split())
BIT = [0] * (n + 1)
def add(i, x):
while i <= n:
BIT[i] += x
i += i & -i
def query(i):
s = 0
while i > 0:
s += BIT[i]
i -= i & -i
return s
a = list(map(int, input().split()))
for i in range(n):
add(i + 1, a[i])
for i in range(q):
x, y, z = map(int, input().split())
if x == 0:
add(y + 1, z)
else:
print(query(z) - query(y))
```
| 100,084 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
Submitted Solution:
```
import sys
input = sys.stdin.buffer.readline
class FenwickTree:
"""FenwickTree (Binary Indexed Tree, 0-index)
Queries:
1. add(i, val): add val to i-th value
2. sum(n): sum(bit[0] + ... + bit[n-1])
complexity: O(log n)
See: http://hos.ac/slides/20140319_bit.pdf
"""
def __init__(self, a_list):
self.N = len(a_list)
self.bit = a_list[:]
for _ in range(self.N, 1 << (self.N - 1).bit_length()):
self.bit.append(0)
for i in range(self.N-1):
self.bit[i | (i+1)] += self.bit[i]
def add(self, i, val):
while i < self.N:
self.bit[i] += val
i |= i + 1
def sum(self, n):
ret = 0
while n >= 0:
ret += self.bit[n]
n = (n & (n + 1)) - 1
return ret
def query(self, low, high):
return self.sum(high) - self.sum(low)
def yosupo():
# https://judge.yosupo.jp/problem/point_add_range_sum
_, Q = map(int, input().split())
fwt = FenwickTree([int(x) for x in input().split()])
ans = []
for _ in range(Q):
type_, l, r = map(int, input().split())
if type_ == 0:
fwt.add(l, r)
else:
ans.append(fwt.query(l-1, r-1))
print(*ans, sep="\n")
def aoj():
# https://onlinejudge.u-aizu.ac.jp/courses/library/3/DSL/2/DSL_2_B
N, Q = map(int, input().split())
fwt = FenwickTree([0] * N)
for _ in range(Q):
type_, l, r = map(int, input().split())
if type_ == 0:
fwt.add(l-1, r)
else:
print(fwt.query(l-2, r-1))
if __name__ == "__main__":
yosupo()
# aoj()
```
Yes
| 100,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
Submitted Solution:
```
import sys
class Fenwick_Tree:
def __init__(self, n):
self._n = n
self.data = [0] * n
def add(self, p, x):
assert 0 <= p < self._n
p += 1
while p <= self._n:
self.data[p - 1] += x
p += p & -p
def sum(self, l, r):
assert 0 <= l <= r <= self._n
return self._sum(r) - self._sum(l)
def _sum(self, r):
s = 0
while r > 0:
s += self.data[r - 1]
r -= r & -r
return s
def main():
input = sys.stdin.readline
n, q = map(int, input().split())
fw = Fenwick_Tree(n)
for i, a in enumerate(map(int, input().split())): fw.add(i, a)
for _ in range(q):
t, a, b = map(int, input().split())
if t == 0:
fw.add(a, b)
else:
print(fw.sum(a, b))
if __name__ == "__main__":
main()
```
Yes
| 100,086 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
Submitted Solution:
```
class SegmentTree:
def __init__(self, a):
self.padding = 0
self.n = len(a)
self.N = 2 ** (self.n-1).bit_length()
self.seg_data = [self.padding]*(self.N-1) + a + [self.padding]*(self.N-self.n)
for i in range(2*self.N-2, 0, -2):
self.seg_data[(i-1)//2] = self.seg_data[i] + self.seg_data[i-1]
def __len__(self):
return self.n
def update(self, i, x):
idx = self.N - 1 + i
self.seg_data[idx] += x
while idx:
idx = (idx-1) // 2
self.seg_data[idx] = self.seg_data[2*idx+1] + self.seg_data[2*idx+2]
def query(self, i, j):
# [i, j)
if i == j:
return self.seg_data[self.N - 1 + i]
else:
idx1 = self.N - 1 + i
idx2 = self.N - 2 + j # ιεΊιγ«γγ
result = self.padding
while idx1 < idx2 + 1:
if idx1&1 == 0: # idx1γεΆζ°
result = result + self.seg_data[idx1]
if idx2&1 == 1: # idx2γε₯ζ°
result = result + self.seg_data[idx2]
idx2 -= 1
idx1 //= 2
idx2 = (idx2 - 1)//2
return result
@property
def data(self):
return self.seg_data[self.N-1:self.N-1+self.n]
N, Q = map(int, input().split())
A = list(map(int, input().split()))
st = SegmentTree(A)
ans = []
for _ in range(Q):
t, i, j = map(int, input().split())
if t:
ans.append(st.query(i, j))
else:
st.update(i, j)
print(*ans, sep='\n')
```
Yes
| 100,087 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
Submitted Solution:
```
class BinaryIndexedTree:
# a[i] = [0] * n
def __init__(self, n):
self.size = n
self.data = [0] * (n+1)
# return sum(a[0:i])
def cumulative_sum(self, i):
ans = 0
while i > 0:
ans += self.data[i]
i -= i & -i
return ans
# a[i] += x
def add(self, i, x):
i += 1
while i <= self.size:
self.data[i] += x
i += i & -i
def main():
from sys import stdin
input = stdin.buffer.readline
n, q = map(int, input().split())
a = list(map(int, input().split()))
bit = BinaryIndexedTree(n)
for i, ai in enumerate(a):
bit.add(i, ai)
ans = []
for _ in range(q):
typ, i, j = map(int, input().split())
if typ == 0:
bit.add(i, j)
else:
ans.append(bit.cumulative_sum(j) - bit.cumulative_sum(i))
for i in ans:
print(i)
main()
```
Yes
| 100,088 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
Submitted Solution:
```
n, q = list(map(lambda x: int(x), input().split()))
list_a = list(map(lambda x: int(x), input().split()))
# element of ith index is the sum of subarray: list_a[:i+1]
current_sum = 0
sum_list_a = []
for ele in list_a:
# print(ele, current_sum)
current_sum += ele
sum_list_a.append(current_sum)
for _ in range(q):
i, x, y = list(map(lambda x: int(x), input().split()))
if i == 0:
for i in range(x, len(x)):
sum_list_a[i] += y
continue
if (x == 0):
print(sum_list_a[y-1])
continue
print(sum_list_a[y-1] - sum_list_a[x-1])
```
No
| 100,089 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
Submitted Solution:
```
import sys
class Bit:
def __init__(self, n):
self.size = n
self.tree = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
def main():
n, q = map(int, sys.stdin.buffer.readline().split())
bit = Bit(n+1)
a = list(map(int, sys.stdin.buffer.readline().split()))
for i in range(n):
bit.add(i+1, a[i])
for x in sys.stdin.buffer.readlines():
q, p, x = map(int, x.split())
if q:
print(bit.sum(x) - bit.sum(p))
else:
bit.add(p, x)
if __name__ == "__main__":
main()
```
No
| 100,090 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
Submitted Solution:
```
class binaryindexedtree():
def __init__(self,n):
self.n=n
self.tree=[0]*n
def add(self,a,w):
x=a
while x<=self.n:
self.tree[x-1]+=w
x+=x&(-x)
def sums(self,a):
x=a
S=0
while x!=0:
S+=self.tree[x-1]
x-=x&(-x)
return S
n,q=map(int,input().split())
a=list(map(int,input().split()))
bit=binaryindexedtree(n)
for i,x in enumerate(a,1):
bit.add(i,x)
ans=[]
for _ in range(q):
x,y,z=map(int,input().split())
if x:ans+=[bit.sums(z)-bit.sums(y)]
else:bit.add(y,z)
print(*ans,sep='\n')
```
No
| 100,091 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given an array a_0, a_1, ..., a_{N-1} of length N. Process Q queries of the following types.
* `0 p x`: a_p \gets a_p + x
* `1 l r`: Print \sum_{i = l}^{r - 1}{a_i}.
Constraints
* 1 \leq N, Q \leq 500,000
* 0 \leq a_i, x \leq 10^9
* 0 \leq p < N
* 0 \leq l_i < r_i \leq N
* All values in Input are integer.
Input
Input is given from Standard Input in the following format:
N Q
a_0 a_1 ... a_{N - 1}
\textrm{Query}_0
\textrm{Query}_1
:
\textrm{Query}_{Q - 1}
Output
For each query of the latter type, print the answer.
Example
Input
5 5
1 2 3 4 5
1 0 5
1 2 4
0 3 10
1 0 5
1 0 3
Output
15
7
25
6
Submitted Solution:
```
class FenwickTree():
def __init__(self, n):
self.n = n
self.data = [0] * n
def build(self, arr):
#assert len(arr) <= n
for i, a in enumerate(arr):
self.data[i] = a
for i in range(1, self.n + 1):
if i + (i & -i) < self.n:
self.data[i + (i & -i) - 1] += self.data[i - 1]
def add(self, p, x):
#assert 0 <= p < self.n
p += 1
while p <= self.n:
self.data[p - 1] += x
p += p & -p
def sum(self, r):
s = 0
while r:
s += self.data[r - 1]
r -= r & -r
return s
def range_sum(self, l, r):
#assert 0 <= l <= r <= self.n
return self.sum(r) - self.sum(l)
import sys
input = sys.stdin.buffer.readline
N, Q = map(int, input().split())
A = tuple(map(int, input().split()))
ft = FenwickTree(N)
ft.build(A)
res = []
for _ in range(Q):
q, x, y = map(int, input().split())
if q:
res.append(str(ft.range_sum(x, y)))
else:
ft.add(x, y)
print('\n'.join(res))
```
No
| 100,092 |
Provide a correct Python 3 solution for this coding contest problem.
Give a pair of integers (A, B) such that A^5-B^5 = X. It is guaranteed that there exists such a pair for the given integer X.
Constraints
* 1 \leq X \leq 10^9
* X is an integer.
* There exists a pair of integers (A, B) satisfying the condition in Problem Statement.
Input
Input is given from Standard Input in the following format:
X
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Examples
Input
33
Output
2 -1
Input
1
Output
0 -1
"Correct Solution:
```
x=int(input())
for i in range(120):
for j in range(-62,i):
if i**5-j**5==x:print(i,j);exit()
```
| 100,093 |
Provide a correct Python 3 solution for this coding contest problem.
Give a pair of integers (A, B) such that A^5-B^5 = X. It is guaranteed that there exists such a pair for the given integer X.
Constraints
* 1 \leq X \leq 10^9
* X is an integer.
* There exists a pair of integers (A, B) satisfying the condition in Problem Statement.
Input
Input is given from Standard Input in the following format:
X
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Examples
Input
33
Output
2 -1
Input
1
Output
0 -1
"Correct Solution:
```
x=int(input())
for a in range(201):
for b in range(-200,201):
if a**5-b**5==x:
print(a,b)
exit()
```
| 100,094 |
Provide a correct Python 3 solution for this coding contest problem.
Give a pair of integers (A, B) such that A^5-B^5 = X. It is guaranteed that there exists such a pair for the given integer X.
Constraints
* 1 \leq X \leq 10^9
* X is an integer.
* There exists a pair of integers (A, B) satisfying the condition in Problem Statement.
Input
Input is given from Standard Input in the following format:
X
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Examples
Input
33
Output
2 -1
Input
1
Output
0 -1
"Correct Solution:
```
A= int(input())
for i in range(-119,119):
for j in range(-119,119):
if i**5-j**5 == A:
print(i,j)
exit()
```
| 100,095 |
Provide a correct Python 3 solution for this coding contest problem.
Give a pair of integers (A, B) such that A^5-B^5 = X. It is guaranteed that there exists such a pair for the given integer X.
Constraints
* 1 \leq X \leq 10^9
* X is an integer.
* There exists a pair of integers (A, B) satisfying the condition in Problem Statement.
Input
Input is given from Standard Input in the following format:
X
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Examples
Input
33
Output
2 -1
Input
1
Output
0 -1
"Correct Solution:
```
x=int(input())
for a in range(120):
for b in range(-120,a):
if a**5 - b**5 == x:
print(a,b)
exit()
```
| 100,096 |
Provide a correct Python 3 solution for this coding contest problem.
Give a pair of integers (A, B) such that A^5-B^5 = X. It is guaranteed that there exists such a pair for the given integer X.
Constraints
* 1 \leq X \leq 10^9
* X is an integer.
* There exists a pair of integers (A, B) satisfying the condition in Problem Statement.
Input
Input is given from Standard Input in the following format:
X
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Examples
Input
33
Output
2 -1
Input
1
Output
0 -1
"Correct Solution:
```
x=int(input())
for i in range(-400,400):
for j in range(-400,400):
if i**5-j**5==x:
print(i,j)
exit()
```
| 100,097 |
Provide a correct Python 3 solution for this coding contest problem.
Give a pair of integers (A, B) such that A^5-B^5 = X. It is guaranteed that there exists such a pair for the given integer X.
Constraints
* 1 \leq X \leq 10^9
* X is an integer.
* There exists a pair of integers (A, B) satisfying the condition in Problem Statement.
Input
Input is given from Standard Input in the following format:
X
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Examples
Input
33
Output
2 -1
Input
1
Output
0 -1
"Correct Solution:
```
x=int(input())
for i in range(120):
for j in range(-54,i):
if i**5-j**5==x:print(i,j);exit()
```
| 100,098 |
Provide a correct Python 3 solution for this coding contest problem.
Give a pair of integers (A, B) such that A^5-B^5 = X. It is guaranteed that there exists such a pair for the given integer X.
Constraints
* 1 \leq X \leq 10^9
* X is an integer.
* There exists a pair of integers (A, B) satisfying the condition in Problem Statement.
Input
Input is given from Standard Input in the following format:
X
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Output
Print A and B, with space in between. If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.
A B
Examples
Input
33
Output
2 -1
Input
1
Output
0 -1
"Correct Solution:
```
x = int(input())
for i in range(238):
a = i-118
for j in range(238):
b = j-119
if a**5-b**5==x:
print(a, b)
exit()
```
| 100,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.