text stringlengths 198 433k | conversation_id int64 0 109k |
|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Tags: data structures, sortings
Correct Solution:
```
#!/usr/bin/env python3
from __future__ import division, print_function
import collections
def least_significant_bit(i):
return ((i) & -(i))
class FenwickTree():
def __init__(self, n):
# 1-indexed
self.n = n + 1
self.data = [0,] * self.n
def add(self, index, value):
# 1-indexed
i = index + 1
while i < self.n:
self.data[i] += value
i += least_significant_bit(i)
def prefix_sum(self, index):
# 1-indexed
i = index + 1
result = 0
while i > 0:
result += self.data[i]
i -= least_significant_bit(i)
return result
def range_sum(self, start, end):
return self.prefix_sum(end) - self.prefix_sum(start-1)
def main():
import sys
data = iter(map(int, sys.stdin.buffer.read().decode('ascii').split()))
n = next(data)
left = [0,] * n
right = [0,] * n
for i in range(n):
a, b = next(data), next(data)
left[i] = a
right[i] = b
order = list(range(n))
order.sort(key=lambda x: left[x])
for i, k in enumerate(order):
left[k] = i
order = list(range(n))
order.sort(key=lambda x:right[x])
res = [0, ] * n
ft = FenwickTree(n)
for i, k in enumerate(order):
a = left[k]
res[k] = i - ft.prefix_sum(a-1)
ft.add(a, 1)
sys.stdout.buffer.write('\n'.join(str(x) for x in res).encode('ascii'))
return 0
if __name__ == '__main__':
main()
```
| 8,000 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Submitted Solution:
```
#!/usr/bin/env python3
from __future__ import division, print_function
def least_significant_bit(i):
return ((i) & -(i))
class FenwickTree():
def __init__(self, n):
# 1-indexed
self.n = n + 1
self.data = [0,] * self.n
def add(self, index, value):
# 1-indexed
i = index + 1
while i < self.n:
self.data[i] += value
i += least_significant_bit(i)
def prefix_sum(self, index):
# 1-indexed
i = index + 1
result = 0
while i > 0:
result += self.data[i]
i -= least_significant_bit(i)
return result
def range_sum(self, start, end):
return self.prefix_sum(end) - self.prefix_sum(start-1)
def main():
import sys
data = iter(map(int, sys.stdin.buffer.read().decode('ascii').split()))
n = next(data)
left = [0,] * n
right = [0,] * n
for i in range(n):
a, b = next(data), next(data)
left[i] = a
right[i] = b
order = list(range(n))
order.sort(key=lambda x: left[x])
for i, k in enumerate(order):
left[k] = i
order = list(range(n))
order.sort(key=lambda x:right[x])
res = [0, ] * n
ft = FenwickTree(n)
for i, k in enumerate(order):
a = left[k]
res[k] = i - ft.prefix_sum(a-1)
ft.add(a, 1)
sys.stdout.buffer.write(b'\n'.join(b'%d' % x for x in res))
return 0
if __name__ == '__main__':
main()
```
Yes
| 8,001 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Submitted Solution:
```
from sys import stdin
input=stdin.readline
class BIT():
def __init__(self, n):
self.n = n
self.tree = [0] * (n + 1)
def sum(self, i):
ans = 0
i += 1
while i > 0:
ans += self.tree[i]
i -= (i & (-i))
return ans
def update(self, i, value):
i += 1
while i <= self.n:
self.tree[i] += value
i += (i & (-i))
def common():
n = int(input())
left=[0]*(n)
right=[0]*(n)
for i in range(n):
a, b = map(int, input().strip().split())
left[i]=a
right[i]=b
order=list(range(n))
order=sorted(order,key=lambda s:left[s])
for i in range(n):
left[order[i]]=i #chota pehle
order = list(range(n))
order = sorted(order, key=lambda s: right[s])
ft=BIT(n)
res=[0]*(n)
for i,k in enumerate(order):
a=left[k]
res[k]=i-ft.sum(a-1) #kitne bade lodu isse chote the - kitne chotu lodu
ft.update(a,1)
print(*res,sep="\n")
common()
```
Yes
| 8,002 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Submitted Solution:
```
import sys
input=sys.stdin.buffer.readline
n=int(input())
l={}
r={}
ref=[]
for i in range(n):
x,y=map(int,input().split())
ref.append(x)
l[x]=y
li=list(l.values())
li.sort()
for i in range(n):
r[li[i]]=i
ke=list(l.keys())
ke.sort()
ar=[1]*(n+1)
for idx in range(1,n+1):
idx2=idx+(idx&(-idx))
if(idx2<n+1):
ar[idx2]+=ar[idx]
ansdic={}
for i in range(n):
inp=r[l[ke[i]]]+1
ans=0
while(inp):
ans+=ar[inp]
inp-=(inp&(-inp))
ansdic[ke[i]]=ans-1
inp=r[l[ke[i]]]+1
add=-1
while(inp<n+1):
ar[inp]+=add
inp+=(inp&(-inp))
for i in ref:
print(ansdic[i])
```
Yes
| 8,003 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Submitted Solution:
```
from collections import defaultdict,Counter
from sys import stdin
input=stdin.readline
class BIT():
def __init__(self, n):
self.n = n
self.tree = [0] * (n + 1)
def sum(self, i):
ans = 0
i += 1
while i > 0:
ans += self.tree[i]
i -= (i & (-i))
return ans
def update(self, i, value):
i += 1
while i <= self.n:
self.tree[i] += value
i += (i & (-i))
def score(t):
cnt=Counter(t)
return list(cnt.values()).count(2)
def year():
dct = defaultdict(list)
n = int(input())
left=[0]*(n)
right=[0]*(n)
for i in range(n):
a, b = map(int, input().strip().split())
left[i]=a
right[i]=b
order=list(range(n))
order=sorted(order,key=lambda s:left[s])
for i in range(n):
left[order[i]]=i
order = list(range(n))
order = sorted(order, key=lambda s: right[s])
ft=BIT(n)
res=[0]*(n)
for i,k in enumerate(order):
a=left[k]
res[k]=i-ft.sum(a-1)
ft.update(a,1)
print(*res,sep="\n")
year()
```
Yes
| 8,004 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Submitted Solution:
```
n = int(input())
xs = []
for i in range(n):
a, b = [int(x) for x in input().split()]
xs.append((a, 0, i))
xs.append((b, 1, i))
xs = sorted(xs)
s = []
ans = [0] * n
for p, end, idx in xs:
if end:
count, pidx = s[-1]
if pidx == idx:
ans[idx] = count
s.pop()
if s:
s[-1][0] += count + 1
else:
for nidx in range(len(s), 0, -1):
if s[nidx - 1][1] == idx:
break
ans[idx] = count
s.pop(nidx - 1)
else:
s.append([0, idx])
for count, idx in s:
ans[idx] = count
for x in ans:
print(x)
```
No
| 8,005 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Submitted Solution:
```
def includes(n, lines):
lines.sort()
l_ind = {l: n-1-i for i, l in enumerate(lines)}
lines.sort(key=lambda x: x[::-1])
return {l: min(i, l_ind[l]) for i, l in enumerate(lines)}
n = int(input())
lines = [tuple(map(lambda x: int(x), input().split())) for i in range(n)]
answer = includes(n, lines[:])
for l in lines:
print(answer[l])
```
No
| 8,006 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Submitted Solution:
```
import logging
import copy
import sys
logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
#def solve(firstLine):
def solve(firstLine, inputLines):
sortedLine = sorted(inputLines, key=lambda line: line[0])
cntList = [0] * len(inputLines)
cntDict = {}
for i in range(1, len(sortedLine)):
p = sortedLine[i]
for j in range(len(sortedLine)):
if i == j :
continue
if p[1] < sortedLine[j][0] :
break
# if sortedLine[j][1] < p[1]:
# break
if sortedLine[j][1] > p[1]:
key = ' '.join(str(e) for e in sortedLine[j])
if key in cntDict:
cntDict[key] += 1
else:
cntDict[key] = 1
log(cntDict)
for line in inputLines:
key = ' '.join(str(e) for e in line)
if key in cntDict:
print(cntDict[key])
else:
print(0)
return
def main():
firstLine = input().split()
firstLine = list(map(int, firstLine))
inputLines = []
for i in range(firstLine[0]):
line = input().split()
line = list(map(int, line))
inputLines.append(line)
#solve(firstLine)
solve(firstLine, inputLines)
def log(*message):
logging.debug(message)
if __name__ == "__main__":
main()
```
No
| 8,007 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given n segments on a line. There are no ends of some segments that coincide. For each segment find the number of segments it contains.
Input
The first line contains a single integer n (1 β€ n β€ 2Β·105) β the number of segments on a line.
Each of the next n lines contains two integers li and ri ( - 109 β€ li < ri β€ 109) β the coordinates of the left and the right ends of the i-th segment. It is guaranteed that there are no ends of some segments that coincide.
Output
Print n lines. The j-th of them should contain the only integer aj β the number of segments contained in the j-th segment.
Examples
Input
4
1 8
2 3
4 7
5 6
Output
3
0
1
0
Input
3
3 4
1 5
2 6
Output
0
1
1
Submitted Solution:
```
import bisect as bs
import itertools as it
import sys
def includes(lines):
count = {}
from_left = sorted(lines)
from_right = sorted(lines, key=lambda x: x[1])
for i, line in enumerate(from_right):
count[line] = len(set(from_right[:i]) & set(from_left[bs.bisect(from_left, line):]))
# j = bs.bisect_left(from_left, line)
# count[line] = (i - j) if i - j > 0 else 0
return count
n = int(input())
if n > 10000:
_INPUT_LINES = sys.stdin.read()
print("START!!!")
lines = [] # [tuple(map(int, input().split())) for i in range(n)]
for line in it.islice(sys.stdin, n):
lines.append(tuple(map(int, line.split())))
answer = includes(lines[:])
for l in lines:
print(answer[l])
```
No
| 8,008 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Tags: implementation
Correct Solution:
```
def is_leap(y):
a = y % 400 == 0
b = y % 4 == 0 and not y % 100 == 0
return a or b
year = int(input())
l = is_leap(year)
w = 1
u = w
y = year
while True:
y += 1
incr = int(is_leap(y - 1))
u = (u + 1 + incr) % 7
if u == w and l == is_leap(y):
print(y)
break
```
| 8,009 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Tags: implementation
Correct Solution:
```
def main():
def leap(y):
return y % 100 and not y % 4 or not y % 400
n = int(input())
a = leap(n)
b, x = not a, 0
while a != b or x % 7:
n += 1
b = leap(n)
x += 365 + b
print(n)
if __name__ == '__main__':
main()
```
| 8,010 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Tags: implementation
Correct Solution:
```
def f(n):
if (n % 400 == 0):
return 2
elif n % 100 != 0 and n % 4 == 0:
return 2
return 1
n = int(input())
x = n
c = f(n)
n += 1
while c % 7 != 0 or f(n) != f(x):
c += f(n)
n += 1
#print(n, f(n), c)
print(n)
```
| 8,011 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Tags: implementation
Correct Solution:
```
y=int(input())
b=0
y0=y
while b or y==y0 or (y0%400==0 or y0%4==0 and y0%100) and not(y%400==0 or y%4==0 and y%100) or not(y0%400==0 or y0%4==0 and y0%100) and (y%400==0 or y%4==0 and y%100):
b+=365%7
if y%400==0 or y%4==0 and y%100:
b+=1
y+=1
b%=7
print(y)
```
| 8,012 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Tags: implementation
Correct Solution:
```
def leapyear(y):
return y%400==0 or (y%4==0 and y%100!=0)
a = int(input())
t = int(leapyear(a))
s = int(leapyear(a+1))
d = s+1
y=a+1
while(d%7!=0 or s!=t):
y+=1
s = int(leapyear(y))
d+=s+1
print(y)
```
| 8,013 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Tags: implementation
Correct Solution:
```
def isleap(y):
return y % 400 == 0 or (y % 4 == 0 and y % 100 != 0)
y = int(input())
days = 366 if isleap(y) else 365
nextSameYear = y+1
while True:
if days % 7 == 0 and isleap(nextSameYear) == isleap(y):
break
days += 366 if isleap(nextSameYear) else 365
nextSameYear+=1
print(nextSameYear)
```
| 8,014 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Tags: implementation
Correct Solution:
```
n = int(input())
count = 0
flag = True
if (n % 4 == 0 and n % 100 != 0) or n % 400 == 0 :
flag = False
while True:
n += 1
if n % 400 == 0:
count += 2
elif n % 4 == 0 and n % 100 != 0:
count += 2
else:
count += 1
#print(count)
if count % 7 == 0:
if flag == False and ((n % 4 == 0 and n % 100 != 0) or n % 400 == 0):
print(n)
break
elif flag == True and ((n % 4 != 0 or n % 100 == 0) and n % 400 != 0):
print(n)
break
else:
continue
```
| 8,015 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Tags: implementation
Correct Solution:
```
def is_leap(year):
return year % 400 == 0 or (year % 4 == 0 and year % 100 != 0)
def year_days(year):
return 365 + int(is_leap(year))
y = int(input().strip())
offset = 0
res = y
while 1:
if offset and offset % 7 == 0 and is_leap(y) == is_leap(res):
break
offset += year_days(res) % 7
res += 1
print(res)
```
| 8,016 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Submitted Solution:
```
import sys
y = int(input())
leap = 1 if y % 400 == 0 or y % 4 == 0 and y % 100 else 0
y += 1
m = (366 if leap else 365) % 7
while 1:
l = 1 if y % 400 == 0 or y % 4 == 0 and y % 100 else 0
if m == 0 and leap == l:
print(y)
exit()
m = (m + (366 if l else 365)) % 7
y += 1
```
Yes
| 8,017 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Submitted Solution:
```
import datetime
def tot_days(year):
if year % 400 == 0: return 366
if year % 100 == 0: return 365
if year % 4 == 0: return 366
return 365
year = int(input())
first_day = 0
tot = tot_days(year)
days = first_day
cyear = year
while True:
days = (days + tot_days(cyear)) % 7
cyear += 1
if first_day == days and tot == tot_days(cyear):
print(cyear)
break
```
Yes
| 8,018 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Submitted Solution:
```
def iswis(a):
return a % 400 == 0 or (a%100!= 0 and a %4==0)
n = int(input())
wis = iswis(n)
fr = 0;
n += 1
if (wis):
fr += 1
fr += 1
while (iswis(n) != wis or fr != 0):
if (iswis(n)):
fr += 1
fr += 1
fr %= 7
n += 1
print(n)
```
Yes
| 8,019 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Submitted Solution:
```
def isleap(n):
if n%4==0:
if n%100==0:
if n%400==0:
return True
return False
return True
return False
n=int(input())
a=0
for i in range(n+1,n+10000000):
if isleap(i):
a+=2
else:
a+=1
a=a%7
if a==0:
if isleap(n):
if isleap(i):
print(i)
break
else:
if isleap(i):
continue
else:
print(i)
break
```
Yes
| 8,020 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Submitted Solution:
```
def isleap(y):
return y % 400 == 0 or (y % 4 == 0 and y % 100 != 0)
y = int(input())
if isleap(y):
print(y + 28)
elif isleap(y+1):
print(y + 5)
elif isleap(y + 2):
print(y + 11)
else:
print(y + 6)
```
No
| 8,021 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Submitted Solution:
```
import bisect
from itertools import accumulate
import os
import sys
import math
from decimal import *
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input(): return sys.stdin.readline().rstrip("\r\n")
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
def SieveOfEratosthenes(n):
prime=[]
primes = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (primes[p] == True):
prime.append(p)
for i in range(p * p, n+1, p):
primes[i] = False
p += 1
return prime
def primefactors(n):
fac=[]
while(n%2==0):
fac.append(2)
n=n//2
for i in range(3,int(math.sqrt(n))+2):
while(n%i==0):
fac.append(i)
n=n//i
if n>1:
fac.append(n)
return fac
def factors(n):
fac=set()
fac.add(1)
fac.add(n)
for i in range(2,int(math.sqrt(n))+1):
if n%i==0:
fac.add(i)
fac.add(n//i)
return list(fac)
#------------------------------------------------------code by AD18
n=int(input())
if n%4==0 and n%100!=0:
print(n+28)
else:
print(n+n%6+n%100)
```
No
| 8,022 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Submitted Solution:
```
y=int(input())
b=0
y0=y
while b%7 or y==y0 or (y0%400==0 or y0%4==0 and y0%100) and not(y%400==0 or y%4==0 and y%100):
b+=1
if y%400==0 or y%4==0 and y%100:
b+=1
y+=1
print(y)
```
No
| 8,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The girl Taylor has a beautiful calendar for the year y. In the calendar all days are given with their days of week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
The calendar is so beautiful that she wants to know what is the next year after y when the calendar will be exactly the same. Help Taylor to find that year.
Note that leap years has 366 days. The year is leap if it is divisible by 400 or it is divisible by 4, but not by 100 (<https://en.wikipedia.org/wiki/Leap_year>).
Input
The only line contains integer y (1000 β€ y < 100'000) β the year of the calendar.
Output
Print the only integer y' β the next year after y when the calendar will be the same. Note that you should find the first year after y with the same calendar.
Examples
Input
2016
Output
2044
Input
2000
Output
2028
Input
50501
Output
50507
Note
Today is Monday, the 13th of June, 2016.
Submitted Solution:
```
def is_leap_year(n):
return (n % 4 == 0 or n % 400 == 0) or (n % 4 == 0 and n % 100 != 0)
def solve(n):
if not is_leap_year(n):
i, ans = n, 0
while ans != 7:
i += 1
ans += 1 if not is_leap_year(i) else 2
return i
i, ans = n + 1, 0
while True:
ans += 1 if not is_leap_year(i) else 2
if ans % 7 == 0 and is_leap_year(i):
return i
i += 1
n = int(input())
print(solve(n))
```
No
| 8,024 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
from collections import defaultdict
def put(): return map(int, input().split())
def dfs():
s = [(1,0)]
ans = 0
vis = [0]*(n+1)
while s:
i,p = s.pop()
if vis[i]==0:
vis[i]=1
s.append((i,p))
for j in tree[i]:
if j!=p:
s.append((j,i))
elif vis[i]==1:
vis[i]=2
for j in tree[i]:
if j != p:
mark[i]+= mark[j]
ans += min(mark[i], 2*k - mark[i])
print(ans)
n,k = put()
l = list(put())
edge = defaultdict()
tree = [[] for i in range(n+1)]
mark = [0]*(n+1)
for i in l:
mark[i]=1
for _ in range(n-1):
x,y = put()
tree[x].append(y)
tree[y].append(x)
dfs()
```
| 8,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
def bfs(source):
q = [0] * (n + 1);
fa = [-1] * n
l, r = [1] * 2
fa[source] = source
q[1] = source
while l <= r:
x = q[l]
l += 1
for y in e[x]:
if fa[y] == -1:
fa[y] = x
r += 1
q[r] = y
i = r;
while i >= 1:
x = q[i]
for y in e[x]:
if fa[y] == x:
sum[x] += sum[y]
dp[x] += dp[y] + min(sum[y], m - sum[y])
i -= 1
n, m =[int(x) for x in input().split()]
m <<= 1
t = [int(x) for x in input().split()]
e = [list() for i in range(n)]
sum = [0] * n
dp = [0] * n
#print(len(e), e)
for i in range(n - 1):
x, y = [int(a) for a in input().split()]
e[x - 1].append(y - 1)
e[y - 1].append(x - 1)
for x in t:
sum[x - 1] = 1
bfs(0)
print(dp[0])
```
| 8,026 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
n, k = map(int, input().split())
s = [0] * n
for i in map(int, input().split()):
s[i - 1] = 1
e = [[] for _ in range(n)]
for _ in range(n - 1):
x, y = (int(s) - 1 for s in input().split())
e[x].append(y)
e[y].append(x)
q, fa = [0], [-1] * n
fa[0] = 0
for i in range(n):
x = q[i]
for y in e[x]:
if fa[y] == -1:
fa[y] = x
q.append(y)
dp, k2 = [0] * n, k * 2
for x in reversed(q):
for y in e[x]:
if fa[y] == x:
i = s[y]
s[x] += i
dp[x] += dp[y] + (k2 - i if i > k else i)
print(dp[0])
```
| 8,027 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
WHITE = 0
GRAY = 1
BLACK = 2
def dfs_iter(G,u=0):
stack = []
stack.append({"u":u,"v":0,"started": False})
while len(stack) != 0 :
current = stack[len(stack)-1]
u = current["u"]
v_index = current["v"]
started = current["started"]
if started:
##despues de que se llama recursivo:
s_v[u]+=s_v[G[u][v_index]] #osea a s_v[u] le suma el valor de su vertice adyacente que se calculo despues de la recursividad#
##
current["v"] += 1
current["started"] = False
continue
if v_index == len(G[u]):
stack.pop()
color[u] = BLACK
continue
color[u] =GRAY
v=G[u][v_index]
## to do:
if color[v] == WHITE:
s = {"u":v, "v":0, "started":False}
current["started"] = True
stack.append(s)
continue
###
current["v"]+=1
def dfs_calc_s(G,u = 0):
color[u] = GRAY
s_v[u] = 1 if uni[u] else 0
for v in G[u]:
if color[v] == WHITE:
dfs_calc_s(G,v)
s_v[u] += s_v[v]
def solution(G, k):
sol = 0
for v in range(len(G)):
sol += min(s_v[v], 2*k - s_v[v])
return sol
def main():
s = input().split(" ")
n = int(s[0])
k = int(s[1])
global uni, color, s_v
uni = [False for i in range(n)]
color = [0] * n
s_v = [0] * n
s = input().split(" ")
for v in s:
a = int(v)-1
uni[a] = True
s_v[a] = 1
G = [[] for _ in range(n)]
for _ in range(n-1):
s = input().split(" ")
a = int(s[0])-1
b = int(s[1])-1
G[a].append(b)
G[b].append(a)
dfs_iter(G)
print(solution(G,k))
try:
main()
except Exception as e:
print(str(e).replace(" ","_"))
```
| 8,028 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
def parser():
return [int(x) for x in input().split(" ")]
def DFS():
visited[0]=True
stack=[]
intruduction_order=[]
stack.append(0)
while len(stack)>0:
v=stack.pop()
for u in adjacents_list[v]:
if not visited[u]:
pi[u]=v
visited[u]=True
if university_in_city[u]:
count_universities_subtree[u]+=1
stack.append(u)
intruduction_order.append(u)
for v in intruduction_order[::-1]:
count_universities_subtree[pi[v]]+=count_universities_subtree[v]
n,k=parser()
visited=[False for x in range(n)]
pi=[0 for x in range(n)]
count_universities_subtree=[0 for x in range(n)]
university_in_city=[False for x in range(n)]
cities_universities=parser()
for i in range(2*k):
university_in_city[cities_universities[i]-1]=True
adjacents_list=[[] for x in range(n)]
for i in range(n-1):
edge=parser()
adjacents_list[edge[0]-1].append(edge[1]-1)
adjacents_list[edge[1]-1].append(edge[0]-1)
DFS()
total=0
for i in range(1,n):
total+=min(count_universities_subtree[i],2*k-count_universities_subtree[i])
print(total)
```
| 8,029 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
#parsea una lΓnea
def parser():
return [int(x) for x in input().split()]
#MΓ©todo usado para contar las universidades en cada subΓ‘rbol
def DFS():
visited[0]=True
stack=[]
introduction_order=[]
stack.append(0)
while len(stack)>0:
v=stack.pop()
for u in adjacents_list[v]:
if not visited[u]:
pi[u]=v
visited[u]=True
if university_in_city[u]:
count_universities_subtree[u]+=1
stack.append(u)
introduction_order.append(u)
#Recorriendo para saber la cantidad de universidades que hay en el subarbol de cada vertice
for v in introduction_order[::-1]:
count_universities_subtree[pi[v]]+=count_universities_subtree[v]
#Recibiendo los valores de n y k
n,k=parser()
#visitados
visited=[False for x in range(n)]
#padres
pi=[0 for x in range(n)]
#universidades en el subarbol
count_universities_subtree=[0 for x in range(n)]
#universidad en la ciudad
university_in_city=[False for x in range(n)]
#Recibiendo las ciudades que tienen universidades
cities_universities=parser()
for i in cities_universities:
university_in_city[i-1]=True
#Armando el Γ‘rbol que representa a Treeland
adjacents_list=[[] for x in range(n)]
for i in range(n-1):
#Leyendo una arista
edge=parser()
adjacents_list[edge[0]-1].append(edge[1]-1)
adjacents_list[edge[1]-1].append(edge[0]-1)
DFS()
#Calculando el total
total=0
for i in range(1,n):
total+=min(count_universities_subtree[i],2*k-count_universities_subtree[i])
#Imprimiendo el resultado
print(total)
```
| 8,030 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
def main():
n, k = map(int, input().split())
s = [0] * n
for i in map(int, input().split()):
s[i - 1] = 1
e = [[] for _ in range(n)]
for _ in range(n - 1):
x, y = (int(s) - 1 for s in input().split())
e[x].append(y)
e[y].append(x)
q, fa = [0], [-1] * n
fa[0] = 0
for i in range(n):
x = q[i]
for y in e[x]:
if fa[y] == -1:
fa[y] = x
q.append(y)
dp, k2 = [0] * n, k * 2
for x in reversed(q):
for y in e[x]:
if fa[y] == x:
i = s[y]
s[x] += i
dp[x] += dp[y] + (k2 - i if i > k else i)
print(dp[0])
if __name__ == "__main__":
main()
```
| 8,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Tags: dfs and similar, dp, graphs, trees
Correct Solution:
```
from collections import defaultdict
from sys import stdin
def put(): return map(int, stdin.readline().split())
def dfs():
s = [(1,0)]
ans = 0
vis = [0]*(n+1)
while s:
i,p = s.pop()
if vis[i]==0:
vis[i]=1
s.append((i,p))
for j in tree[i]:
if j!=p:
s.append((j,i))
elif vis[i]==1:
vis[i]=2
for j in tree[i]:
if j != p:
mark[i]+= mark[j]
ans += min(mark[i], 2*k - mark[i])
print(ans)
n,k = put()
l = list(put())
edge = defaultdict()
tree = [[] for i in range(n+1)]
mark = [0]*(n+1)
for i in l:
mark[i]=1
for _ in range(n-1):
x,y = put()
tree[x].append(y)
tree[y].append(x)
dfs()
```
| 8,032 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Submitted Solution:
```
# [https://codeforces.com/contest/700/submission/19421380]
(n, k) = map(int, input().split())
s = [0] * n
for i in map(int, input().split()):
s[i - 1] = 1
e = [[] for _ in range(n)]
for _ in range(n - 1):
(x, y) = (int(s) - 1 for s in input().split())
e[x].append(y)
e[y].append(x)
q = [0]
fa = [-1] * n
fa[0] = 0
for i in range(n):
x = q[i]
for y in e[x]:
if fa[y] == -1:
fa[y] = x
q.append(y)
dp = [0] * n
k2 = k * 2
for x in reversed(q):
for y in e[x]:
if fa[y] == x:
i = s[y]
s[x] += i
dp[x] += dp[y] + (k2 - i if i > k else i)
print(dp[0])
```
Yes
| 8,033 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Submitted Solution:
```
def bfs(source):
q = [0] * (n + 1);
fa = [-1] * n
l, r = [1] * 2
fa[source] = source
q[1] = source
while l <= r:
x = q[l]
l += 1
for y in e[x]:
if fa[y] == -1:
fa[y] = x
r += 1
q[r] = y
i = r;
while i >= 1:
x = q[i]
for y in e[x]:
if fa[y] == x:
sum[x] += sum[y]
dp[x] += dp[y] + min(sum[y], m - sum[y])
i -= 1
n, m =[int(x) for x in input().split()]
m <<= 1
t = [int(x) for x in input().split()]
e = [list() for i in range(n)]
sum = [0] * n
dp = [0] * n
#print(len(e), e)
for i in range(n - 1):
x, y = [int(a) for a in input().split()]
e[x - 1].append(y - 1)
e[y - 1].append(x - 1)
for x in t:
sum[x - 1] = 1
bfs(0)
print(dp[0])
# Made By Mostafa_Khaled
```
Yes
| 8,034 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Submitted Solution:
```
a = input()
if a[0] == '7':
print(6)
else:
print(9)
```
No
| 8,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Submitted Solution:
```
a = input()
if a[0] == 7:
print(6)
else:
print(9)
```
No
| 8,036 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Submitted Solution:
```
n, k = [int(x) for x in input().split(' ')]
arr = list(map(int, input().split(' ')))
pairs = []
for i in range(k):
pairs.append([arr[i], arr[i+k]])
linked_list = {}
for i in range(n-1):
a, b = [int(x) for x in input().split(' ')]
if a not in linked_list:
linked_list[a] = [b]
else:
linked_list[a].append(b)
if b not in linked_list:
linked_list[b] = [a]
else:
linked_list[b].append(a)
visited = set()
def dfs(i, j):
global visited
if i == j:
return 0
if i in visited:
return -1
visited.add(i)
for k in linked_list[i]:
ans = dfs(k, j)
if ans != -1:
return ans+1
return -1
tot = 0
for i in pairs:
tot += dfs(*i)
visited = set()
print(tot)
```
No
| 8,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Treeland is a country in which there are n towns connected by n - 1 two-way road such that it's possible to get from any town to any other town.
In Treeland there are 2k universities which are located in different towns.
Recently, the president signed the decree to connect universities by high-speed network.The Ministry of Education understood the decree in its own way and decided that it was enough to connect each university with another one by using a cable. Formally, the decree will be done!
To have the maximum sum in the budget, the Ministry decided to divide universities into pairs so that the total length of the required cable will be maximum. In other words, the total distance between universities in k pairs should be as large as possible.
Help the Ministry to find the maximum total distance. Of course, each university should be present in only one pair. Consider that all roads have the same length which is equal to 1.
Input
The first line of the input contains two integers n and k (2 β€ n β€ 200 000, 1 β€ k β€ n / 2) β the number of towns in Treeland and the number of university pairs. Consider that towns are numbered from 1 to n.
The second line contains 2k distinct integers u1, u2, ..., u2k (1 β€ ui β€ n) β indices of towns in which universities are located.
The next n - 1 line contains the description of roads. Each line contains the pair of integers xj and yj (1 β€ xj, yj β€ n), which means that the j-th road connects towns xj and yj. All of them are two-way roads. You can move from any town to any other using only these roads.
Output
Print the maximum possible sum of distances in the division of universities into k pairs.
Examples
Input
7 2
1 5 6 2
1 3
3 2
4 5
3 7
4 3
4 6
Output
6
Input
9 3
3 2 1 6 5 9
8 9
3 2
2 7
3 4
7 6
4 5
2 1
2 8
Output
9
Note
The figure below shows one of possible division into pairs in the first test. If you connect universities number 1 and 6 (marked in red) and universities number 2 and 5 (marked in blue) by using the cable, the total distance will equal 6 which will be the maximum sum in this example.
<image>
Submitted Solution:
```
import sys
sys.setrecursionlimit(10**9)
epicdebug = 0
tree = []
tin = []
tout = []
p = []
h = []
used = []
timer = 1
def dfs(v, par):
global timer
used[v] = True
tin[v] = timer;
h[v] = h[par] + 1
timer += 1
p[v][0] = par
for i in range(1, 18):
p[v][i] = p[p[v][i - 1]][i - 1]
for i in range(len(tree[v])):
to = tree[v][i];
if not used[to]:
dfs(to, v)
tout[v] = timer;
timer += 1
def isAncestor(u, v):
if tin[u] <= tin[v] and tout[u] >= tout[v]: return True
return False
def getLCA(u, v):
if isAncestor(u, v): return u
if isAncestor(v, u): return v
for i in range(17, -1, -1):
if not isAncestor(p[u][i], v):
u = p[u][i]
return p[u][0]
def pathLen(u, v):
return h[u] + h[v] - 2 * h[getLCA(u, v)]
try:
n, k = map(int, input().split())
if n == 200000 and k == 100000:
epicdebug = 1
tree = [[] for i in range(n)]
tin = [0] * n
tout = [0] * n
h = [0] * n
used = [False] * n
p = [[0] * 18 for i in range(n)]
k *= 2
good = list(map(int, input().split()))
for i in range(len(good)):
good[i] -= 1
for i in range(n - 1):
u, v = map(int, input().split())
u -= 1
v -= 1
tree[u].append(v)
tree[v].append(u)
if epicdebug:
exit(0)
dfs(0, 0)
if epicdebug:
exit(0)
for i in range(len(good)):
good[i] = (tin[good[i]], good[i])
good.sort()
res = 0
j = len(good) // 2
for i in range(len(good) // 2):
res += pathLen(good[i][1], good[j][1])
j += 1
print(res)
except Exception as e:
print(str(e))
```
No
| 8,038 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a set Y of n distinct positive integers y1, y2, ..., yn.
Set X of n distinct positive integers x1, x2, ..., xn is said to generate set Y if one can transform X to Y by applying some number of the following two operation to integers in X:
1. Take any integer xi and multiply it by two, i.e. replace xi with 2Β·xi.
2. Take any integer xi, multiply it by two and add one, i.e. replace xi with 2Β·xi + 1.
Note that integers in X are not required to be distinct after each operation.
Two sets of distinct integers X and Y are equal if they are equal as sets. In other words, if we write elements of the sets in the array in the increasing order, these arrays would be equal.
Note, that any set of integers (or its permutation) generates itself.
You are given a set Y and have to find a set X that generates Y and the maximum element of X is mininum possible.
Input
The first line of the input contains a single integer n (1 β€ n β€ 50 000) β the number of elements in Y.
The second line contains n integers y1, ..., yn (1 β€ yi β€ 109), that are guaranteed to be distinct.
Output
Print n integers β set of distinct integers that generate Y and the maximum element of which is minimum possible. If there are several such sets, print any of them.
Examples
Input
5
1 2 3 4 5
Output
4 5 2 3 1
Input
6
15 14 3 13 1 12
Output
12 13 14 7 3 1
Input
6
9 7 13 17 5 11
Output
4 5 2 6 3 1
Tags: binary search, data structures, dfs and similar, greedy, strings, trees
Correct Solution:
```
from collections import defaultdict
import heapq
pow=[1]
for i in range(30):
pow.append(pow[-1]*2)
n=int(input())
b=list(map(int,input().split()))
d=defaultdict(lambda:0)
for j in b:
d[j]=1
for j in range(n):
b[j]=-b[j]
heapq.heapify(b)
ans=[]
f=1
while(f):
j= -heapq.heappop(b)
can=0
for i in range(31):
curr=(j-(j%pow[i]))//pow[i]
if curr<1:
break
if d[curr]==0:
heapq.heappush(b,-curr)
d[curr]=1
can=1
break
if not can:
heapq.heappush(b,-j)
break
for j in range(n):
b[j]=-b[j]
print(*b)
```
| 8,039 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a set Y of n distinct positive integers y1, y2, ..., yn.
Set X of n distinct positive integers x1, x2, ..., xn is said to generate set Y if one can transform X to Y by applying some number of the following two operation to integers in X:
1. Take any integer xi and multiply it by two, i.e. replace xi with 2Β·xi.
2. Take any integer xi, multiply it by two and add one, i.e. replace xi with 2Β·xi + 1.
Note that integers in X are not required to be distinct after each operation.
Two sets of distinct integers X and Y are equal if they are equal as sets. In other words, if we write elements of the sets in the array in the increasing order, these arrays would be equal.
Note, that any set of integers (or its permutation) generates itself.
You are given a set Y and have to find a set X that generates Y and the maximum element of X is mininum possible.
Input
The first line of the input contains a single integer n (1 β€ n β€ 50 000) β the number of elements in Y.
The second line contains n integers y1, ..., yn (1 β€ yi β€ 109), that are guaranteed to be distinct.
Output
Print n integers β set of distinct integers that generate Y and the maximum element of which is minimum possible. If there are several such sets, print any of them.
Examples
Input
5
1 2 3 4 5
Output
4 5 2 3 1
Input
6
15 14 3 13 1 12
Output
12 13 14 7 3 1
Input
6
9 7 13 17 5 11
Output
4 5 2 6 3 1
Tags: binary search, data structures, dfs and similar, greedy, strings, trees
Correct Solution:
```
def main():
from heapq import heapify, heapreplace
input()
s = set(map(int, input().split()))
xx = [-x for x in s]
heapify(xx)
while True:
x = -xx[0]
while x != 1:
x //= 2
if x not in s:
s.add(x)
heapreplace(xx, -x)
break
else:
break
print(' '.join(str(-x) for x in xx))
if __name__ == '__main__':
main()
```
| 8,040 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a set Y of n distinct positive integers y1, y2, ..., yn.
Set X of n distinct positive integers x1, x2, ..., xn is said to generate set Y if one can transform X to Y by applying some number of the following two operation to integers in X:
1. Take any integer xi and multiply it by two, i.e. replace xi with 2Β·xi.
2. Take any integer xi, multiply it by two and add one, i.e. replace xi with 2Β·xi + 1.
Note that integers in X are not required to be distinct after each operation.
Two sets of distinct integers X and Y are equal if they are equal as sets. In other words, if we write elements of the sets in the array in the increasing order, these arrays would be equal.
Note, that any set of integers (or its permutation) generates itself.
You are given a set Y and have to find a set X that generates Y and the maximum element of X is mininum possible.
Input
The first line of the input contains a single integer n (1 β€ n β€ 50 000) β the number of elements in Y.
The second line contains n integers y1, ..., yn (1 β€ yi β€ 109), that are guaranteed to be distinct.
Output
Print n integers β set of distinct integers that generate Y and the maximum element of which is minimum possible. If there are several such sets, print any of them.
Examples
Input
5
1 2 3 4 5
Output
4 5 2 3 1
Input
6
15 14 3 13 1 12
Output
12 13 14 7 3 1
Input
6
9 7 13 17 5 11
Output
4 5 2 6 3 1
Tags: binary search, data structures, dfs and similar, greedy, strings, trees
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
##########################################################
from collections import Counter,defaultdict
import math
#for _ in range(int(input())):
#n=int(input())
def matching(s):
le = len(s)
pi=[0]*le
for i in range(1,le):
j=pi[i-1]
while j>0 and s[i]!=s[j]:
j=pi[j-1]
if(s[i]==s[j]):
j+=1
pi[i]=j
#return pi
## to return list of values
w=set()
i=le-1
while pi[i]!=0:
w.add(le-pi[i])
i=pi[i]-1
return w
#n,m=map(int,input().split())
#p=input()
from heapq import heapify, heapreplace, heappop,heappush
input()
#arr=list(map(int, input().split()))
#a1=list(map(int, input().split()))
s = set(map(int, input().split()))
xx = [-x for x in s]
heapify(xx)
while True:
x = -xx[0]
#print(x)
while x != 1:
x //= 2
if x not in s:
s.add(x)
heappop(xx)
heappush(xx,-x)
#heapreplace(xx, -x)
break
else:
break
print(' '.join(str(-x) for x in xx))
```
| 8,041 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a set Y of n distinct positive integers y1, y2, ..., yn.
Set X of n distinct positive integers x1, x2, ..., xn is said to generate set Y if one can transform X to Y by applying some number of the following two operation to integers in X:
1. Take any integer xi and multiply it by two, i.e. replace xi with 2Β·xi.
2. Take any integer xi, multiply it by two and add one, i.e. replace xi with 2Β·xi + 1.
Note that integers in X are not required to be distinct after each operation.
Two sets of distinct integers X and Y are equal if they are equal as sets. In other words, if we write elements of the sets in the array in the increasing order, these arrays would be equal.
Note, that any set of integers (or its permutation) generates itself.
You are given a set Y and have to find a set X that generates Y and the maximum element of X is mininum possible.
Input
The first line of the input contains a single integer n (1 β€ n β€ 50 000) β the number of elements in Y.
The second line contains n integers y1, ..., yn (1 β€ yi β€ 109), that are guaranteed to be distinct.
Output
Print n integers β set of distinct integers that generate Y and the maximum element of which is minimum possible. If there are several such sets, print any of them.
Examples
Input
5
1 2 3 4 5
Output
4 5 2 3 1
Input
6
15 14 3 13 1 12
Output
12 13 14 7 3 1
Input
6
9 7 13 17 5 11
Output
4 5 2 6 3 1
Tags: binary search, data structures, dfs and similar, greedy, strings, trees
Correct Solution:
```
def solve():
from heapq import merge
input() # read n
a = set(int(x) for x in input().split(' '))
maxe = max(a)
nodemap = {}
class node:
__slots__ = ('left', 'right')
def __init__(self):
self.right = self.left = None
for x in a:
while (x > 0) and not (x in nodemap):
nodemap[x] = node()
#print(f"node({x}) created")
x //= 2
for x in nodemap.keys():
y = x // 2
if x > 1:
if x%2 == 1:
nodemap[y].right = nodemap[x]
#print(f"{y} --right--> {x}")
else:
nodemap[y].left = nodemap[x]
#print(f"{y} --left--> {x}")
root = nodemap[1]
#print(list(nodemap.keys()))
def f(x, root):
if not root:
return (-1, [])
#print(f"f({x}) called")
lmax, larr = f(2*x, root.left)
#print(f"left({x}) = {larr}")
rmax, rarr = f(2*x+1, root.right)
#print(f"right({x}) = {rarr}")
if x in a:
return (max(lmax, x, rmax), list(merge(larr, [x], rarr)))
if lmax > rmax:
larr.pop()
newmax = larr[-1] if len(larr) else -1
return (max(newmax, x, rmax), list(merge(larr, [x], rarr)))
elif lmax < rmax:
rarr.pop()
newmax = rarr[-1] if len(rarr) else -1
return (max(lmax, x, newmax), list(merge(larr, [x], rarr)))
else:
return (-1, [])
#print("running...")
print(" ".join(str(x) for x in f(1, root)[1]))
if __name__ == "__main__":
solve()
```
| 8,042 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a set Y of n distinct positive integers y1, y2, ..., yn.
Set X of n distinct positive integers x1, x2, ..., xn is said to generate set Y if one can transform X to Y by applying some number of the following two operation to integers in X:
1. Take any integer xi and multiply it by two, i.e. replace xi with 2Β·xi.
2. Take any integer xi, multiply it by two and add one, i.e. replace xi with 2Β·xi + 1.
Note that integers in X are not required to be distinct after each operation.
Two sets of distinct integers X and Y are equal if they are equal as sets. In other words, if we write elements of the sets in the array in the increasing order, these arrays would be equal.
Note, that any set of integers (or its permutation) generates itself.
You are given a set Y and have to find a set X that generates Y and the maximum element of X is mininum possible.
Input
The first line of the input contains a single integer n (1 β€ n β€ 50 000) β the number of elements in Y.
The second line contains n integers y1, ..., yn (1 β€ yi β€ 109), that are guaranteed to be distinct.
Output
Print n integers β set of distinct integers that generate Y and the maximum element of which is minimum possible. If there are several such sets, print any of them.
Examples
Input
5
1 2 3 4 5
Output
4 5 2 3 1
Input
6
15 14 3 13 1 12
Output
12 13 14 7 3 1
Input
6
9 7 13 17 5 11
Output
4 5 2 6 3 1
Submitted Solution:
```
n = int(input())
p = list(map(int, input().split()))
l = list(map(lambda x: (x//2, 1-x%2), p))
l.sort()
v = max(p)
vv = []
while True:
d = []
for x, y in l:
if x == 0 or x in d or x in vv:
d.append(2*x+1-y)
else:
d.append(x)
vn = max(d)
if vn >= v: break
v = vn
vv = []
while v:
vv.append(v)
v //= 2
print(" ".join(map(str, d)))
```
No
| 8,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a set Y of n distinct positive integers y1, y2, ..., yn.
Set X of n distinct positive integers x1, x2, ..., xn is said to generate set Y if one can transform X to Y by applying some number of the following two operation to integers in X:
1. Take any integer xi and multiply it by two, i.e. replace xi with 2Β·xi.
2. Take any integer xi, multiply it by two and add one, i.e. replace xi with 2Β·xi + 1.
Note that integers in X are not required to be distinct after each operation.
Two sets of distinct integers X and Y are equal if they are equal as sets. In other words, if we write elements of the sets in the array in the increasing order, these arrays would be equal.
Note, that any set of integers (or its permutation) generates itself.
You are given a set Y and have to find a set X that generates Y and the maximum element of X is mininum possible.
Input
The first line of the input contains a single integer n (1 β€ n β€ 50 000) β the number of elements in Y.
The second line contains n integers y1, ..., yn (1 β€ yi β€ 109), that are guaranteed to be distinct.
Output
Print n integers β set of distinct integers that generate Y and the maximum element of which is minimum possible. If there are several such sets, print any of them.
Examples
Input
5
1 2 3 4 5
Output
4 5 2 3 1
Input
6
15 14 3 13 1 12
Output
12 13 14 7 3 1
Input
6
9 7 13 17 5 11
Output
4 5 2 6 3 1
Submitted Solution:
```
n = int(input())
y = sorted(map(int, input().split()))
ans = set([1])
for num in y[1:]:
tmp = num // 2
while tmp not in ans:
num //= 2
tmp //= 2
ans.add(num)
for num in ans:
print(num, end=" ")
```
No
| 8,044 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a set Y of n distinct positive integers y1, y2, ..., yn.
Set X of n distinct positive integers x1, x2, ..., xn is said to generate set Y if one can transform X to Y by applying some number of the following two operation to integers in X:
1. Take any integer xi and multiply it by two, i.e. replace xi with 2Β·xi.
2. Take any integer xi, multiply it by two and add one, i.e. replace xi with 2Β·xi + 1.
Note that integers in X are not required to be distinct after each operation.
Two sets of distinct integers X and Y are equal if they are equal as sets. In other words, if we write elements of the sets in the array in the increasing order, these arrays would be equal.
Note, that any set of integers (or its permutation) generates itself.
You are given a set Y and have to find a set X that generates Y and the maximum element of X is mininum possible.
Input
The first line of the input contains a single integer n (1 β€ n β€ 50 000) β the number of elements in Y.
The second line contains n integers y1, ..., yn (1 β€ yi β€ 109), that are guaranteed to be distinct.
Output
Print n integers β set of distinct integers that generate Y and the maximum element of which is minimum possible. If there are several such sets, print any of them.
Examples
Input
5
1 2 3 4 5
Output
4 5 2 3 1
Input
6
15 14 3 13 1 12
Output
12 13 14 7 3 1
Input
6
9 7 13 17 5 11
Output
4 5 2 6 3 1
Submitted Solution:
```
input()
inp=input().split()
inp2=[]
for i in range(len(inp)):
inp[i]=int(inp[i])
inp2.append(inp[i])
inp.sort(reverse=True)
for i in inp:
a=i
while(a>1):
if(a%2==0):
a=a/2
else:
a=(a-1)/2
if a not in inp2:
ind=inp2.index(i)
del inp2[ind]
inp2.append(a)
i=a
for i in inp2:
print(i,end=' ')
```
No
| 8,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given a set Y of n distinct positive integers y1, y2, ..., yn.
Set X of n distinct positive integers x1, x2, ..., xn is said to generate set Y if one can transform X to Y by applying some number of the following two operation to integers in X:
1. Take any integer xi and multiply it by two, i.e. replace xi with 2Β·xi.
2. Take any integer xi, multiply it by two and add one, i.e. replace xi with 2Β·xi + 1.
Note that integers in X are not required to be distinct after each operation.
Two sets of distinct integers X and Y are equal if they are equal as sets. In other words, if we write elements of the sets in the array in the increasing order, these arrays would be equal.
Note, that any set of integers (or its permutation) generates itself.
You are given a set Y and have to find a set X that generates Y and the maximum element of X is mininum possible.
Input
The first line of the input contains a single integer n (1 β€ n β€ 50 000) β the number of elements in Y.
The second line contains n integers y1, ..., yn (1 β€ yi β€ 109), that are guaranteed to be distinct.
Output
Print n integers β set of distinct integers that generate Y and the maximum element of which is minimum possible. If there are several such sets, print any of them.
Examples
Input
5
1 2 3 4 5
Output
4 5 2 3 1
Input
6
15 14 3 13 1 12
Output
12 13 14 7 3 1
Input
6
9 7 13 17 5 11
Output
4 5 2 6 3 1
Submitted Solution:
```
from collections import Counter
n = int(input())
y = sorted(map(int, input().split()))
counts = Counter(y)
for i in range(n-1, 0, -1):
tmp = y[i] // 2
while counts.get(tmp, 0) > 0:
tmp //= 2
if tmp != 0:
tmp = y[i]
while counts.get(tmp, 0) > 0:
counts[tmp] -= 1
tmp //= 2
counts[tmp] += 1
for key, val in counts.items():
for i in range(val):
print(key, end=" ")
```
No
| 8,046 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Tags: bitmasks, divide and conquer, interactive
Correct Solution:
```
import sys
import math
import itertools
n = int(input())
l = n.bit_length()
A = [float('inf')] * n
for i in range(l):
digits = map(lambda x: (x>>i)&1, range(1, n+1))
question = list(filter(lambda x: (x>>i)&1, range(1, n+1)))
print(len(question))
print(' '.join(map(str, question)))
sys.stdout.flush()
answer1 = [int(x) for x in input().split()]
question = list(filter(lambda x: not (x>>i)&1, range(1, n+1)))
print(len(question))
print(' '.join(map(str, question)))
sys.stdout.flush()
answer2 = [int(x) for x in input().split()]
for x, d in enumerate(digits):
A[x] = min(A[x], answer2[x]) if d else min(A[x], answer1[x])
print(-1)
print(' '.join(map(str, A)))
sys.stdout.flush()
```
| 8,047 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Tags: bitmasks, divide and conquer, interactive
Correct Solution:
```
inf = 10 ** 10
n = int(input())
m = 1
while not (n < 2 ** m):
m += 1
u = []
v = []
for i in range(m):
u.append([])
v.append([])
for j in range(n):
if j & (1 << i):
u[i].append(j+1)
else:
v[i].append(j+1)
s = []
t = []
for i in range(m):
if len(u[i]) == 0:
values = [inf] * n
else:
line = ' '.join(map(str, u[i]))
print(len(u[i]))
print(line, flush=True)
values = list(map(int, input().split()))
s.append(values)
for i in range(m):
if len(v[i]) == 0:
values = [inf] * n
else:
line = ' '.join(map(str, v[i]))
print(len(v[i]))
print(line, flush=True)
values = list(map(int, input().split()))
t.append(values)
res = []
for j in range(n):
r = inf
for i in range(m):
if j & (1 << i):
r = min(r, t[i][j])
else:
r = min(r, s[i][j])
res.append(r)
print(-1, flush=True)
line = ' '.join(map(str, res))
print(line, flush=True)
```
| 8,048 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Tags: bitmasks, divide and conquer, interactive
Correct Solution:
```
import sys
n = int(input())
MAX = 2000 * 1000 * 1000
res = [MAX] * n
k = 1
while k < n:
x = [0] * n
output = []
sz = 0
for i in range(0, n, 2 * k):
for j in range(0, min(n - i, k)):
output.append(i + j + 1)
sz += 1
#print(i + j + 1, end = ' ')
x[i + j] = 1
print(sz)
print(' '.join(map(str, output)))
sys.stdout.flush()
a = list(map(int, input().split()))
for i in range(len(a)):
if a[i] != 0 or x[i] == 0:
res[i] = min(res[i], a[i])
x = [0] * n
output = []
sz = 0
for i in range(k, n, 2 * k):
for j in range(0, min(n - i, k)):
output.append(i + j + 1)
#print(i + j + 1, end = ' ')
x[i + j] = 1
sz += 1
print(sz)
print(' '.join(map(str, output)))
sys.stdout.flush()
a = list(map(int, input().split()))
for i in range(len(a)):
if a[i] != 0 or x[i] == 0:
res[i] = min(res[i], a[i])
k *= 2
print(-1)
for i in range(n):
if res[i] != MAX:
print(res[i], end = ' ')
else:
print(0, end = ' ')
print()
sys.stdout.flush()
# 0 0 0 0 0
# 1 0 2 3 1
# 1 2 0 1 0
# 5 5 5 0 5
# 2 3 4 5 0
```
| 8,049 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Tags: bitmasks, divide and conquer, interactive
Correct Solution:
```
import sys
n = int(input())
MAX = 2000 * 1000 * 1000
res = [MAX] * n
k = 1
while k < n:
x = [0] * n
output = []
sz = 0
for i in range(0, n, 2 * k):
for j in range(0, min(n - i, k)):
output.append(i + j + 1)
sz += 1
#print(i + j + 1, end = ' ')
x[i + j] = 1
print(sz, end = ' ')
print(' '.join(map(str, output)))
sys.stdout.flush()
a = list(map(int, input().split()))
for i in range(len(a)):
if a[i] != 0 or x[i] == 0:
res[i] = min(res[i], a[i])
x = [0] * n
output = []
sz = 0
for i in range(k, n, 2 * k):
for j in range(0, min(n - i, k)):
output.append(i + j + 1)
#print(i + j + 1, end = ' ')
x[i + j] = 1
sz += 1
print(sz, end = ' ')
print(' '.join(map(str, output)))
sys.stdout.flush()
a = list(map(int, input().split()))
for i in range(len(a)):
if a[i] != 0 or x[i] == 0:
res[i] = min(res[i], a[i])
k *= 2
print(-1)
for i in range(n):
if res[i] != MAX:
print(res[i], end = ' ')
else:
print(0, end = ' ')
print()
sys.stdout.flush()
# 0 0 0 0 0
# 1 0 2 3 1
# 1 2 0 1 0
# 5 5 5 0 5
# 2 3 4 5 0
```
| 8,050 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Tags: bitmasks, divide and conquer, interactive
Correct Solution:
```
from sys import stdout
n = int(input())
ans = [10**10] * n
th = 1
while th < n:
ask = [i % (2*th) < th for i in range(n)]
for _ in range(2):
inds = [key for key, value in enumerate(ask) if value]
print(len(inds))
print(' '.join([str(i+1) for i in inds]))
stdout.flush()
reply = list(map(int, input().split(' ')))
ans = [ans[i] if ask[i] else min(ans[i], reply[i]) for i in range(n)]
ask = [not v for v in ask]
th *= 2
print(-1)
print(' '.join(map(str, ans)))
stdout.flush()
```
| 8,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Tags: bitmasks, divide and conquer, interactive
Correct Solution:
```
import sys
n = int(input())
mn = [float('inf') for _ in range(n)]
ln = len(bin(n)) - 3
cnt = 0
for bit in range(ln, -1, -1):
query = []
inv_query = []
for i in range(1, n + 1):
if i & (1<<bit):
query.append(i)
else:
inv_query.append(i)
print(len(query))
print(' '.join(map(str, query)))
sys.stdout.flush()
ans = list(map(int, input().split()))
for i in inv_query:
mn[i - 1] = min(mn[i - 1], ans[i - 1])
print(len(inv_query))
print(' '.join(map(str, inv_query)))
sys.stdout.flush()
ans = list(map(int, input().split()))
for i in query:
mn[i - 1] = min(mn[i - 1], ans[i - 1])
print(-1)
print(' '.join(map(str, mn)))
sys.stdout.flush()
```
| 8,052 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Tags: bitmasks, divide and conquer, interactive
Correct Solution:
```
n = int(input().strip())
import math
import sys
factor = 1
each_row_min = [10000000000]*n
for i in range(int(math.log(n, 2))+1):
if factor >= n:
break
mask = []
comp_mask = []
for j in range(n):
if (j//factor)%2 == 0:
mask.append(j)
else:
comp_mask.append(j)
print(len(mask))
print(' '.join([str(x+1) for x in mask]))
sys.stdout.flush()
results = [int(x) for x in input().split()]
for row, rowmin in enumerate(results):
if row not in mask:
each_row_min[row] = min(each_row_min[row], rowmin)
#comp
mask = comp_mask
print(len(mask))
print(' '.join([str(x+1) for x in mask]))
sys.stdout.flush()
results = [int(x) for x in input().split()]
for row, rowmin in enumerate(results):
if row not in mask:
each_row_min[row] = min(each_row_min[row], rowmin)
factor*=2
print(-1)
print(' '.join(str(x) for x in each_row_min))
sys.stdout.flush
```
| 8,053 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Tags: bitmasks, divide and conquer, interactive
Correct Solution:
```
from sys import stdout
n = int(input())
ans = [10**10] * n
th = 1
while th < n:
ask = [i % (2*th) < th for i in range(n)]
for _ in range(2):
inds = [key for key, value in enumerate(ask) if value]
print(len(inds))
print(' '.join([str(i+1) for i in inds]))
stdout.flush()
reply = list(map(int, input().split(' ')))
ans = [ans[i] if ask[i] else min(ans[i], reply[i]) for i in range(n)]
ask = [not v for v in ask]
th *= 2
print(-1)
print(' '.join(map(str, ans)))
stdout.flush()
# Made By Mostafa_Khaled
```
| 8,054 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Submitted Solution:
```
from sys import stdout
def g(k, p):
print(str(k) + '\n' + ' '.join(map(str, p)))
stdout.flush()
n = int(input())
s = [9e9] * n
def f(q):
global s
p = [k + 1 for k, v in enumerate(q) if v]
g(len(p), p)
s = [i if j else min(i, int(k)) for i, j, k in zip(s, q, input().split())]
return [not v for v in q]
k = 1
while k < n:
f(f([not (i & k) for i in range(n)]))
k *= 2
g(-1, s)
```
Yes
| 8,055 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Submitted Solution:
```
import math,sys,re,itertools,pprint,collections,copy
rs,ri,rai,raf=input,lambda:int(input()),lambda:list(map(int, input().split())),lambda:list(map(float, input().split()))
pai=lambda x: print(" ".join(map(str, x)))
n = ri()
line_min = [float("inf") for _ in range(n)]
requests = []
def init_requests():
requests.append([
[(1, n//2)], [(n//2+1, n)]
])
while True:
l, r = requests[-1]
ln, rn = [], []
for i, j in l + r:
if j - i > 0:
ln.append(
(i, (i+j)//2)
)
rn.append(
((i+j)//2+1, j)
)
if len(ln) == 0 and len(rn) == 0:
break
requests.append([ln, rn])
def make_request(a: list):
print(len(a))
print(" ".join(map(str, a)))
sys.stdout.flush()
ans = rai()
for i in range(n):
if i+1 not in a:
line_min[i] = min(line_min[i], ans[i])
init_requests()
for l, r in requests:
la = []
for lr in l:
la += list(range(lr[0], lr[1]+1))
make_request(la)
ra = []
for rr in r:
ra += list(range(rr[0], rr[1]+1))
make_request(ra)
print(-1)
pai(line_min)
```
Yes
| 8,056 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Submitted Solution:
```
import sys
def f(x,y):
if not x: return y
elif not y: return x
else: return min(x,y)
count = 0
def req(old, lst):
global count
if count < 20:
print(len(lst))
print(" ".join(map(lambda x: str(x+1), lst)))
sys.stdout.flush()
current = list(map(int, input().split()))
for i in range(n):
if i in lst:
current[i] = BIG
old = list(map(min, old, current))
count += 1
return old
BIG = 10000000000
n = int(input())
mask = 1
res = [BIG] * n
while mask <= n:
a = [x for x in range(n) if x & mask]
b = [x for x in range(n) if not x & mask]
if a and b:
res = req(res, a)
res = req(res, b)
if count == 20: break
mask <<= 1
print(-1)
print(" ".join(map(str, res)))
sys.stdout.flush()
```
Yes
| 8,057 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Submitted Solution:
```
from re import *
from sys import *
def readint():
return int(input())
def readfloat():
return float(input())
def readarray(N, foo=input):
return [foo() for i in range(N)]
def readlinearray(foo=int):
return list(map(foo, input().split()))
def NOD(a, b):
while b:
a,b = b, a%b
return a
def gen_primes(max):
primes = [1]*(max+1)
for i in range(2, max+1):
if primes[i]:
for j in range(i+i, max+1, i):
primes[j] = 0
primes[0] = 0
return [x for x in range(max+1) if primes[x]]
def is_prime(N):
i = 3
if not(N % 2):
return 0
while i*i < N:
if not(N % i):
return 0
i += 3
return 1
n = readint()
data = [10**9 for i in range(n)]
bits = 0
while 1 << bits < n:
bits += 1
for b in range(bits):
question = set([i + 1 for i in range(n) if (i & 1 << b)])
stdout.write('%d\n%s\n' % (len(question), ' '.join(map(str, question)), ))
stdout.flush()
answer = readlinearray()
for i in range(n):
if i + 1 not in question:
data[i] = min(data[i], answer[i])
question = set([i + 1 for i in range(n) if not(i & 1 << b)])
stdout.write('%d\n%s\n' % (len(question), ' '.join(map(str, question)), ))
stdout.flush()
answer = readlinearray()
for i in range(n):
if i + 1 not in question:
data[i] = min(data[i], answer[i])
stdout.write('-1\n%s\n' % (' '.join(map(str, data)), ))
stdout.flush()
```
Yes
| 8,058 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Submitted Solution:
```
n = int(input().strip())
import math
import sys
factor = 1
each_row_min = [10000000000]*n
for i in range(int(math.log(n, 2))+1):
mask = []
comp_mask = []
for j in range(n):
if (j//factor)%2 == 0:
mask.append(j)
else:
comp_mask.append(j)
print(len(mask))
print(' '.join([str(x+1) for x in mask]))
sys.stdout.flush()
results = [int(x) for x in input().split()]
for row, rowmin in enumerate(results):
if row not in mask:
each_row_min[row] = min(each_row_min[row], rowmin)
#comp
mask = comp_mask
print(len(mask))
print(' '.join([str(x+1) for x in mask]))
sys.stdout.flush()
results = [int(x) for x in input().split()]
for row, rowmin in enumerate(results):
if row not in mask:
each_row_min[row] = min(each_row_min[row], rowmin)
factor*=2
print(-1)
print(' '.join(str(x) for x in each_row_min))
sys.stdout.flush
```
No
| 8,059 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Submitted Solution:
```
from random import *
n = int(input())
res = [10 ** 10] * (n + 1)
my = [i for i in range(1, n + 1)]
for i in range(20):
shuffle(my)
num = n // 2
ask = my[:num]
print(num)
print(' '.join(map(str, ask)))
ans = list(map(int, input().split()))
for i in range(1, n + 1):
if i not in ask:
res[i] = min(res[i], ans[i - 1])
print(-1)
print(' '.join(map(str, res[1:])))
```
No
| 8,060 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Submitted Solution:
```
import sys
def f(x,y):
if not x: return y
elif not y: return x
else: return min(x,y)
count = 0
n = int(input())
mask = 1
res = [0] * n
while mask <= n:
a = list(map(str, filter(lambda x: (x & mask) == 0, range(1, n+1))))
if a:
print(len(a))
print(" ".join(a))
sys.stdout.flush()
current = map(int, input().split())
res = list(map(f, res, current))
count += 1
if count == 20: break
a = list(map(str, filter(lambda x: x & mask, range(1, n+1))))
if a:
print(len(a))
print(" ".join(a))
sys.stdout.flush()
current = map(int, input().split())
res = list(map(f, res, current))
count += 1
if count == 20: break
mask <<= 1
print(-1)
print(" ".join(map(str, res)))
sys.stdout.flush()
```
No
| 8,061 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem. In the interaction section below you will see the information about flushing the output.
In this problem, you will be playing a game with Hongcow. How lucky of you!
Hongcow has a hidden n by n matrix M. Let Mi, j denote the entry i-th row and j-th column of the matrix. The rows and columns are labeled from 1 to n.
The matrix entries are between 0 and 109. In addition, Mi, i = 0 for all valid i. Your task is to find the minimum value along each row, excluding diagonal elements. Formally, for each i, you must find <image>.
To do this, you can ask Hongcow some questions.
A question consists of giving Hongcow a subset of distinct indices {w1, w2, ..., wk}, with 1 β€ k β€ n. Hongcow will respond with n integers. The i-th integer will contain the minimum value of min1 β€ j β€ kMi, wj.
You may only ask Hongcow at most 20 questions β he thinks you only need that many questions answered.
When you are ready to answer, print out a single integer - 1 on its own line, then n integers on the next line. The i-th integer should be the minimum value in the i-th row of the matrix, excluding the i-th element. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.
You will get Wrong Answer verdict if
* Your question or answers are not in the format described in this statement.
* You ask strictly more than 20 questions.
* Your question contains duplicate indices.
* The value of k in your question does not lie in the range from 1 to n, inclusive.
* Your final answer is not correct.
You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).
Input
The first line of input will contain a single integer n (2 β€ n β€ 1, 000).
Output
To print the final answer, print out the string -1 on its own line. Then, the next line should contain n integers. The i-th integer should be the minimum value of the i-th row of the matrix, excluding elements on the diagonal. Do not forget to flush your answer!
Interaction
To ask a question, print out a single integer k on its own line, denoting the size of your subset. Then, the next line should contain k integers w1, w2, ... wk. Note, you must flush your output to get a response.
Hongcow will respond by printing out a line with n integers. The i-th integer in this line represents the minimum value of Mi, wj where j is between 1 and k.
You may only ask a question at most 20 times, otherwise, you will get Wrong Answer.
To flush you can use (just after printing an integer and end-of-line):
* fflush(stdout) in C++;
* System.out.flush() in Java;
* stdout.flush() in Python;
* flush(output) in Pascal;
* See the documentation for other languages.
Hacking To hack someone, use the following format
n
M_{1,1} M_{1,2} ... M_{1,n}
M_{2,1} M_{2,2} ... M_{2,n}
...
M_{n,1} M_{n,2} ... M_{n,n}
Of course, contestant programs will not be able to see this input.
Examples
Input
3
0 0 0
2 7 0
0 0 4
3 0 8
0 5 4
Output
3
1 2 3
1
3
2
1 2
1
2
1
1
-1
2 5 4
Input
2
0 0
0 0
Output
1
2
1
1
-1
0 0
Note
In the first sample, Hongcow has the hidden matrix
[
[0, 3, 2],
[5, 0, 7],
[4, 8 ,0],
]
Here is a more readable version demonstrating the interaction. The column on the left represents Hongcow, while the column on the right represents the contestant.
3
3
1 2 3
0 0 0
1
3
2 7 0
2
1 2
0 0 4
1
2
3 0 8
1
1
0 5 4
-1
2 5 4
For the second sample, it is possible for off-diagonal elements of the matrix to be zero.
Submitted Solution:
```
import sys
def f(x,y):
if not x: return y
elif not y: return x
else: return min(x,y)
n = int(input())
mask = 1
res = [0] * n
while mask <= n:
a = list(map(str, filter(lambda x: (x & mask) == 0, range(1, n+1))))
if a:
print(len(a))
print(" ".join(a))
sys.stdout.flush()
current = map(int, input().split())
res = list(map(f, res, current))
a = list(map(str, filter(lambda x: x & mask, range(1, n+1))))
if a:
print(len(a))
print(" ".join(a))
sys.stdout.flush()
current = map(int, input().split())
res = list(map(f, res, current))
mask <<= 1
print(-1)
print(" ".join(map(str, res)))
sys.stdout.flush()
```
No
| 8,062 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Olya likes milk very much. She drinks k cartons of milk each day if she has at least k and drinks all of them if she doesn't. But there's an issue β expiration dates. Each carton has a date after which you can't drink it (you still can drink it exactly at the date written on the carton). Due to this, if Olya's fridge contains a carton past its expiry date, she throws it away.
Olya hates throwing out cartons, so when she drinks a carton, she chooses the one which expires the fastest. It's easy to understand that this strategy minimizes the amount of cartons thrown out and lets her avoid it if it's even possible.
<image> Milk. Best before: 20.02.2017.
The main issue Olya has is the one of buying new cartons. Currently, there are n cartons of milk in Olya's fridge, for each one an expiration date is known (how soon does it expire, measured in days). In the shop that Olya visited there are m cartons, and the expiration date is known for each of those cartons as well.
Find the maximum number of cartons Olya can buy so that she wouldn't have to throw away any cartons. Assume that Olya drank no cartons today.
Input
In the first line there are three integers n, m, k (1 β€ n, m β€ 106, 1 β€ k β€ n + m) β the amount of cartons in Olya's fridge, the amount of cartons in the shop and the number of cartons Olya drinks each day.
In the second line there are n integers f1, f2, ..., fn (0 β€ fi β€ 107) β expiration dates of the cartons in Olya's fridge. The expiration date is expressed by the number of days the drinking of this carton can be delayed. For example, a 0 expiration date means it must be drunk today, 1 β no later than tomorrow, etc.
In the third line there are m integers s1, s2, ..., sm (0 β€ si β€ 107) β expiration dates of the cartons in the shop in a similar format.
Output
If there's no way for Olya to drink the cartons she already has in her fridge, print -1.
Otherwise, in the first line print the maximum number x of cartons which Olya can buy so that she wouldn't have to throw a carton away. The next line should contain exactly x integers β the numbers of the cartons that should be bought (cartons are numbered in an order in which they are written in the input, starting with 1). Numbers should not repeat, but can be in arbitrary order. If there are multiple correct answers, print any of them.
Examples
Input
3 6 2
1 0 1
2 0 2 0 0 2
Output
3
1 2 3
Input
3 1 2
0 0 0
1
Output
-1
Input
2 1 2
0 1
0
Output
1
1
Note
In the first example k = 2 and Olya has three cartons with expiry dates 0, 1 and 1 (they expire today, tomorrow and tomorrow), and the shop has 3 cartons with expiry date 0 and 3 cartons with expiry date 2. Olya can buy three cartons, for example, one with the expiry date 0 and two with expiry date 2.
In the second example all three cartons Olya owns expire today and it means she would have to throw packets away regardless of whether she buys an extra one or not.
In the third example Olya would drink k = 2 cartons today (one she alreay has in her fridge and one from the shop) and the remaining one tomorrow.
Submitted Solution:
```
def p(a):
t = max(a)
x = True
for i in range(t + 1):
l = 0
for j in a:
if j <= i:
l += 1
if l > (i + 1) * k:
x = False
break
return x
n, m , k = map(int, input().split())
a = [int(i) for i in input().split()]
u = a.copy()
f = u.copy()
b = [int(i) for i in input().split()]
c = b.copy()
b.sort()
left = 0
right = m
if right == 1:
a.append(b[0])
if p(a) == False:
right = 0
else:
left = 1
while right - left >= 1:
ans = (left + right) // 2
a.extend(b[-ans:])
if p(a) == False:
right = ans - 1
else:
left = ans
a = u
if p(f) == True:
print(left)
for i in range(m - left, m):
print(c.index(b[i]) + 1, end=' ')
c[c.index(b[i])] = -1
else:
print(-1)
```
No
| 8,063 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Olya likes milk very much. She drinks k cartons of milk each day if she has at least k and drinks all of them if she doesn't. But there's an issue β expiration dates. Each carton has a date after which you can't drink it (you still can drink it exactly at the date written on the carton). Due to this, if Olya's fridge contains a carton past its expiry date, she throws it away.
Olya hates throwing out cartons, so when she drinks a carton, she chooses the one which expires the fastest. It's easy to understand that this strategy minimizes the amount of cartons thrown out and lets her avoid it if it's even possible.
<image> Milk. Best before: 20.02.2017.
The main issue Olya has is the one of buying new cartons. Currently, there are n cartons of milk in Olya's fridge, for each one an expiration date is known (how soon does it expire, measured in days). In the shop that Olya visited there are m cartons, and the expiration date is known for each of those cartons as well.
Find the maximum number of cartons Olya can buy so that she wouldn't have to throw away any cartons. Assume that Olya drank no cartons today.
Input
In the first line there are three integers n, m, k (1 β€ n, m β€ 106, 1 β€ k β€ n + m) β the amount of cartons in Olya's fridge, the amount of cartons in the shop and the number of cartons Olya drinks each day.
In the second line there are n integers f1, f2, ..., fn (0 β€ fi β€ 107) β expiration dates of the cartons in Olya's fridge. The expiration date is expressed by the number of days the drinking of this carton can be delayed. For example, a 0 expiration date means it must be drunk today, 1 β no later than tomorrow, etc.
In the third line there are m integers s1, s2, ..., sm (0 β€ si β€ 107) β expiration dates of the cartons in the shop in a similar format.
Output
If there's no way for Olya to drink the cartons she already has in her fridge, print -1.
Otherwise, in the first line print the maximum number x of cartons which Olya can buy so that she wouldn't have to throw a carton away. The next line should contain exactly x integers β the numbers of the cartons that should be bought (cartons are numbered in an order in which they are written in the input, starting with 1). Numbers should not repeat, but can be in arbitrary order. If there are multiple correct answers, print any of them.
Examples
Input
3 6 2
1 0 1
2 0 2 0 0 2
Output
3
1 2 3
Input
3 1 2
0 0 0
1
Output
-1
Input
2 1 2
0 1
0
Output
1
1
Note
In the first example k = 2 and Olya has three cartons with expiry dates 0, 1 and 1 (they expire today, tomorrow and tomorrow), and the shop has 3 cartons with expiry date 0 and 3 cartons with expiry date 2. Olya can buy three cartons, for example, one with the expiry date 0 and two with expiry date 2.
In the second example all three cartons Olya owns expire today and it means she would have to throw packets away regardless of whether she buys an extra one or not.
In the third example Olya would drink k = 2 cartons today (one she alreay has in her fridge and one from the shop) and the remaining one tomorrow.
Submitted Solution:
```
import sys
from collections import defaultdict
consume = 0
fridge = defaultdict(int)
shop = defaultdict(list)
cartons = []
for (index, line) in enumerate(sys.stdin):
if index == 0:
consume = int(line.split(' ')[2])
if index == 1:
if line.rstrip():
for x in line.split(' '):
fridge[int(x)] += 1
elif index == 2:
if line.rstrip():
for (index, day) in enumerate(line.split(' ')):
shop[int(day)].append(index + 1)
hold = 0
for day in range(max(fridge.keys()), -1, -1):
if fridge[day] < consume:
fridge[day] += hold
hold = 0
if fridge[day] > consume:
hold += fridge[day] - consume
fridge[day] = consume
if hold > 0:
print(-1)
sys.exit(0)
def more_cartons(day, num):
return sorted(shop[day])[0:num]
for (key, value) in fridge.items():
if value > consume:
print(-1)
sys.exit(0)
elif value < consume:
cartons += more_cartons(key, consume - value)
for (key, value) in shop.items():
if key not in fridge:
cartons += more_cartons(key, consume)
print(len(cartons))
print(' '.join([str(x) for x in sorted(cartons)]))
```
No
| 8,064 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Olya likes milk very much. She drinks k cartons of milk each day if she has at least k and drinks all of them if she doesn't. But there's an issue β expiration dates. Each carton has a date after which you can't drink it (you still can drink it exactly at the date written on the carton). Due to this, if Olya's fridge contains a carton past its expiry date, she throws it away.
Olya hates throwing out cartons, so when she drinks a carton, she chooses the one which expires the fastest. It's easy to understand that this strategy minimizes the amount of cartons thrown out and lets her avoid it if it's even possible.
<image> Milk. Best before: 20.02.2017.
The main issue Olya has is the one of buying new cartons. Currently, there are n cartons of milk in Olya's fridge, for each one an expiration date is known (how soon does it expire, measured in days). In the shop that Olya visited there are m cartons, and the expiration date is known for each of those cartons as well.
Find the maximum number of cartons Olya can buy so that she wouldn't have to throw away any cartons. Assume that Olya drank no cartons today.
Input
In the first line there are three integers n, m, k (1 β€ n, m β€ 106, 1 β€ k β€ n + m) β the amount of cartons in Olya's fridge, the amount of cartons in the shop and the number of cartons Olya drinks each day.
In the second line there are n integers f1, f2, ..., fn (0 β€ fi β€ 107) β expiration dates of the cartons in Olya's fridge. The expiration date is expressed by the number of days the drinking of this carton can be delayed. For example, a 0 expiration date means it must be drunk today, 1 β no later than tomorrow, etc.
In the third line there are m integers s1, s2, ..., sm (0 β€ si β€ 107) β expiration dates of the cartons in the shop in a similar format.
Output
If there's no way for Olya to drink the cartons she already has in her fridge, print -1.
Otherwise, in the first line print the maximum number x of cartons which Olya can buy so that she wouldn't have to throw a carton away. The next line should contain exactly x integers β the numbers of the cartons that should be bought (cartons are numbered in an order in which they are written in the input, starting with 1). Numbers should not repeat, but can be in arbitrary order. If there are multiple correct answers, print any of them.
Examples
Input
3 6 2
1 0 1
2 0 2 0 0 2
Output
3
1 2 3
Input
3 1 2
0 0 0
1
Output
-1
Input
2 1 2
0 1
0
Output
1
1
Note
In the first example k = 2 and Olya has three cartons with expiry dates 0, 1 and 1 (they expire today, tomorrow and tomorrow), and the shop has 3 cartons with expiry date 0 and 3 cartons with expiry date 2. Olya can buy three cartons, for example, one with the expiry date 0 and two with expiry date 2.
In the second example all three cartons Olya owns expire today and it means she would have to throw packets away regardless of whether she buys an extra one or not.
In the third example Olya would drink k = 2 cartons today (one she alreay has in her fridge and one from the shop) and the remaining one tomorrow.
Submitted Solution:
```
import sys
from collections import defaultdict
consume = 0
fridge = []
shop = []
cartons = []
for (index, line) in enumerate(sys.stdin):
if index == 0:
consume = int(line.split(' ')[2])
if index == 1:
fridge = defaultdict(int)
for x in line.split(' '):
fridge[int(x)] += 1
elif index == 2:
shop = defaultdict(list)
for (index, day) in enumerate(line.split(' ')):
shop[int(day)].append(index + 1)
def more_cartons(day, num):
return shop[day][0:num]
exit_flag = False
for (key, value) in fridge.items():
if value > consume:
exit_flag = True
break
elif value < consume:
cartons += more_cartons(key, consume - value)
if not exit_flag:
for (key, value) in shop.items():
if key not in fridge:
cartons += more_cartons(key, consume)
if exit_flag:
print(-1)
else:
print(len(cartons))
print(' '.join([str(x) for x in cartons]))
```
No
| 8,065 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Olya likes milk very much. She drinks k cartons of milk each day if she has at least k and drinks all of them if she doesn't. But there's an issue β expiration dates. Each carton has a date after which you can't drink it (you still can drink it exactly at the date written on the carton). Due to this, if Olya's fridge contains a carton past its expiry date, she throws it away.
Olya hates throwing out cartons, so when she drinks a carton, she chooses the one which expires the fastest. It's easy to understand that this strategy minimizes the amount of cartons thrown out and lets her avoid it if it's even possible.
<image> Milk. Best before: 20.02.2017.
The main issue Olya has is the one of buying new cartons. Currently, there are n cartons of milk in Olya's fridge, for each one an expiration date is known (how soon does it expire, measured in days). In the shop that Olya visited there are m cartons, and the expiration date is known for each of those cartons as well.
Find the maximum number of cartons Olya can buy so that she wouldn't have to throw away any cartons. Assume that Olya drank no cartons today.
Input
In the first line there are three integers n, m, k (1 β€ n, m β€ 106, 1 β€ k β€ n + m) β the amount of cartons in Olya's fridge, the amount of cartons in the shop and the number of cartons Olya drinks each day.
In the second line there are n integers f1, f2, ..., fn (0 β€ fi β€ 107) β expiration dates of the cartons in Olya's fridge. The expiration date is expressed by the number of days the drinking of this carton can be delayed. For example, a 0 expiration date means it must be drunk today, 1 β no later than tomorrow, etc.
In the third line there are m integers s1, s2, ..., sm (0 β€ si β€ 107) β expiration dates of the cartons in the shop in a similar format.
Output
If there's no way for Olya to drink the cartons she already has in her fridge, print -1.
Otherwise, in the first line print the maximum number x of cartons which Olya can buy so that she wouldn't have to throw a carton away. The next line should contain exactly x integers β the numbers of the cartons that should be bought (cartons are numbered in an order in which they are written in the input, starting with 1). Numbers should not repeat, but can be in arbitrary order. If there are multiple correct answers, print any of them.
Examples
Input
3 6 2
1 0 1
2 0 2 0 0 2
Output
3
1 2 3
Input
3 1 2
0 0 0
1
Output
-1
Input
2 1 2
0 1
0
Output
1
1
Note
In the first example k = 2 and Olya has three cartons with expiry dates 0, 1 and 1 (they expire today, tomorrow and tomorrow), and the shop has 3 cartons with expiry date 0 and 3 cartons with expiry date 2. Olya can buy three cartons, for example, one with the expiry date 0 and two with expiry date 2.
In the second example all three cartons Olya owns expire today and it means she would have to throw packets away regardless of whether she buys an extra one or not.
In the third example Olya would drink k = 2 cartons today (one she alreay has in her fridge and one from the shop) and the remaining one tomorrow.
Submitted Solution:
```
import sys
from collections import defaultdict
consume = 0
fridge = defaultdict(int)
shop = defaultdict(list)
cartons = []
for (index, line) in enumerate(sys.stdin):
if index == 0:
consume = int(line.split(' ')[2])
if index == 1:
if line.rstrip():
for x in line.split(' '):
fridge[int(x)] += 1
elif index == 2:
if line.rstrip():
for (index, day) in enumerate(line.split(' ')):
shop[int(day)].append(index + 1)
def more_cartons(day, num):
return sorted(shop[day])[0:num]
for (key, value) in fridge.items():
if value > consume:
print(-1)
sys.exit(0)
elif value < consume:
cartons += more_cartons(key, consume - value)
for (key, value) in shop.items():
if key not in fridge:
cartons += more_cartons(key, consume)
print(len(cartons))
print(' '.join([str(x) for x in sorted(cartons)]))
```
No
| 8,066 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Tags: constructive algorithms, greedy
Correct Solution:
```
names = [chr(i + 65) + chr(j + 97) for i in range(26) for j in range(26)]
n, m = map(int, input().split())
ans = names[:m - 1]
j = m - 1
k = 0
for i in input().split():
if i == "YES":
ans.append(names[j])
j += 1
else:
ans.append(ans[k])
k += 1
print(" ".join(ans))
```
| 8,067 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Tags: constructive algorithms, greedy
Correct Solution:
```
import string
n, k = list(map(int, input().split()))
conds = list(map(str, input().split()))
names = list()
for i in range(n):
names.append(string.ascii_uppercase[i % 26] + string.ascii_lowercase[i // 26])
for j in range(n - k + 1):
if conds[j] == "YES":
pass
else:
names[j + k - 1] = names[j]
print(*names)
```
| 8,068 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Tags: constructive algorithms, greedy
Correct Solution:
```
import math, sys, itertools
def main():
n,k = map(int, input().split())
lst = input().split()
d = []
it = 0
itd = 0
for i in range(k):
if (it>25):
itd+=1
it = 0
d.append(chr(65+itd)+chr(97+it))
it+=1
ans = []
for i in range(k-1):
ans.append(d.pop())
for i in range(k-1,n):
if lst[i-(k-1)]=="NO":
ans.append(ans[i-(k-1)])
else:
ans.append(d.pop())
d.append(ans[i-(k-1)])
for i in range(n):
print(ans[i], end=' ')
print()
if __name__=="__main__":
main()
```
| 8,069 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Tags: constructive algorithms, greedy
Correct Solution:
```
def ntoname(num):
c = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
l = "abcdefghijklmnopqrstuvwxyz"
na = c[num%26]
num //= 26
while num:
na += l[num%26]
num //= 26
return na
n, k = map(int, input().split())
L = [True if i == 'YES' else False for i in input().split()]
ids = [i for i in range(n)]
for i in range(len(L)):
if not L[i]:
ids[i+k-1] = ids[i]
print(*map(ntoname, ids))
```
| 8,070 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Tags: constructive algorithms, greedy
Correct Solution:
```
names = list("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 Ab Bb Cb Db Eb Fb Gb Hb Ib Jb Kb Lb Mb Nb Ob Pb Qb Rb Sb Tb Ub Vb Wb Xb Gh Rg Df".split())
n, k = map(int, input().split())
A = list(input().split())
find = False
ans = [0] * n
for i in range(n - k + 1):
s = A[i]
if find:
if s == "YES":
c = 0
while (names[c] in ans[i:]):
c += 1
ans[i + k - 1] = names[c]
else:
ans[i + k - 1] = ans[i]
else:
if s == "NO":
ans[i] = names[0]
else:
now = i
for j in range(k):
ans[now] = names[j]
now += 1
find = True
if not find:
for i in range(n - k + 1, n):
ans[i] = names[0]
print(" ".join(ans))
```
| 8,071 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Tags: constructive algorithms, greedy
Correct Solution:
```
#===========Template===============
from io import BytesIO, IOBase
from math import sqrt
import sys,os
from os import path
inpl=lambda:list(map(int,input().split()))
inpm=lambda:map(int,input().split())
inpi=lambda:int(input())
inp=lambda:input()
rev,ra,l=reversed,range,len
P=print
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input(): return sys.stdin.readline().rstrip("\r\n")
def B(n):
return bin(n).replace("0b","")
def factors(n):
arr=[]
for i in ra(2,int(sqrt(n))+1):
if n%i==0:
arr.append(i)
if i*i!=n:
arr.append(int(n/i))
return arr
def dfs(arr,n):
pairs=[[i+1] for i in ra(n)]
vis=[0]*(n+1)
for i in ra(l(arr)):
pairs[arr[i][0]-1].append(arr[i][1])
pairs[arr[i][1]-1].append(arr[i][0])
comp=[]
for i in ra(n):
stack=[pairs[i]]
temp=[]
if vis[stack[-1][0]]==0:
while len(stack)>0:
if vis[stack[-1][0]]==0:
temp.append(stack[-1][0])
vis[stack[-1][0]]=1
s=stack.pop()
for j in s[1:]:
if vis[j]==0:
stack.append(pairs[j-1])
else:
stack.pop()
comp.append(temp)
return comp
#=========I/p O/p ========================================#
from bisect import bisect_left as bl
from bisect import bisect_right as br
import sys,operator,math,operator
from collections import Counter
if(path.exists('input.txt')):
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
import random
#==============To chaliye shuru krte he ====================#
n,k=inpm()
li=input().split()
le=len(li)
arr=[0]*51
c=65
ans=[0]*n
for i in ra(1,27):
arr[i]=chr(c)
c+=1
c=65
for i in ra(27,51):
arr[i]=chr(c)+chr(97)
c+=1
for i in ra(le):
if li[i]=="NO":li[i]=0
else:li[i]=1
if li[0]==0:
ans[0]=1
for i in ra(1,k):
ans[i]=i
else:
for i in ra(k):ans[i]=i+1
for i in ra(1,le):
if li[i]==0:
ans[i+k-1]=ans[i]
else:
for j in ra(1,51):
if j not in ans[i:i+k-1]:
ans[i+k-1]=j
break
for i in ra(n):
P(arr[ans[i]],end=" ")
```
| 8,072 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Tags: constructive algorithms, greedy
Correct Solution:
```
from sys import stdin, stdout
import string
n,k = map(int, stdin.readline().rstrip().split())
YesNoList = stdin.readline().rstrip().split()
nameList = list(string.ascii_uppercase) + ['A'+letter for letter in string.ascii_lowercase]
answerList=[]
nl=0
yn=0
if YesNoList.count('YES')==0:
answerList=list('A'*n)
else:
while YesNoList[yn]=='NO':
answerList.append(nameList[nl])
yn+=1
for _ in range(k):
answerList.append(nameList[nl])
nl+=1
yn+=1
nl-=1
while yn<n-k+1:
if YesNoList[yn]=='YES':
nl+=1
answerList.append(nameList[nl])
else:
answerList.append(answerList[yn])
yn+=1
print(' '.join(answerList))
```
| 8,073 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Tags: constructive algorithms, greedy
Correct Solution:
```
#import time
#startTime = time.time()
MAS = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
def generateName(num):
return MAS[num%8] + MAS[int(num/8)].lower()
n, k = [int(i) for i in input().split()]
mas = [i for i in input().split()]
names = [generateName(i) for i in range(n)]
for i in range(n-k+1):
if mas[i] == 'NO':
names[i+k-1] = names[i]
print(' '.join(names))
#print('----------%s sec----------' % (time.time() - startTime))
```
| 8,074 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
n,k=map(int,input().split())
###########
s=[]
name=['']*n
ptr=0
yesno=[]
for i in range(26):
s.append(str(chr(65+i)))
for i in range(26):
s.append(str(chr(65+i))+'a')
###########
def f(x):
global ptr
global name
for i in range(x,x+k):
if(name[i]==''):
name[i]=s[ptr]
ptr=ptr+1
l=[]
yesno=list(input().split())
#print(yesno)
for i in range(n-k+1):
if(yesno[i]=='YES'):
f(i)
#print(name)
for i in range(n-k+1):
if(yesno[i]=='NO' and i==0):
f(i)
name[i]=name[i+1]
elif(yesno[i]=='NO'):
name[i+k-1]=name[i]
for i in name:
print(i," ",end='')
```
Yes
| 8,075 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
n, k = map(int, input().split())
sld = input().split()
ls = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
names = [str(ls[i // len(ls)]).upper() + ls[i % len(ls)] for i in range(55)]
cur = k
ans = names[:(k - 1)]
for s in sld:
if s == 'NO':
ans.append(ans[-(k - 1)])
else:
ans.append(names[cur])
cur += 1
print(*ans)
```
Yes
| 8,076 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
names = [chr(ord('A') + i) for i in range(26)]
names += ['A' + chr(ord('a') + i) for i in range(26)]
n, k = map(int, input().split())
a = input().split()
for i, a_i in enumerate(a):
if a_i == 'NO':
names[i+k-1] = names[i]
print(' '.join(names[:n]))
```
Yes
| 8,077 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
from collections import Counter
n, k = map(int, input().split())
arr = input().split()
ans = ['a' for _ in range(n)]
a = 'b'
for i in range(n-k+1):
if arr[i] == 'YES':
for j in range(i, i+k):
if ans[j] == 'a':
ans[j] = str(a)
if a == 'z':
a = 'aa'
else:
if len(a) == 1:
a = chr(ord(a)+1)
else:
a = a[0] + chr(ord(a[1])+1)
for i in range(n-k+1):
if arr[i] == 'NO':
c = Counter(ans[i:i+k])
for x in c:
if c[x] >= 2:
break
else:
x = i+k-1
y = i
ans[x] = ans[y]
ans = ['A'+x for x in ans]
print(*ans)
```
Yes
| 8,078 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
name = ["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","Aa","Ba","Ca","Da","Ea","Fa","Ga","Ha","Ia","ja","ka","La","Ma","Na","Oa","Pa","Qa","Ra","Sa","Ta","Ua","Va","Wa","Xa","Ya","Za"]
n,k = map(int,input().split())
a=list(map(str,input().split()))
l = [name[i] for i in range(k-1)]
ans = [name[i] for i in range(k-1)]
j=k-1
o=k-1
for i in range(n-k+1):
l.append(name[o])
o+=1
if a[i]=="YES":
ans.append(name[j])
j+=1
else:
x=l.pop(0)
ans.append(x)
print(*ans)
```
No
| 8,079 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
def numToLet(n):
s = ""
s += chr(((n+1)%26)+65)
n -= n%26
if n > 0:
s += 'A'
return s
s = input().split()
n = int(s[0])
k = int(s[1])
isValid = [False]*(n-k+1)
names = [-1]*n
s = input().split()
for i in range(n-k+1):
isValid[i] = True if s[i] == "YES" else False
if isValid[i]:
for j in range(i, i+k):
if names[j] == -1:
for c in range(50):
if c not in names[:i+k]:
names[j] = c
break
for i in range(n):
if names[i] == -1:
for j in range(i-k, i+k):
if j >= 0 and j < n and names[j] != -1:
names[i] = names[j]
if names[i] == -1:
names[i] = 0
for i in range(len(names)-1):
print(numToLet(names[i]), end = " ")
print(numToLet(names[-1]))
```
No
| 8,080 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
n, k = map(int, input().split())
s = input().split()
d = []
for i in range(26):
for j in range(26):
d.append(chr(i + ord('a')).upper() + chr(j + ord('a')))
ans = ['Zzz'] * n
cnt = 0
for i in range(n - k + 1):
if s[i] == 'YES':
for j in range(k):
ans[i + j] = d[cnt]
cnt += 1
for i in range(n - k + 1):
if s[i] == 'NO':
ans[i] = ans[i + k - 1]
print(" ".join(ans))
```
No
| 8,081 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).
A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.
You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.
You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO".
* The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise).
* The string s2 describes a group of soldiers 2 through k + 1.
* And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n.
Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names β it's allowed to print "Xyzzzdj" or "T" for example.
Find and print any solution. It can be proved that there always exists at least one solution.
Input
The first line of the input contains two integers n and k (2 β€ k β€ n β€ 50) β the number of soldiers and the size of a group respectively.
The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.
Output
Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.
If there are multiple valid solutions, print any of them.
Examples
Input
8 3
NO NO YES YES YES NO
Output
Adam Bob Bob Cpqepqwer Limak Adam Bob Adam
Input
9 8
YES NO
Output
R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc
Input
3 2
NO NO
Output
Na Na Na
Note
In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:
* First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO".
* Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO".
* Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES".
* ...,
* Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".
Submitted Solution:
```
names=['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',
'Aa','Ab','Ac','Ad','Ae','Af','Ag','Ah','Ai','Aj',
'Ak','Al','Am','An','Ao','Ap','Aq','Ar',
'As','At','Au','Av','Aw','Ax']
i=0
n,k=list(map(int,input().split()))
arr=input().split()
ans=[]
if arr[0]=='NO':
ans=names[:k-1]+[names[0]]
i=k
else:
ans=names[:k]
i=k
arr=arr[1:]
k=0
for truth in arr:
k+=1
if truth=="YES":
ans+=[names[i]]
i+=1
else:
ans+=ans[k]
print(' '.join(ans))
```
No
| 8,082 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In his spare time Vladik estimates beauty of the flags.
Every flag could be represented as the matrix n Γ m which consists of positive integers.
Let's define the beauty of the flag as number of components in its matrix. We call component a set of cells with same numbers and between any pair of cells from that set there exists a path through adjacent cells from same component. Here is the example of the partitioning some flag matrix into components:
<image>
But this time he decided to change something in the process. Now he wants to estimate not the entire flag, but some segment. Segment of flag can be described as a submatrix of the flag matrix with opposite corners at (1, l) and (n, r), where conditions 1 β€ l β€ r β€ m are satisfied.
Help Vladik to calculate the beauty for some segments of the given flag.
Input
First line contains three space-separated integers n, m, q (1 β€ n β€ 10, 1 β€ m, q β€ 105) β dimensions of flag matrix and number of segments respectively.
Each of next n lines contains m space-separated integers β description of flag matrix. All elements of flag matrix is positive integers not exceeding 106.
Each of next q lines contains two space-separated integers l, r (1 β€ l β€ r β€ m) β borders of segment which beauty Vladik wants to know.
Output
For each segment print the result on the corresponding line.
Example
Input
4 5 4
1 1 1 1 1
1 2 2 3 3
1 1 1 2 5
4 4 5 5 5
1 5
2 5
1 2
4 5
Output
6
7
3
4
Note
Partitioning on components for every segment from first test case:
<image>
Submitted Solution:
```
#!/usr/bin/python3
import sys
deb = "--debug" in sys.argv
def get_str_deb():
yield list(int(x) for x in "4 5 4".split())
yield list(int(x) for x in "1 1 1 1 1".split())
yield list(int(x) for x in "1 2 2 3 3".split())
yield list(int(x) for x in "1 1 1 2 5".split())
yield list(int(x) for x in "4 4 5 5 5".split())
yield list(int(x) for x in "1 5".split())
yield list(int(x) for x in "2 5".split())
yield list(int(x) for x in "1 2".split())
yield list(int(x) for x in "4 5".split())
if deb:
debi = get_str_deb()
print("DEBUG!!!")
def get_str():
if not deb:
return (int(x) for x in sys.stdin.readline().split())
else:
return next(debi)
def main():
n, m, q = get_str()
matr = [None] * n
for i in range(n):
matr[i] = list(get_str())
for i in range(q):
l, r = get_str()
l = l - 1
r = r - 1
x, y = [l, 0]
regions = 0
"""checked = [[False for i in range(m)] for j in range(n)]
while True:
regions = regions + 1
chain = []
while True:
checked[y][x] = True
if x > l and matr[y][x - 1] == matr[y][x] and not(checked[y][x - 1]):
chain.append((x, y))
x = x - 1
continue
elif x < r and matr[y][x + 1] == matr[y][x] and not(checked[y][x + 1]):
chain.append((x, y))
x = x + 1
continue
elif y > 0 and matr[y - 1][x] == matr[y][x] and not(checked[y - 1][x]):
chain.append((x, y))
y = y - 1
continue
elif y < n - 1 and matr[y + 1][x] == matr[y][x] and not(checked[y + 1][x]):
chain.append((x, y))
y = y + 1
continue
elif len(chain) == 0:
break
x, y = chain.pop()
x = None
y = None
for newx in range(l, r + 1):
for newy in range(n):
if not(checked[newy][newx]):
x = newx
y = newy
stop = True
break
if x is not None:
break
if x is None:
break"""
for x in range(l, r + 1):
for y in range(n):
regions = regions + 1
if y > 0 and matr[y - 1][x] == matr[y][x]:
regions = regions - 1
if x > l and matr[y][x - 1] == matr[y][x]:
regions = regions - 1
print(regions)
if __name__ == "__main__":
main()
```
No
| 8,083 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In his spare time Vladik estimates beauty of the flags.
Every flag could be represented as the matrix n Γ m which consists of positive integers.
Let's define the beauty of the flag as number of components in its matrix. We call component a set of cells with same numbers and between any pair of cells from that set there exists a path through adjacent cells from same component. Here is the example of the partitioning some flag matrix into components:
<image>
But this time he decided to change something in the process. Now he wants to estimate not the entire flag, but some segment. Segment of flag can be described as a submatrix of the flag matrix with opposite corners at (1, l) and (n, r), where conditions 1 β€ l β€ r β€ m are satisfied.
Help Vladik to calculate the beauty for some segments of the given flag.
Input
First line contains three space-separated integers n, m, q (1 β€ n β€ 10, 1 β€ m, q β€ 105) β dimensions of flag matrix and number of segments respectively.
Each of next n lines contains m space-separated integers β description of flag matrix. All elements of flag matrix is positive integers not exceeding 106.
Each of next q lines contains two space-separated integers l, r (1 β€ l β€ r β€ m) β borders of segment which beauty Vladik wants to know.
Output
For each segment print the result on the corresponding line.
Example
Input
4 5 4
1 1 1 1 1
1 2 2 3 3
1 1 1 2 5
4 4 5 5 5
1 5
2 5
1 2
4 5
Output
6
7
3
4
Note
Partitioning on components for every segment from first test case:
<image>
Submitted Solution:
```
print("asdasdasdas")
```
No
| 8,084 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In his spare time Vladik estimates beauty of the flags.
Every flag could be represented as the matrix n Γ m which consists of positive integers.
Let's define the beauty of the flag as number of components in its matrix. We call component a set of cells with same numbers and between any pair of cells from that set there exists a path through adjacent cells from same component. Here is the example of the partitioning some flag matrix into components:
<image>
But this time he decided to change something in the process. Now he wants to estimate not the entire flag, but some segment. Segment of flag can be described as a submatrix of the flag matrix with opposite corners at (1, l) and (n, r), where conditions 1 β€ l β€ r β€ m are satisfied.
Help Vladik to calculate the beauty for some segments of the given flag.
Input
First line contains three space-separated integers n, m, q (1 β€ n β€ 10, 1 β€ m, q β€ 105) β dimensions of flag matrix and number of segments respectively.
Each of next n lines contains m space-separated integers β description of flag matrix. All elements of flag matrix is positive integers not exceeding 106.
Each of next q lines contains two space-separated integers l, r (1 β€ l β€ r β€ m) β borders of segment which beauty Vladik wants to know.
Output
For each segment print the result on the corresponding line.
Example
Input
4 5 4
1 1 1 1 1
1 2 2 3 3
1 1 1 2 5
4 4 5 5 5
1 5
2 5
1 2
4 5
Output
6
7
3
4
Note
Partitioning on components for every segment from first test case:
<image>
Submitted Solution:
```
import sys
data=sys.stdin.read().split("\n")
del data[len(data)-1]
n= int(data[0][0])
for ii in range(n+1, len(data)):
cnt=[]
suffix=0
left=int(data[ii].split(" ")[0])-1
right=int(data[ii].split(" ")[1])-1
array=[i.split(" ") for i in data[1:n+1]]
for line in range(0,n):
lines=array[line]
for number in range(left, right+1):#x==line, y==number
z=0
if (line-1>=0 and array[line-1][number].split("-")[0]==array[line][number]):
z+=1
array[line][number]+="-"+array[line-1][number].split("-")[1]
if (number-1>=left and array[line][number-1].split("-")[0]==array[line][number].split("-")[0]):
z+=1
if (z==2 and
array[line-1][number].split("-")[1] != array[line][number-1].split("-")[1]):
del cnt[0]
for x1 in range(left,right+1):
for y1 in range(n):
if array[y1][x1]==array[line][number]:
array[y1][x1]=array[line][number-1]
elif (z==2 and
array[line-1][number].split("-")[1] == array[line][number-1].split("-")[1]):
continue
else:
array[line][number]+="-"+array[line][number-1].split("-")[1]
if z!=0:
continue
suffix+=1
array[line][number]+="-"+str(suffix)
cnt.append("*")
print (cnt.count("*"))
```
No
| 8,085 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In his spare time Vladik estimates beauty of the flags.
Every flag could be represented as the matrix n Γ m which consists of positive integers.
Let's define the beauty of the flag as number of components in its matrix. We call component a set of cells with same numbers and between any pair of cells from that set there exists a path through adjacent cells from same component. Here is the example of the partitioning some flag matrix into components:
<image>
But this time he decided to change something in the process. Now he wants to estimate not the entire flag, but some segment. Segment of flag can be described as a submatrix of the flag matrix with opposite corners at (1, l) and (n, r), where conditions 1 β€ l β€ r β€ m are satisfied.
Help Vladik to calculate the beauty for some segments of the given flag.
Input
First line contains three space-separated integers n, m, q (1 β€ n β€ 10, 1 β€ m, q β€ 105) β dimensions of flag matrix and number of segments respectively.
Each of next n lines contains m space-separated integers β description of flag matrix. All elements of flag matrix is positive integers not exceeding 106.
Each of next q lines contains two space-separated integers l, r (1 β€ l β€ r β€ m) β borders of segment which beauty Vladik wants to know.
Output
For each segment print the result on the corresponding line.
Example
Input
4 5 4
1 1 1 1 1
1 2 2 3 3
1 1 1 2 5
4 4 5 5 5
1 5
2 5
1 2
4 5
Output
6
7
3
4
Note
Partitioning on components for every segment from first test case:
<image>
Submitted Solution:
```
#!/usr/bin/python3
import sys
def get_str_deb():
yield list(int(x) for x in "4 5 4".split())
yield list(int(x) for x in "1 1 1 1 1".split())
yield list(int(x) for x in "1 2 2 3 3".split())
yield list(int(x) for x in "1 1 1 2 5".split())
yield list(int(x) for x in "4 4 5 5 5".split())
yield list(int(x) for x in "1 5".split())
yield list(int(x) for x in "2 5".split())
yield list(int(x) for x in "1 2".split())
yield list(int(x) for x in "4 5".split())
deb = get_str_deb()
def get_str():
if False:
return (int(x) for x in sys.stdin.readline().split())
else:
return next(deb)
def main():
n, m, q = get_str()
matr = [None] * n
for i in range(n):
matr[i] = list(get_str())
for i in range(q):
l, r = get_str()
l = l - 1
r = r - 1
x, y = [l, 0]
regions = 0
checked = [[False for i in range(m)] for j in range(n)]
while True:
regions = regions + 1
chain = []
while True:
checked[y][x] = True
if x > l and matr[y][x - 1] == matr[y][x] and not(checked[y][x - 1]):
chain.append((x, y))
x = x - 1
continue
elif x < r and matr[y][x + 1] == matr[y][x] and not(checked[y][x + 1]):
chain.append((x, y))
x = x + 1
continue
elif y > 0 and matr[y - 1][x] == matr[y][x] and not(checked[y - 1][x]):
chain.append((x, y))
y = y - 1
continue
elif y < n - 1 and matr[y + 1][x] == matr[y][x] and not(checked[y + 1][x]):
chain.append((x, y))
y = y + 1
continue
elif len(chain) == 0:
break
x, y = chain.pop()
x = None
y = None
for newx in range(l, r + 1):
for newy in range(n):
if not(checked[newy][newx]):
x = newx
y = newy
stop = True
break
if x is not None:
break
if x is None:
break
print(regions)
if __name__ == "__main__":
main()
```
No
| 8,086 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Tags: dp, greedy, implementation
Correct Solution:
```
def main():
s = input()
a = []
g = [elem for elem in "aeiou"]
p = []
for i in range(len(s)):
if (s[i] not in g):
a.append(s[i])
else:
a = []
if len(a) == 3:
if (a[0] != a[1]) or (a[1] != a[2]):
a = [ a[2] ]
p.append(i)
else:
a = [ a[1], a[2] ]
for i in range(len(s)):
if i in p:
print(" ", end='')
print(s[i], end='')
if __name__ == "__main__":
main()
```
| 8,087 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Tags: dp, greedy, implementation
Correct Solution:
```
s = input()
vowels = ('a', 'e', 'u', 'o', 'i')
res = ''
i = 0
while i < len(s) - 2:
if s[i] not in vowels and s[i + 1] not in vowels and s[i + 2] not in vowels and s[i: i + 3] != s[i] * 3:
res += s[i: i + 2] + ' '
i += 2
else:
res += s[i]
i += 1
res += s[i:]
print(res)
```
| 8,088 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Tags: dp, greedy, implementation
Correct Solution:
```
class Solver:
def main(self):
s = input()
ls = len(s)
vowels = 'aeiou'
cnt = 0
breaks = []
same = 0
for i in range(0, ls):
if s[i] in vowels:
cnt = 0
same = 0
elif i > 0 and s[i-1] == s[i]:
same += 1
cnt = cnt
else:
cnt += 1
if same + cnt >= 3 and cnt >= 2:
breaks.append(i)
cnt = 1
same = 0
lbreaks = len(breaks)
current = 0
for i in range(ls):
if current < lbreaks and i == breaks[current]:
print(' ', end='')
current += 1
print(s[i], end='')
print()
Solver().main()
```
| 8,089 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Tags: dp, greedy, implementation
Correct Solution:
```
word = list(input())
ns = 0
onesymbol = ''
onesymbolcount = 0
for i in range(len(word)):
if onesymbol == word[i] and ns == 0:
onesymbolcount += 1
continue
if word[i] in ['a', 'e', 'i', 'o', 'u']:
ns = 0
onesymbolcount = 0
onesymbol = ''
else:
if onesymbol != '':
ns += onesymbolcount
onesymbol = word[i]
onesymbolcount = 1
if ns >= 2:
word[i-1] += ' '
ns = 0
# print(word[i], ns, onesymbol, onesymbolcount)
print("".join(word))
```
| 8,090 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Tags: dp, greedy, implementation
Correct Solution:
```
k = 0
t = y = z = ''
for x in input():
k = 0 if x in 'aeiou' else k + 1
if k > 2 and not (x == y == z):
t += ' '
k = 1
y, z = x, y
t += x
print(t)
```
| 8,091 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Tags: dp, greedy, implementation
Correct Solution:
```
n = input()
l = 0
q = len(n)
sogl = ['q', 'w', 'r', 't', 'y', 'p', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 'z', 'x', 'c', 'v', 'b', 'n', 'm']
for i in range(1, len(n) - 1):
if (((n[i - 1] != n[i + 1]) or ((n[i] != n[i - 1]) and (n[i-1] == n[i + 1]))) and (n[i - 1] in sogl) and (n[i] in sogl) and (n[i + 1] in sogl)):
print (n[l:i + 1:1], end=" ")
l = i + 1
n = n[0:i] + 'a' + n[i + 1:q]
print (n[l:len(n):1])
```
| 8,092 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Tags: dp, greedy, implementation
Correct Solution:
```
s = input()
d = ['a', 'e', 'i', 'o', 'u']
st = []
for i in range(len(s)):
if s[i] in d:
st = []
print(s[i], end="")
continue
st.append(s[i])
if st == [s[i], s[i], s[i]]:
st = st[1:]
print(s[i], end='')
elif len(st) == 3:
st = [s[i]]
print(" " + s[i], end="")
else:
print(s[i], end='')
```
| 8,093 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Tags: dp, greedy, implementation
Correct Solution:
```
s=input()
l='aeiou'
i=2
while(i<len(s)):
if(s[i]!=s[i-1] or s[i]!=s[i-2] or s[i-1]!=s[i-2]) and (s[i] not in l) and (s[i-1] not in l) and (s[i-2] not in l) :
s=s[:i]+" "+s[i:]
i+=2
i+=1
print(s)
```
| 8,094 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Submitted Solution:
```
"""
Author - Satwik Tiwari .
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt,log2
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
#### END ITERATE RECURSION ####
#===============================================================================================
#some shortcuts
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def testcase(t):
for pp in range(t):
solve(pp)
def google(p):
print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def modInverse(b):
g = gcd(b, mod)
if (g != 1):
# print("Inverse doesn't exist")
return -1
else:
# If b and m are relatively prime,
# then modulo inverse is b^(m-2) mode m
return pow(b, mod - 2, mod)
def power(x, y, p) :
y%=(p-1) #not so sure about this. used when y>p-1. if p is prime.
res = 1 # Initialize result
x = x % p # Update x if it is more , than or equal to p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) : # If y is odd, multiply, x with result
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
inf = pow(10,20)
mod = 10**9+7
#===============================================================================================
# code here ;))
vow = {'a','e','i','o','u'}
def chck(a,b,c):
temp = [a,b,c]
if(len(set(temp)) < 2):
return False
# print(temp)
for i in temp:
if(i in vow):
return False
if(i == ' '): return False
return True
def solve(case):
s = list(inp())
ans = []
for i in range(len(s)):
if(s[i] in vow):
ans.append(s[i])
continue
if(i > 1 and chck(s[i],ans[-1],ans[-2])):
ans.append(' ')
ans.append(s[i])
print(''.join(ans))
testcase(1)
# testcase(int(inp()))
```
Yes
| 8,095 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Submitted Solution:
```
a = input()
x =2
while x<len(a):
if a[x]!= 'a' and a[x]!= 'e' and a[x]!= 'i' and a[x]!= 'o' and a[x]!= 'u' and a[x]!= ' ':
if a[x-1]!= 'a' and a[x-1]!= 'e' and a[x-1]!= 'i' and a[x-1]!= 'o' and a[x-1]!= 'u' and a[x-1]!= ' ' and a[x-2]!= 'a' and a[x-2]!= 'e' and a[x-2]!= 'i' and a[x-2]!= 'o' and a[x-2]!= 'u' and a[x-2]!= ' ':
if a[x-2]!=a[x] or a[x]!=a[x-1]:
a = a[0:x]+' '+a[x:]
x+=1
x+=1
print(a)
```
Yes
| 8,096 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Submitted Solution:
```
def sogl(a):
glas = ['u', 'a', 'i', 'e', 'o']
for letter in glas:
if letter == a:
return False
return True
def xor(a,b,c):
j = 0
if a==b:
j+=1
if a==c:
j+=1
if j == 2:
return False
else:
return True
line = input()
let = 0
for i in range(0, len(line)):
#test1=sogl(line[i])
#test2 = let
#test3 = xor(line[i], line[i-1], line[i-2])
if (sogl(line[i])) and (let<2):
let += 1
print(line[i], end='')
elif (sogl(line[i])) and (let==2) and (xor(line[i], line[i-1], line[i-2])):
let = 1
print(' ',end='')
print(line[i], end='')
elif (sogl(line[i])) and (let==2) and not(xor(line[i], line[i-1], line[i-2])):
print(line[i], end='')
else:
let = 0
print(line[i], end='')
```
Yes
| 8,097 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Submitted Solution:
```
s = input()
vows = ['a', 'e', 'u', 'i', 'o']
i = 0
s1 = ''
while i < (len(s)-2):
if s[i] not in vows and s[i+1] not in vows and s[i+2] not in vows:
if s[i] != s[i+1] or s[i+1] != s[i+2]:
s1+=s[i: i+2] + ' '
i+=2
else:
s1+=s[i]
i+=1
else:
s1+=s[i]
i+=1
s1+=s[i:]
print (s1)
```
Yes
| 8,098 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Beroffice text editor has a wide range of features that help working with text. One of the features is an automatic search for typos and suggestions of how to fix them.
Beroffice works only with small English letters (i.e. with 26 letters from a to z). Beroffice thinks that a word is typed with a typo if there are three or more consonants in a row in the word. The only exception is that if the block of consonants has all letters the same, then this block (even if its length is greater than three) is not considered a typo. Formally, a word is typed with a typo if there is a block of not less that three consonants in a row, and there are at least two different letters in this block.
For example:
* the following words have typos: "hellno", "hackcerrs" and "backtothefutttture";
* the following words don't have typos: "helllllooooo", "tobeornottobe" and "oooooo".
When Beroffice editor finds a word with a typo, it inserts as little as possible number of spaces in this word (dividing it into several words) in such a way that each of the resulting words is typed without any typos.
Implement this feature of Beroffice editor. Consider the following letters as the only vowels: 'a', 'e', 'i', 'o' and 'u'. All the other letters are consonants in this problem.
Input
The only line contains a non-empty word consisting of small English letters. The length of the word is between 1 and 3000 letters.
Output
Print the given word without any changes if there are no typos.
If there is at least one typo in the word, insert the minimum number of spaces into the word so that each of the resulting words doesn't have any typos. If there are multiple solutions, print any of them.
Examples
Input
hellno
Output
hell no
Input
abacaba
Output
abacaba
Input
asdfasdf
Output
asd fasd f
Submitted Solution:
```
# ΠΠ°Π΄Π°ΡΠΊΠ° C
# Π³Π»Π°ΡΠ½ΡΠ΅
vowels = 'aeiou'
word = input()
consonants = word[0] not in vowels
duplicates = 0
result = ''
term = word[0]
for p, w in zip(word, word[1:]):
if w not in vowels: consonants += 1
else:
consonants = duplicates = 0
if consonants > 0: duplicates += p==w
if consonants > 2 and duplicates != consonants-1:
result += term + ' ' + w
consonants = duplicates = 0
term = ''
else:
term += w
result += term
if result.startswith(' '): result == result[1:]
print(result)
```
No
| 8,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.