message stringlengths 2 28.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 21 109k | cluster float64 7 7 | __index_level_0__ int64 42 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iahub and his friend Floyd have started painting a wall. Iahub is painting the wall red and Floyd is painting it pink. You can consider the wall being made of a very large number of bricks, numbered 1, 2, 3 and so on.
Iahub has the following scheme of painting: he skips x - 1 consecutive bricks, then he paints the x-th one. That is, he'll paint bricks x, 2·x, 3·x and so on red. Similarly, Floyd skips y - 1 consecutive bricks, then he paints the y-th one. Hence he'll paint bricks y, 2·y, 3·y and so on pink.
After painting the wall all day, the boys observed that some bricks are painted both red and pink. Iahub has a lucky number a and Floyd has a lucky number b. Boys wonder how many bricks numbered no less than a and no greater than b are painted both red and pink. This is exactly your task: compute and print the answer to the question.
Input
The input will have a single line containing four integers in this order: x, y, a, b. (1 ≤ x, y ≤ 1000, 1 ≤ a, b ≤ 2·109, a ≤ b).
Output
Output a single integer — the number of bricks numbered no less than a and no greater than b that are painted both red and pink.
Examples
Input
2 3 6 18
Output
3
Note
Let's look at the bricks from a to b (a = 6, b = 18). The bricks colored in red are numbered 6, 8, 10, 12, 14, 16, 18. The bricks colored in pink are numbered 6, 9, 12, 15, 18. The bricks colored in both red and pink are numbered with 6, 12 and 18.
Submitted Solution:
```
x, y, a, b = [int(n) for n in input().split()]
XY = x*y
count = 0
if a == b:
if a % XY == 0:
count += 1
else:
count = ( (b//XY) - ((a-1)//XY) )
if XY == 1 and a != 1 and a != b and a-b > 1:
count += -1
print(count)
# 1503196049000
``` | instruction | 0 | 75,367 | 7 | 150,734 |
No | output | 1 | 75,367 | 7 | 150,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Iahub and his friend Floyd have started painting a wall. Iahub is painting the wall red and Floyd is painting it pink. You can consider the wall being made of a very large number of bricks, numbered 1, 2, 3 and so on.
Iahub has the following scheme of painting: he skips x - 1 consecutive bricks, then he paints the x-th one. That is, he'll paint bricks x, 2·x, 3·x and so on red. Similarly, Floyd skips y - 1 consecutive bricks, then he paints the y-th one. Hence he'll paint bricks y, 2·y, 3·y and so on pink.
After painting the wall all day, the boys observed that some bricks are painted both red and pink. Iahub has a lucky number a and Floyd has a lucky number b. Boys wonder how many bricks numbered no less than a and no greater than b are painted both red and pink. This is exactly your task: compute and print the answer to the question.
Input
The input will have a single line containing four integers in this order: x, y, a, b. (1 ≤ x, y ≤ 1000, 1 ≤ a, b ≤ 2·109, a ≤ b).
Output
Output a single integer — the number of bricks numbered no less than a and no greater than b that are painted both red and pink.
Examples
Input
2 3 6 18
Output
3
Note
Let's look at the bricks from a to b (a = 6, b = 18). The bricks colored in red are numbered 6, 8, 10, 12, 14, 16, 18. The bricks colored in pink are numbered 6, 9, 12, 15, 18. The bricks colored in both red and pink are numbered with 6, 12 and 18.
Submitted Solution:
```
x, y, a, b = map(int, input().split())
s = 0
k = x*y
f = max(x, y)
m = min(x, y)
#print(m)
for i in range(m, 1, -1):
if x % i == 0 and y % i == 0:
k = k // i
x = x // i
y = y // i
if b % k == 0:
s = 1
print((b - a) // k + s)
``` | instruction | 0 | 75,368 | 7 | 150,736 |
No | output | 1 | 75,368 | 7 | 150,737 |
Provide a correct Python 3 solution for this coding contest problem.
On a clear night, a boy, Campanella looked up at the sky, there were many stars which have different colors such as red, yellow, green, blue, purple, etc. He was watching the stars and just lost track of time. Presently, he wondered,
| <image>
---|---
"There are many stars in the space. What color is the universe if I look up it from outside?"
Until he found the answer to this question, he couldn't sleep. After a moment's thought, he proposed a hypothesis,
"When I observe the stars in the sky, if more than half of the stars have the same color, that is the color of the universe."
He has collected data of stars in the universe after consistently observing them. However, when he try to count the number of star, he was in bed sick with a cold. You decided to help him by developing a program to identify the color of the universe.
You are given an array A. Let |A| be the number of element in A, and let Nm be the number of m in A. For example, if A = {3, 1, 2, 3, 3, 1, 5, 3}, |A| = 8, N3 = 4, N1 = 2, N5 = 1. Your program have to find m such that:
Nm > (|A| / 2 )
If there is no such m, you also have to report the fact. There is no such m for the above example, but for a array A = {5, 2, 5, 3, 4, 5, 5}, 5 is the answer.
Input
There are several test cases. For each test case, in the first line |A| is given. In the next line, there will be |A| integers. The integers are less than 231 and |A| < 1,000,000. The input terminate with a line which contains single 0.
Output
For each test case, output m in a line. If there is no answer, output "NO COLOR" in a line.
Example
Input
8
3 1 2 3 3 1 5 3
7
5 2 5 3 4 5 5
0
Output
NO COLOR
5 | instruction | 0 | 75,823 | 7 | 151,646 |
"Correct Solution:
```
from collections import defaultdict
while True:
n = int(input())
if not n:
break
stars = defaultdict(int)
for s in map(int, input().split()):
stars[s] += 1
half_n = n // 2
for i, s in stars.items():
if s > half_n:
print(i)
break
else:
print('NO COLOR')
``` | output | 1 | 75,823 | 7 | 151,647 |
Provide a correct Python 3 solution for this coding contest problem.
On a clear night, a boy, Campanella looked up at the sky, there were many stars which have different colors such as red, yellow, green, blue, purple, etc. He was watching the stars and just lost track of time. Presently, he wondered,
| <image>
---|---
"There are many stars in the space. What color is the universe if I look up it from outside?"
Until he found the answer to this question, he couldn't sleep. After a moment's thought, he proposed a hypothesis,
"When I observe the stars in the sky, if more than half of the stars have the same color, that is the color of the universe."
He has collected data of stars in the universe after consistently observing them. However, when he try to count the number of star, he was in bed sick with a cold. You decided to help him by developing a program to identify the color of the universe.
You are given an array A. Let |A| be the number of element in A, and let Nm be the number of m in A. For example, if A = {3, 1, 2, 3, 3, 1, 5, 3}, |A| = 8, N3 = 4, N1 = 2, N5 = 1. Your program have to find m such that:
Nm > (|A| / 2 )
If there is no such m, you also have to report the fact. There is no such m for the above example, but for a array A = {5, 2, 5, 3, 4, 5, 5}, 5 is the answer.
Input
There are several test cases. For each test case, in the first line |A| is given. In the next line, there will be |A| integers. The integers are less than 231 and |A| < 1,000,000. The input terminate with a line which contains single 0.
Output
For each test case, output m in a line. If there is no answer, output "NO COLOR" in a line.
Example
Input
8
3 1 2 3 3 1 5 3
7
5 2 5 3 4 5 5
0
Output
NO COLOR
5 | instruction | 0 | 75,824 | 7 | 151,648 |
"Correct Solution:
```
while True:
N = int(input())
if N == 0:
break
A = list(map(int, input().split()))
A.sort()
m = 0
flag = True
for i in range(N):
m += 1
if i == N - 1 or A[i] != A[i + 1]:
if 2 * m > N:
print(A[i])
flag = False
break
m = 0
if flag:
print("NO COLOR")
``` | output | 1 | 75,824 | 7 | 151,649 |
Provide a correct Python 3 solution for this coding contest problem.
On a clear night, a boy, Campanella looked up at the sky, there were many stars which have different colors such as red, yellow, green, blue, purple, etc. He was watching the stars and just lost track of time. Presently, he wondered,
| <image>
---|---
"There are many stars in the space. What color is the universe if I look up it from outside?"
Until he found the answer to this question, he couldn't sleep. After a moment's thought, he proposed a hypothesis,
"When I observe the stars in the sky, if more than half of the stars have the same color, that is the color of the universe."
He has collected data of stars in the universe after consistently observing them. However, when he try to count the number of star, he was in bed sick with a cold. You decided to help him by developing a program to identify the color of the universe.
You are given an array A. Let |A| be the number of element in A, and let Nm be the number of m in A. For example, if A = {3, 1, 2, 3, 3, 1, 5, 3}, |A| = 8, N3 = 4, N1 = 2, N5 = 1. Your program have to find m such that:
Nm > (|A| / 2 )
If there is no such m, you also have to report the fact. There is no such m for the above example, but for a array A = {5, 2, 5, 3, 4, 5, 5}, 5 is the answer.
Input
There are several test cases. For each test case, in the first line |A| is given. In the next line, there will be |A| integers. The integers are less than 231 and |A| < 1,000,000. The input terminate with a line which contains single 0.
Output
For each test case, output m in a line. If there is no answer, output "NO COLOR" in a line.
Example
Input
8
3 1 2 3 3 1 5 3
7
5 2 5 3 4 5 5
0
Output
NO COLOR
5 | instruction | 0 | 75,825 | 7 | 151,650 |
"Correct Solution:
```
while 1:
nums = int(input())
if nums != 0:
d = {}
stars = list(map(int,input().split()))
for x in stars:
if x not in d:
d[x] = 1
else:
d[x] += 1
key = list(d.keys())
val = list(d.values())
m = int(max(val))
if m > nums/2:
res = key[val.index(m)]
print(res)
else:
print("NO COLOR")
else:break
``` | output | 1 | 75,825 | 7 | 151,651 |
Provide a correct Python 3 solution for this coding contest problem.
On a clear night, a boy, Campanella looked up at the sky, there were many stars which have different colors such as red, yellow, green, blue, purple, etc. He was watching the stars and just lost track of time. Presently, he wondered,
| <image>
---|---
"There are many stars in the space. What color is the universe if I look up it from outside?"
Until he found the answer to this question, he couldn't sleep. After a moment's thought, he proposed a hypothesis,
"When I observe the stars in the sky, if more than half of the stars have the same color, that is the color of the universe."
He has collected data of stars in the universe after consistently observing them. However, when he try to count the number of star, he was in bed sick with a cold. You decided to help him by developing a program to identify the color of the universe.
You are given an array A. Let |A| be the number of element in A, and let Nm be the number of m in A. For example, if A = {3, 1, 2, 3, 3, 1, 5, 3}, |A| = 8, N3 = 4, N1 = 2, N5 = 1. Your program have to find m such that:
Nm > (|A| / 2 )
If there is no such m, you also have to report the fact. There is no such m for the above example, but for a array A = {5, 2, 5, 3, 4, 5, 5}, 5 is the answer.
Input
There are several test cases. For each test case, in the first line |A| is given. In the next line, there will be |A| integers. The integers are less than 231 and |A| < 1,000,000. The input terminate with a line which contains single 0.
Output
For each test case, output m in a line. If there is no answer, output "NO COLOR" in a line.
Example
Input
8
3 1 2 3 3 1 5 3
7
5 2 5 3 4 5 5
0
Output
NO COLOR
5 | instruction | 0 | 75,826 | 7 | 151,652 |
"Correct Solution:
```
while True:
num=int(input())
if num==0:
break
stars=sorted(input().split())
if stars.count(stars[num//2]) > num/2 :
print(stars[num//2])
else:
print("NO COLOR")
``` | output | 1 | 75,826 | 7 | 151,653 |
Provide a correct Python 3 solution for this coding contest problem.
On a clear night, a boy, Campanella looked up at the sky, there were many stars which have different colors such as red, yellow, green, blue, purple, etc. He was watching the stars and just lost track of time. Presently, he wondered,
| <image>
---|---
"There are many stars in the space. What color is the universe if I look up it from outside?"
Until he found the answer to this question, he couldn't sleep. After a moment's thought, he proposed a hypothesis,
"When I observe the stars in the sky, if more than half of the stars have the same color, that is the color of the universe."
He has collected data of stars in the universe after consistently observing them. However, when he try to count the number of star, he was in bed sick with a cold. You decided to help him by developing a program to identify the color of the universe.
You are given an array A. Let |A| be the number of element in A, and let Nm be the number of m in A. For example, if A = {3, 1, 2, 3, 3, 1, 5, 3}, |A| = 8, N3 = 4, N1 = 2, N5 = 1. Your program have to find m such that:
Nm > (|A| / 2 )
If there is no such m, you also have to report the fact. There is no such m for the above example, but for a array A = {5, 2, 5, 3, 4, 5, 5}, 5 is the answer.
Input
There are several test cases. For each test case, in the first line |A| is given. In the next line, there will be |A| integers. The integers are less than 231 and |A| < 1,000,000. The input terminate with a line which contains single 0.
Output
For each test case, output m in a line. If there is no answer, output "NO COLOR" in a line.
Example
Input
8
3 1 2 3 3 1 5 3
7
5 2 5 3 4 5 5
0
Output
NO COLOR
5 | instruction | 0 | 75,827 | 7 | 151,654 |
"Correct Solution:
```
while 1:
n=int(input())
if n==0:break
s=sorted(input().split())
print(s[n//2] if s.count(s[n//2])>n/2 else 'NO COLOR')
``` | output | 1 | 75,827 | 7 | 151,655 |
Provide a correct Python 3 solution for this coding contest problem.
On a clear night, a boy, Campanella looked up at the sky, there were many stars which have different colors such as red, yellow, green, blue, purple, etc. He was watching the stars and just lost track of time. Presently, he wondered,
| <image>
---|---
"There are many stars in the space. What color is the universe if I look up it from outside?"
Until he found the answer to this question, he couldn't sleep. After a moment's thought, he proposed a hypothesis,
"When I observe the stars in the sky, if more than half of the stars have the same color, that is the color of the universe."
He has collected data of stars in the universe after consistently observing them. However, when he try to count the number of star, he was in bed sick with a cold. You decided to help him by developing a program to identify the color of the universe.
You are given an array A. Let |A| be the number of element in A, and let Nm be the number of m in A. For example, if A = {3, 1, 2, 3, 3, 1, 5, 3}, |A| = 8, N3 = 4, N1 = 2, N5 = 1. Your program have to find m such that:
Nm > (|A| / 2 )
If there is no such m, you also have to report the fact. There is no such m for the above example, but for a array A = {5, 2, 5, 3, 4, 5, 5}, 5 is the answer.
Input
There are several test cases. For each test case, in the first line |A| is given. In the next line, there will be |A| integers. The integers are less than 231 and |A| < 1,000,000. The input terminate with a line which contains single 0.
Output
For each test case, output m in a line. If there is no answer, output "NO COLOR" in a line.
Example
Input
8
3 1 2 3 3 1 5 3
7
5 2 5 3 4 5 5
0
Output
NO COLOR
5 | instruction | 0 | 75,828 | 7 | 151,656 |
"Correct Solution:
```
# AOJ 1008: What Color Is The Universe?
# Python3 2018.7.4 bal4u
import sys
from sys import stdin
input = stdin.readline
from collections import Counter
while True:
n = int(input())
if n == 0: break
a = tuple(map(int, input().split()))
x, w = Counter(a).most_common()[0]
print(x if w>(n>>1) else "NO COLOR")
``` | output | 1 | 75,828 | 7 | 151,657 |
Provide a correct Python 3 solution for this coding contest problem.
On a clear night, a boy, Campanella looked up at the sky, there were many stars which have different colors such as red, yellow, green, blue, purple, etc. He was watching the stars and just lost track of time. Presently, he wondered,
| <image>
---|---
"There are many stars in the space. What color is the universe if I look up it from outside?"
Until he found the answer to this question, he couldn't sleep. After a moment's thought, he proposed a hypothesis,
"When I observe the stars in the sky, if more than half of the stars have the same color, that is the color of the universe."
He has collected data of stars in the universe after consistently observing them. However, when he try to count the number of star, he was in bed sick with a cold. You decided to help him by developing a program to identify the color of the universe.
You are given an array A. Let |A| be the number of element in A, and let Nm be the number of m in A. For example, if A = {3, 1, 2, 3, 3, 1, 5, 3}, |A| = 8, N3 = 4, N1 = 2, N5 = 1. Your program have to find m such that:
Nm > (|A| / 2 )
If there is no such m, you also have to report the fact. There is no such m for the above example, but for a array A = {5, 2, 5, 3, 4, 5, 5}, 5 is the answer.
Input
There are several test cases. For each test case, in the first line |A| is given. In the next line, there will be |A| integers. The integers are less than 231 and |A| < 1,000,000. The input terminate with a line which contains single 0.
Output
For each test case, output m in a line. If there is no answer, output "NO COLOR" in a line.
Example
Input
8
3 1 2 3 3 1 5 3
7
5 2 5 3 4 5 5
0
Output
NO COLOR
5 | instruction | 0 | 75,829 | 7 | 151,658 |
"Correct Solution:
```
from collections import Counter
while 1:
N = int(input())
if N == 0:
break
ct = Counter(map(int, input().split()))
(a, b), *c = ct.most_common()
if b*2 > N:
print(a)
else:
print("NO COLOR")
``` | output | 1 | 75,829 | 7 | 151,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On a clear night, a boy, Campanella looked up at the sky, there were many stars which have different colors such as red, yellow, green, blue, purple, etc. He was watching the stars and just lost track of time. Presently, he wondered,
| <image>
---|---
"There are many stars in the space. What color is the universe if I look up it from outside?"
Until he found the answer to this question, he couldn't sleep. After a moment's thought, he proposed a hypothesis,
"When I observe the stars in the sky, if more than half of the stars have the same color, that is the color of the universe."
He has collected data of stars in the universe after consistently observing them. However, when he try to count the number of star, he was in bed sick with a cold. You decided to help him by developing a program to identify the color of the universe.
You are given an array A. Let |A| be the number of element in A, and let Nm be the number of m in A. For example, if A = {3, 1, 2, 3, 3, 1, 5, 3}, |A| = 8, N3 = 4, N1 = 2, N5 = 1. Your program have to find m such that:
Nm > (|A| / 2 )
If there is no such m, you also have to report the fact. There is no such m for the above example, but for a array A = {5, 2, 5, 3, 4, 5, 5}, 5 is the answer.
Input
There are several test cases. For each test case, in the first line |A| is given. In the next line, there will be |A| integers. The integers are less than 231 and |A| < 1,000,000. The input terminate with a line which contains single 0.
Output
For each test case, output m in a line. If there is no answer, output "NO COLOR" in a line.
Example
Input
8
3 1 2 3 3 1 5 3
7
5 2 5 3 4 5 5
0
Output
NO COLOR
5
Submitted Solution:
```
import sys
def count(i,data):
res = 0
for x in data:
if(x == i):
res += 1
return res
def print_color(size,data):
data = sorted(data)
for i in data:
if(count(i,data) > int(size / 2)):
print(i)
return
print("NO COLOR")
l = []
for i in sys.stdin:
l.append(i)
for i in range(0,len(l),2):
if(isinstance(l[i],str) == True):
continue
l[i] = int(l[i])
if(i < len(l) - 1):
l[i+1] = l[i+1].split()
for j in range(0,len(l[i+1])):
l[i+1][j] = int(l[i+1][j])
for i in range(0,len(l),2):
if(l[i] != 0):
print_color(l[i],l[i+1])
``` | instruction | 0 | 75,830 | 7 | 151,660 |
No | output | 1 | 75,830 | 7 | 151,661 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On a clear night, a boy, Campanella looked up at the sky, there were many stars which have different colors such as red, yellow, green, blue, purple, etc. He was watching the stars and just lost track of time. Presently, he wondered,
| <image>
---|---
"There are many stars in the space. What color is the universe if I look up it from outside?"
Until he found the answer to this question, he couldn't sleep. After a moment's thought, he proposed a hypothesis,
"When I observe the stars in the sky, if more than half of the stars have the same color, that is the color of the universe."
He has collected data of stars in the universe after consistently observing them. However, when he try to count the number of star, he was in bed sick with a cold. You decided to help him by developing a program to identify the color of the universe.
You are given an array A. Let |A| be the number of element in A, and let Nm be the number of m in A. For example, if A = {3, 1, 2, 3, 3, 1, 5, 3}, |A| = 8, N3 = 4, N1 = 2, N5 = 1. Your program have to find m such that:
Nm > (|A| / 2 )
If there is no such m, you also have to report the fact. There is no such m for the above example, but for a array A = {5, 2, 5, 3, 4, 5, 5}, 5 is the answer.
Input
There are several test cases. For each test case, in the first line |A| is given. In the next line, there will be |A| integers. The integers are less than 231 and |A| < 1,000,000. The input terminate with a line which contains single 0.
Output
For each test case, output m in a line. If there is no answer, output "NO COLOR" in a line.
Example
Input
8
3 1 2 3 3 1 5 3
7
5 2 5 3 4 5 5
0
Output
NO COLOR
5
Submitted Solution:
```
while 1:
size_a=int(input())
if size_a==0:
break
a = list(map(int,input().split()))
check = []
cond=0
for i in range(size_a):
if a[i] in check:
pass
elif a.count(a[i]) > int(size_a/2):
print(a[i])
cond=1
break
else:
check.append(a[i])
if cond==0:
print('NO COLOR')
``` | instruction | 0 | 75,831 | 7 | 151,662 |
No | output | 1 | 75,831 | 7 | 151,663 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On a clear night, a boy, Campanella looked up at the sky, there were many stars which have different colors such as red, yellow, green, blue, purple, etc. He was watching the stars and just lost track of time. Presently, he wondered,
| <image>
---|---
"There are many stars in the space. What color is the universe if I look up it from outside?"
Until he found the answer to this question, he couldn't sleep. After a moment's thought, he proposed a hypothesis,
"When I observe the stars in the sky, if more than half of the stars have the same color, that is the color of the universe."
He has collected data of stars in the universe after consistently observing them. However, when he try to count the number of star, he was in bed sick with a cold. You decided to help him by developing a program to identify the color of the universe.
You are given an array A. Let |A| be the number of element in A, and let Nm be the number of m in A. For example, if A = {3, 1, 2, 3, 3, 1, 5, 3}, |A| = 8, N3 = 4, N1 = 2, N5 = 1. Your program have to find m such that:
Nm > (|A| / 2 )
If there is no such m, you also have to report the fact. There is no such m for the above example, but for a array A = {5, 2, 5, 3, 4, 5, 5}, 5 is the answer.
Input
There are several test cases. For each test case, in the first line |A| is given. In the next line, there will be |A| integers. The integers are less than 231 and |A| < 1,000,000. The input terminate with a line which contains single 0.
Output
For each test case, output m in a line. If there is no answer, output "NO COLOR" in a line.
Example
Input
8
3 1 2 3 3 1 5 3
7
5 2 5 3 4 5 5
0
Output
NO COLOR
5
Submitted Solution:
```
import sys
def count(i,data):
res = 0
for x in data:
if(x == i):
res += 1
return res
def print_color(size,data):
data = sorted(data)
for i in data:
if(count(i,data) > int(size / 2)):
print(i)
return
print("NO COLOR")
l = []
for i in sys.stdin:
l.append(i)
for i in range(0,len(l),2):
l[i] = int(l[i])
if(i < len(l) - 1):
l[i+1] = l[i+1].split()
for j in range(0,len(l[i+1])):
l[i+1][j] = int(l[i+1][j])
for i in range(0,len(l),2):
if(l[i] != 0):
print_color(l[i],l[i+1])
``` | instruction | 0 | 75,832 | 7 | 151,664 |
No | output | 1 | 75,832 | 7 | 151,665 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
On a clear night, a boy, Campanella looked up at the sky, there were many stars which have different colors such as red, yellow, green, blue, purple, etc. He was watching the stars and just lost track of time. Presently, he wondered,
| <image>
---|---
"There are many stars in the space. What color is the universe if I look up it from outside?"
Until he found the answer to this question, he couldn't sleep. After a moment's thought, he proposed a hypothesis,
"When I observe the stars in the sky, if more than half of the stars have the same color, that is the color of the universe."
He has collected data of stars in the universe after consistently observing them. However, when he try to count the number of star, he was in bed sick with a cold. You decided to help him by developing a program to identify the color of the universe.
You are given an array A. Let |A| be the number of element in A, and let Nm be the number of m in A. For example, if A = {3, 1, 2, 3, 3, 1, 5, 3}, |A| = 8, N3 = 4, N1 = 2, N5 = 1. Your program have to find m such that:
Nm > (|A| / 2 )
If there is no such m, you also have to report the fact. There is no such m for the above example, but for a array A = {5, 2, 5, 3, 4, 5, 5}, 5 is the answer.
Input
There are several test cases. For each test case, in the first line |A| is given. In the next line, there will be |A| integers. The integers are less than 231 and |A| < 1,000,000. The input terminate with a line which contains single 0.
Output
For each test case, output m in a line. If there is no answer, output "NO COLOR" in a line.
Example
Input
8
3 1 2 3 3 1 5 3
7
5 2 5 3 4 5 5
0
Output
NO COLOR
5
Submitted Solution:
```
while 1:
size_a=int(input())
if size_a==0:
break
a = list(int(input().split()))
check = []
cond=0
for i in range(size_a):
if a[i] in check:
pass
elif a.count(a[i]) > int(size_a/2):
print(a[i])
cond=1
break
else:
check.append(a[i])
if cond==0:
print('NO COLOR')
``` | instruction | 0 | 75,833 | 7 | 151,666 |
No | output | 1 | 75,833 | 7 | 151,667 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No | instruction | 0 | 76,559 | 7 | 153,118 |
"Correct Solution:
```
n,m,k=map(int,input().split())
s=[]
for i in range(n+1):
for j in range(m+1):
s.append((n-i)*(m-j)+i*j)
print("Yes"if k in s else"No")
``` | output | 1 | 76,559 | 7 | 153,119 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No | instruction | 0 | 76,560 | 7 | 153,120 |
"Correct Solution:
```
n,m,k=map(int,input().split())
for i in range(n+1):
for j in range(m+1):
if i*m+j*n-2*i*j==k:
print('Yes')
exit()
print('No')
``` | output | 1 | 76,560 | 7 | 153,121 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No | instruction | 0 | 76,561 | 7 | 153,122 |
"Correct Solution:
```
n,m,k = map(int, input().split())
for i in range(n+1):
for j in range(m+1):
if i*j + (n-i)*(m-j) == k:
print('Yes')
exit()
print('No')
``` | output | 1 | 76,561 | 7 | 153,123 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No | instruction | 0 | 76,562 | 7 | 153,124 |
"Correct Solution:
```
n, m, k = list(map(int, input().split()))
for i in range(n+1):
for j in range(m+1):
if m*i + n*j - 2*(i*j) == k:
print('Yes')
exit()
print('No')
``` | output | 1 | 76,562 | 7 | 153,125 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No | instruction | 0 | 76,563 | 7 | 153,126 |
"Correct Solution:
```
N, M, K = [int(_) for _ in input().split()]
for i in range(N+1):
for j in range(M+1):
if i *(M-j) + j *(N-i) == K:
print("Yes")
exit()
print("No")
``` | output | 1 | 76,563 | 7 | 153,127 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No | instruction | 0 | 76,564 | 7 | 153,128 |
"Correct Solution:
```
N, M, K = map(int, input().split())
for i in range(N):
for j in range(M):
s = i * j + (N-i) * (M-j)
if s == K or N*M - s == K:
print("Yes")
exit()
print("No")
``` | output | 1 | 76,564 | 7 | 153,129 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No | instruction | 0 | 76,565 | 7 | 153,130 |
"Correct Solution:
```
n,m,k=map(int,input().split())
for i in range(n+1):
for j in range(m+1):
if m*i+n*j-2*(i*j)==k:
print("Yes")
exit()
print("No")
``` | output | 1 | 76,565 | 7 | 153,131 |
Provide a correct Python 3 solution for this coding contest problem.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No | instruction | 0 | 76,566 | 7 | 153,132 |
"Correct Solution:
```
N, M, K = map(int, input().split())
for l in range(N+1):
for k in range(M+1):
if (N-l)*(M-k) + l*k == K:
print("Yes")
exit()
print("No")
``` | output | 1 | 76,566 | 7 | 153,133 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No
Submitted Solution:
```
n,m,k = map(int,input().split())
for i in range(n+1):
for j in range(m+1):
if k==i*m+(n-2*i)*j:
print('Yes')
exit()
print('No')
``` | instruction | 0 | 76,567 | 7 | 153,134 |
Yes | output | 1 | 76,567 | 7 | 153,135 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No
Submitted Solution:
```
n,m,k=map(int,input().split())
for i in range(n+1):
for j in range(m+1):
if k==i*j+(n-i)*(m-j):
print('Yes')
exit()
print('No')
``` | instruction | 0 | 76,568 | 7 | 153,136 |
Yes | output | 1 | 76,568 | 7 | 153,137 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No
Submitted Solution:
```
N,M,K=map(int,input().split())
cand=[]
for i in range(N+1):
for j in range(M+1):
cand.append(i*(M-j)+j*(N-i))
if K in cand:
print("Yes")
else:
print("No")
``` | instruction | 0 | 76,569 | 7 | 153,138 |
Yes | output | 1 | 76,569 | 7 | 153,139 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No
Submitted Solution:
```
n,m,k = map(int,input().split())
for i in range(n+1):
for j in range(m+1):
black = n*j + m *i - 2*j*i
if k == black:
print('Yes')
exit(0)
print('No')
``` | instruction | 0 | 76,570 | 7 | 153,140 |
Yes | output | 1 | 76,570 | 7 | 153,141 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No
Submitted Solution:
```
N, M, K = map(int, input().split())
for n in range(N + 1):
for m in range(M + 1):
if n * N + m * M - n * m * 2 == K:
print('Yes')
exit()
print('No')
``` | instruction | 0 | 76,571 | 7 | 153,142 |
No | output | 1 | 76,571 | 7 | 153,143 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No
Submitted Solution:
```
# python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline
H, W, K = map(int, input().split())
if K % W == 0:
print("Yes")
exit()
else:
for h in range(H//2):
w = (K-W*h)/(H-2*h)
if int(w) == w and 0 <= w <= W:
print("Yes")
exit()
print("No")
``` | instruction | 0 | 76,572 | 7 | 153,144 |
No | output | 1 | 76,572 | 7 | 153,145 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No
Submitted Solution:
```
N,M,K = [int(i) for i in input().split()]
ans = 'No'
for j in range(N+1):
for k in range(M+1):
if j * (M - 2) + k * (N - 2) == K:
ans = 'Yes'
print(ans)
``` | instruction | 0 | 76,573 | 7 | 153,146 |
No | output | 1 | 76,573 | 7 | 153,147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a grid with N rows and M columns of squares. Initially, all the squares are white.
There is a button attached to each row and each column. When a button attached to a row is pressed, the colors of all the squares in that row are inverted; that is, white squares become black and vice versa. When a button attached to a column is pressed, the colors of all the squares in that column are inverted.
Takahashi can freely press the buttons any number of times. Determine whether he can have exactly K black squares in the grid.
Constraints
* 1 \leq N,M \leq 1000
* 0 \leq K \leq NM
Input
Input is given from Standard Input in the following format:
N M K
Output
If Takahashi can have exactly K black squares in the grid, print `Yes`; otherwise, print `No`.
Examples
Input
2 2 2
Output
Yes
Input
2 2 1
Output
No
Input
3 5 8
Output
Yes
Input
7 9 20
Output
No
Submitted Solution:
```
#!/usr/bin/env python3
def main():
n, m, k = map(int, input().split())
ans = 'No'
for i in range(n):
for j in range(m):
if n - i + m - j == k:
ans = 'Yes'
print(ans)
if __name__ == "__main__":
main()
``` | instruction | 0 | 76,574 | 7 | 153,148 |
No | output | 1 | 76,574 | 7 | 153,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
DZY loves colors, and he enjoys painting.
On a colorful day, DZY gets a colorful ribbon, which consists of n units (they are numbered from 1 to n from left to right). The color of the i-th unit of the ribbon is i at first. It is colorful enough, but we still consider that the colorfulness of each unit is 0 at first.
DZY loves painting, we know. He takes up a paintbrush with color x and uses it to draw a line on the ribbon. In such a case some contiguous units are painted. Imagine that the color of unit i currently is y. When it is painted by this paintbrush, the color of the unit becomes x, and the colorfulness of the unit increases by |x - y|.
DZY wants to perform m operations, each operation can be one of the following:
1. Paint all the units with numbers between l and r (both inclusive) with color x.
2. Ask the sum of colorfulness of the units between l and r (both inclusive).
Can you help DZY?
Input
The first line contains two space-separated integers n, m (1 ≤ n, m ≤ 105).
Each of the next m lines begins with a integer type (1 ≤ type ≤ 2), which represents the type of this operation.
If type = 1, there will be 3 more integers l, r, x (1 ≤ l ≤ r ≤ n; 1 ≤ x ≤ 108) in this line, describing an operation 1.
If type = 2, there will be 2 more integers l, r (1 ≤ l ≤ r ≤ n) in this line, describing an operation 2.
Output
For each operation 2, print a line containing the answer — sum of colorfulness.
Examples
Input
3 3
1 1 2 4
1 2 3 5
2 1 3
Output
8
Input
3 4
1 1 3 4
2 1 1
2 2 2
2 3 3
Output
3
2
1
Input
10 6
1 1 5 3
1 2 7 9
1 10 10 11
1 3 8 12
1 1 10 3
2 1 10
Output
129
Note
In the first sample, the color of each unit is initially [1, 2, 3], and the colorfulness is [0, 0, 0].
After the first operation, colors become [4, 4, 3], colorfulness become [3, 2, 0].
After the second operation, colors become [4, 5, 5], colorfulness become [3, 3, 2].
So the answer to the only operation of type 2 is 8.
Submitted Solution:
```
numbers = input().split(' ')
queries = [input().split(' ') for i in range(int(numbers[1]))]
def result(size, queries):
sequence = [0] * int(size)
results = list()
for query in queries:
if query[0] == '1':
for i in range(int(query[1]) - 1, int(query[2])):
sequence[i] = int(query[3]) - i - 1
else:
results.append(sum(sequence[int(query[1]) - 1:int(query[2])]))
return results
for result in result(numbers[0], queries):
print(result)
``` | instruction | 0 | 77,084 | 7 | 154,168 |
No | output | 1 | 77,084 | 7 | 154,169 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work. | instruction | 0 | 77,135 | 7 | 154,270 |
Tags: combinatorics, math
Correct Solution:
```
'''
##======================================================================================================================================##
## _____ _ _ _ _____ _ _ _ _ _____ _____ ____ ___ ____ ___ ##
## | / \ | \ / | | | | |\ | | | | | | | | \ | | | ##
## |_____ / \ | \/ | |_____ | | | \ | | __ --- |_____ |____| | | | |___ |___| ##
## | / \ | | | | | | \ | | | | | | | | | | \ ##
## _____| / \ | | _____| \ __ / | \| |_____| _____| | | |___/ |____ | \ ##
##======================================================================================================================================##
------------------------------Samsung_Spider------------------------------
'''
n = float(input())
if n <= 4:
print("0")
elif n % 2 != 0:
print("0")
else:
n = ((n / 2) - 2) / 2
if n % 1 == 0.5:
n += 0.5
print(int(n))
``` | output | 1 | 77,135 | 7 | 154,271 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work. | instruction | 0 | 77,136 | 7 | 154,272 |
Tags: combinatorics, math
Correct Solution:
```
n = int(input())
p = n // 2
if (n % 2 == 1):
print(0)
else:
if (n % 4 == 0):
print((p-1)//2)
else:
print(p//2)
``` | output | 1 | 77,136 | 7 | 154,273 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work. | instruction | 0 | 77,137 | 7 | 154,274 |
Tags: combinatorics, math
Correct Solution:
```
n=int(input());print(0if(n&1)else(n//2-1)>>1)
``` | output | 1 | 77,137 | 7 | 154,275 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work. | instruction | 0 | 77,138 | 7 | 154,276 |
Tags: combinatorics, math
Correct Solution:
```
n = int(input())
print(0 if n % 2 != 0 else n // 4 - (n % 4 == 0))
``` | output | 1 | 77,138 | 7 | 154,277 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work. | instruction | 0 | 77,139 | 7 | 154,278 |
Tags: combinatorics, math
Correct Solution:
```
import math
n=int(input())
if(n%2!=0):
print(0)
else:
a=math.ceil(n/4)
print(a-1)
``` | output | 1 | 77,139 | 7 | 154,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work. | instruction | 0 | 77,140 | 7 | 154,280 |
Tags: combinatorics, math
Correct Solution:
```
n = int(input())
if n&1 == 1:
print(0)
elif n&3 == 0:
print((n>>2)-1)
else:
print(n>>2)
``` | output | 1 | 77,140 | 7 | 154,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work. | instruction | 0 | 77,141 | 7 | 154,282 |
Tags: combinatorics, math
Correct Solution:
```
def main():
n = int(input())
if n % 2 == 1:
print(0)
else:
print(((n // 2) - 1) // 2)
main()
``` | output | 1 | 77,141 | 7 | 154,283 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Pasha has a wooden stick of some positive integer length n. He wants to perform exactly three cuts to get four parts of the stick. Each part must have some positive integer length and the sum of these lengths will obviously be n.
Pasha likes rectangles but hates squares, so he wonders, how many ways are there to split a stick into four parts so that it's possible to form a rectangle using these parts, but is impossible to form a square.
Your task is to help Pasha and count the number of such ways. Two ways to cut the stick are considered distinct if there exists some integer x, such that the number of parts of length x in the first way differ from the number of parts of length x in the second way.
Input
The first line of the input contains a positive integer n (1 ≤ n ≤ 2·109) — the length of Pasha's stick.
Output
The output should contain a single integer — the number of ways to split Pasha's stick into four parts of positive integer length so that it's possible to make a rectangle by connecting the ends of these parts, but is impossible to form a square.
Examples
Input
6
Output
1
Input
20
Output
4
Note
There is only one way to divide the stick in the first sample {1, 1, 2, 2}.
Four ways to divide the stick in the second sample are {1, 1, 9, 9}, {2, 2, 8, 8}, {3, 3, 7, 7} and {4, 4, 6, 6}. Note that {5, 5, 5, 5} doesn't work. | instruction | 0 | 77,142 | 7 | 154,284 |
Tags: combinatorics, math
Correct Solution:
```
from math import *
def main():
n=int(input())
if n%2!=0:
print(0)
else:
ans=ceil((n/4)-1)
print(ans)
main()
``` | output | 1 | 77,142 | 7 | 154,285 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Steve Rogers is fascinated with new vibranium shields S.H.I.E.L.D gave him. They're all uncolored. There are n shields in total, the i-th shield is located at point (xi, yi) of the coordinate plane. It's possible that two or more shields share the same location.
Steve wants to paint all these shields. He paints each shield in either red or blue. Painting a shield in red costs r dollars while painting it in blue costs b dollars.
Additionally, there are m constraints Steve wants to be satisfied. The i-th constraint is provided by three integers ti, li and di:
* If ti = 1, then the absolute difference between the number of red and blue shields on line x = li should not exceed di.
* If ti = 2, then the absolute difference between the number of red and blue shields on line y = li should not exceed di.
Steve gave you the task of finding the painting that satisfies all the condition and the total cost is minimum.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 100 000) — the number of shields and the number of constraints respectively.
The second line contains two integers r and b (1 ≤ r, b ≤ 109).
The next n lines contain the shields coordinates. The i-th of these lines contains two integers xi and yi (1 ≤ xi, yi ≤ 109).
The next m lines contain the constrains. The j-th of these lines contains three integers tj, lj and dj (1 ≤ tj ≤ 2, 1 ≤ lj ≤ 109, 0 ≤ dj ≤ n).
Output
If satisfying all the constraints is impossible print -1 in first and only line of the output.
Otherwise, print the minimum total cost in the first line of output. In the second line print a string of length n consisting of letters 'r' and 'b' only. The i-th character should be 'r' if the i-th shield should be painted red in the optimal answer and 'b' if it should be painted blue. The cost of painting shields in these colors should be equal the minimum cost you printed on the first line.
If there exist more than one optimal solution, print any of them.
Examples
Input
5 6
8 3
2 10
1 5
9 10
9 10
2 8
1 9 1
1 2 1
2 10 3
2 10 2
1 1 1
2 5 2
Output
25
rbrbb
Input
4 4
7 3
10 3
9 8
10 3
2 8
2 8 0
2 8 0
1 2 0
1 9 0
Output
-1
Submitted Solution:
```
from queue import Queue
def main():
def Dinic(capacities, SOURCE, SINK):
levels = get_level_graph(capacities, SOURCE, SINK)
while SINK in levels:
while (find_path(capacities, levels, SOURCE, SINK)):
pass
levels = get_level_graph(capacities, SOURCE, SINK)
def get_level_graph(capacities, SOURCE, SINK):
q = Queue()
q.put(SOURCE)
levels = {}
levels[SOURCE] = 0
while not q.empty():
current = q.get()
for neighbour in capacities[current]:
if neighbour not in levels:
if capacities[current][neighbour] > 0:
q.put(neighbour)
levels[neighbour] = levels[current] + 1
return levels
def find_path(capacities, levels, SOURCE, SINK):
stack = [SOURCE]
parents = {}
parents[SOURCE] = None
while len(stack) != 0:
current = stack.pop()
if current == SINK:
break
for neighbour in capacities[current]:
if neighbour not in parents:
if capacities[current][neighbour] > 0 and levels[neighbour] > levels[current]:
stack.append(neighbour)
parents[neighbour] = current
if SINK not in parents:
return False
else:
current = SINK
path = [current]
while (current != SOURCE):
current = parents[current]
path.append(current)
path = path[::-1]
min_cap = min([capacities[path[i]][path[i + 1]] for i in range(0, len(path) - 1)])
for i in range(0, len(path) - 1):
capacities[path[i]][path[i + 1]] -= min_cap
capacities[path[i + 1]][path[i]] += min_cap
return True
n, m = map(int, input().split())
r, b = map(int, input().split())
import sys
from collections import defaultdict
graph = defaultdict(lambda: defaultdict(int))
count = defaultdict(int)
edges = []
for e in range(n):
u, v = map(int, input().split())
"""
if n==100000:
continue
"""
graph[u][-v] += 1
graph[-v][u] = 0
count[u] += 1
count[-v] += 1
edges.append((u, -v))
constraint = defaultdict(lambda: 10 ** 6)
for c in range(m):
t, l, d = map(int, input().split())
if t == 1:
constraint[l] = min(d, constraint[l])
else:
constraint[-l] = min(d, constraint[-l])
if n==100000:
return
S = 10 ** 10
T = 10 ** 10 + 1
# we put the lower bound and upper bounds on the edges linked to S and T
nodes = list(graph.keys())
for u in nodes:
c = count[u]
d = constraint[u]
if u > 0:
if c % 2 == 0:
graph[S][u] = (max(0, int(c / 2) - int(d / 2)), int((c + 1) / 2) + int(d / 2))
else:
if d == 0:
print(-1)
sys.exit()
else:
graph[S][u] = (max(0, int(c / 2) - int((d - 1) / 2)), int((c + 1) / 2) + int((d - 1) / 2))
else:
if c % 2 == 0:
graph[u][T] = (max(0, int(c / 2) - int(d / 2)), int((c + 1) / 2) + int(d / 2))
else:
if d == 0:
print(-1)
sys.exit()
else:
graph[u][T] = (max(0, int(c / 2) - int((d - 1) / 2)), int((c + 1) / 2) + int((d - 1) / 2))
# We get an admissible flow
# Transform the graph by removing the lower ( we compute the demands for each node )
demands = defaultdict(int)
for u in graph:
for v in graph[u]:
if u == S or v == T:
demands[u] += graph[u][v][0]
demands[v] -= graph[u][v][0]
graph[u][v] = graph[u][v][1] - graph[u][v][0]
# We use the demand to create edges from S2, and toward T2
S2 = 10 ** 10 + 2
T2 = 10 ** 10 + 3
nodes = list(graph.keys())
for u in nodes:
if demands[u] < 0:
graph[S2][u] = abs(demands[u])
else:
graph[u][T2] = demands[u]
# Infinite edge from T to S
graph[T][S] = 10 ** 9
# Compute MAX FLOW on this transformed graph (to find an admissible flow in the initial graph)
Dinic(graph, S2, T2)
# We check that there is an admissible flow (by looking at whether or not the edges of S2 and T2 are saturated)
for v in graph[S2]:
cap = graph[S2][v]
if cap > 0:
print(-1)
sys.exit()
# Remove node S2 and T2 as well as the infinite edge between T and S
# Equivalently we remove the edges by setting the capacity of the edges to 0.
for u in graph:
for v in graph[u]:
if u == S2 or v == T2:
graph[u][v] = 0
graph[v][u] = 0
Dinic(graph, S, T)
solution = []
cheapest = None
expensive = None
if r > b:
cheapest = ("b", b)
expensive = ("r", r)
else:
cheapest = ("r", r)
expensive = ("b", b)
cost = 0
for edge in edges:
u, v = edge
if graph[u][v] > 0:
solution.append(expensive[0])
graph[u][v] -= 1
cost += expensive[1]
else:
solution.append(cheapest[0])
cost += cheapest[1]
print(cost)
print("".join(solution))
main()
``` | instruction | 0 | 77,185 | 7 | 154,370 |
No | output | 1 | 77,185 | 7 | 154,371 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Steve Rogers is fascinated with new vibranium shields S.H.I.E.L.D gave him. They're all uncolored. There are n shields in total, the i-th shield is located at point (xi, yi) of the coordinate plane. It's possible that two or more shields share the same location.
Steve wants to paint all these shields. He paints each shield in either red or blue. Painting a shield in red costs r dollars while painting it in blue costs b dollars.
Additionally, there are m constraints Steve wants to be satisfied. The i-th constraint is provided by three integers ti, li and di:
* If ti = 1, then the absolute difference between the number of red and blue shields on line x = li should not exceed di.
* If ti = 2, then the absolute difference between the number of red and blue shields on line y = li should not exceed di.
Steve gave you the task of finding the painting that satisfies all the condition and the total cost is minimum.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 100 000) — the number of shields and the number of constraints respectively.
The second line contains two integers r and b (1 ≤ r, b ≤ 109).
The next n lines contain the shields coordinates. The i-th of these lines contains two integers xi and yi (1 ≤ xi, yi ≤ 109).
The next m lines contain the constrains. The j-th of these lines contains three integers tj, lj and dj (1 ≤ tj ≤ 2, 1 ≤ lj ≤ 109, 0 ≤ dj ≤ n).
Output
If satisfying all the constraints is impossible print -1 in first and only line of the output.
Otherwise, print the minimum total cost in the first line of output. In the second line print a string of length n consisting of letters 'r' and 'b' only. The i-th character should be 'r' if the i-th shield should be painted red in the optimal answer and 'b' if it should be painted blue. The cost of painting shields in these colors should be equal the minimum cost you printed on the first line.
If there exist more than one optimal solution, print any of them.
Examples
Input
5 6
8 3
2 10
1 5
9 10
9 10
2 8
1 9 1
1 2 1
2 10 3
2 10 2
1 1 1
2 5 2
Output
25
rbrbb
Input
4 4
7 3
10 3
9 8
10 3
2 8
2 8 0
2 8 0
1 2 0
1 9 0
Output
-1
Submitted Solution:
```
from queue import Queue
n = None
def main():
def Dinic(capacities, SOURCE, SINK):
levels = get_level_graph(capacities, SOURCE, SINK)
count = 0
while SINK in levels:
while (find_path(capacities, levels, SOURCE, SINK)):
count += 1
if n==100000 and count==10:
print("Heya")
return
levels = get_level_graph(capacities, SOURCE, SINK)
def get_level_graph(capacities, SOURCE, SINK):
q = Queue()
q.put(SOURCE)
levels = {}
levels[SOURCE] = 0
while not q.empty():
current = q.get()
for neighbour in capacities[current]:
if neighbour not in levels:
if capacities[current][neighbour] > 0:
q.put(neighbour)
levels[neighbour] = levels[current] + 1
return levels
def find_path(capacities, levels, SOURCE, SINK):
stack = [SOURCE]
parents = {}
parents[SOURCE] = None
while len(stack) != 0:
current = stack.pop()
if current == SINK:
break
for neighbour in capacities[current]:
if neighbour not in parents:
if capacities[current][neighbour] > 0 and levels[neighbour] > levels[current]:
stack.append(neighbour)
parents[neighbour] = current
if SINK not in parents:
return False
else:
current = SINK
path = [current]
while (current != SOURCE):
current = parents[current]
path.append(current)
path = path[::-1]
min_cap = min([capacities[path[i]][path[i + 1]] for i in range(0, len(path) - 1)])
for i in range(0, len(path) - 1):
capacities[path[i]][path[i + 1]] -= min_cap
capacities[path[i + 1]][path[i]] += min_cap
return True
global n
n, m = map(int, input().split())
r, b = map(int, input().split())
import sys
from collections import defaultdict
graph = defaultdict(lambda: defaultdict(int))
count = defaultdict(int)
edges = []
for e in range(n):
u, v = map(int, input().split())
"""
if n==100000:
continue
"""
graph[u][-v] += 1
graph[-v][u] = 0
count[u] += 1
count[-v] += 1
edges.append((u, -v))
constraint = defaultdict(lambda: 10 ** 6)
for c in range(m):
t, l, d = map(int, input().split())
if t == 1:
constraint[l] = min(d, constraint[l])
else:
constraint[-l] = min(d, constraint[-l])
S = 10 ** 10
T = 10 ** 10 + 1
# we put the lower bound and upper bounds on the edges linked to S and T
nodes = list(graph.keys())
for u in nodes:
c = count[u]
d = constraint[u]
if u > 0:
if c % 2 == 0:
graph[S][u] = (max(0, int(c / 2) - int(d / 2)), int((c + 1) / 2) + int(d / 2))
else:
if d == 0:
print(-1)
sys.exit()
else:
graph[S][u] = (max(0, int(c / 2) - int((d - 1) / 2)), int((c + 1) / 2) + int((d - 1) / 2))
else:
if c % 2 == 0:
graph[u][T] = (max(0, int(c / 2) - int(d / 2)), int((c + 1) / 2) + int(d / 2))
else:
if d == 0:
print(-1)
sys.exit()
else:
graph[u][T] = (max(0, int(c / 2) - int((d - 1) / 2)), int((c + 1) / 2) + int((d - 1) / 2))
# We get an admissible flow
# Transform the graph by removing the lower ( we compute the demands for each node )
demands = defaultdict(int)
for u in graph:
for v in graph[u]:
if u == S or v == T:
demands[u] += graph[u][v][0]
demands[v] -= graph[u][v][0]
graph[u][v] = graph[u][v][1] - graph[u][v][0]
# We use the demand to create edges from S2, and toward T2
S2 = 10 ** 10 + 2
T2 = 10 ** 10 + 3
nodes = list(graph.keys())
for u in nodes:
if demands[u] < 0:
graph[S2][u] = abs(demands[u])
else:
graph[u][T2] = demands[u]
# Infinite edge from T to S
graph[T][S] = 10 ** 9
# Compute MAX FLOW on this transformed graph (to find an admissible flow in the initial graph)
Dinic(graph, S2, T2)
if n==100000:
return
# We check that there is an admissible flow (by looking at whether or not the edges of S2 and T2 are saturated)
for v in graph[S2]:
cap = graph[S2][v]
if cap > 0:
print(-1)
sys.exit()
# Remove node S2 and T2 as well as the infinite edge between T and S
# Equivalently we remove the edges by setting the capacity of the edges to 0.
for u in graph:
for v in graph[u]:
if u == S2 or v == T2:
graph[u][v] = 0
graph[v][u] = 0
Dinic(graph, S, T)
solution = []
cheapest = None
expensive = None
if r > b:
cheapest = ("b", b)
expensive = ("r", r)
else:
cheapest = ("r", r)
expensive = ("b", b)
cost = 0
for edge in edges:
u, v = edge
if graph[u][v] > 0:
solution.append(expensive[0])
graph[u][v] -= 1
cost += expensive[1]
else:
solution.append(cheapest[0])
cost += cheapest[1]
print(cost)
print("".join(solution))
main()
``` | instruction | 0 | 77,186 | 7 | 154,372 |
No | output | 1 | 77,186 | 7 | 154,373 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Steve Rogers is fascinated with new vibranium shields S.H.I.E.L.D gave him. They're all uncolored. There are n shields in total, the i-th shield is located at point (xi, yi) of the coordinate plane. It's possible that two or more shields share the same location.
Steve wants to paint all these shields. He paints each shield in either red or blue. Painting a shield in red costs r dollars while painting it in blue costs b dollars.
Additionally, there are m constraints Steve wants to be satisfied. The i-th constraint is provided by three integers ti, li and di:
* If ti = 1, then the absolute difference between the number of red and blue shields on line x = li should not exceed di.
* If ti = 2, then the absolute difference between the number of red and blue shields on line y = li should not exceed di.
Steve gave you the task of finding the painting that satisfies all the condition and the total cost is minimum.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 100 000) — the number of shields and the number of constraints respectively.
The second line contains two integers r and b (1 ≤ r, b ≤ 109).
The next n lines contain the shields coordinates. The i-th of these lines contains two integers xi and yi (1 ≤ xi, yi ≤ 109).
The next m lines contain the constrains. The j-th of these lines contains three integers tj, lj and dj (1 ≤ tj ≤ 2, 1 ≤ lj ≤ 109, 0 ≤ dj ≤ n).
Output
If satisfying all the constraints is impossible print -1 in first and only line of the output.
Otherwise, print the minimum total cost in the first line of output. In the second line print a string of length n consisting of letters 'r' and 'b' only. The i-th character should be 'r' if the i-th shield should be painted red in the optimal answer and 'b' if it should be painted blue. The cost of painting shields in these colors should be equal the minimum cost you printed on the first line.
If there exist more than one optimal solution, print any of them.
Examples
Input
5 6
8 3
2 10
1 5
9 10
9 10
2 8
1 9 1
1 2 1
2 10 3
2 10 2
1 1 1
2 5 2
Output
25
rbrbb
Input
4 4
7 3
10 3
9 8
10 3
2 8
2 8 0
2 8 0
1 2 0
1 9 0
Output
-1
Submitted Solution:
```
from queue import Queue
n = None
def main():
def Dinic(capacities, SOURCE, SINK):
levels = get_level_graph(capacities, SOURCE, SINK)
count = 0
while SINK in levels:
while (find_path(capacities, levels, SOURCE, SINK)):
count += 1
if n==100000 and count==100:
print("Heya")
return
levels = get_level_graph(capacities, SOURCE, SINK)
def get_level_graph(capacities, SOURCE, SINK):
q = Queue()
q.put(SOURCE)
levels = {}
levels[SOURCE] = 0
while not q.empty():
current = q.get()
for neighbour in capacities[current]:
if neighbour not in levels:
if capacities[current][neighbour] > 0:
q.put(neighbour)
levels[neighbour] = levels[current] + 1
return levels
def find_path(capacities, levels, SOURCE, SINK):
stack = [SOURCE]
parents = {}
parents[SOURCE] = None
while len(stack) != 0:
current = stack.pop()
if current == SINK:
break
for neighbour in capacities[current]:
if neighbour not in parents:
if capacities[current][neighbour] > 0 and levels[neighbour] > levels[current]:
stack.append(neighbour)
parents[neighbour] = current
if SINK not in parents:
return False
else:
current = SINK
path = [current]
while (current != SOURCE):
current = parents[current]
path.append(current)
path = path[::-1]
min_cap = min([capacities[path[i]][path[i + 1]] for i in range(0, len(path) - 1)])
for i in range(0, len(path) - 1):
capacities[path[i]][path[i + 1]] -= min_cap
capacities[path[i + 1]][path[i]] += min_cap
return True
global n
n, m = map(int, input().split())
r, b = map(int, input().split())
import sys
from collections import defaultdict
graph = defaultdict(lambda: defaultdict(int))
count = defaultdict(int)
edges = []
for e in range(n):
u, v = map(int, input().split())
"""
if n==100000:
continue
"""
graph[u][-v] += 1
graph[-v][u] = 0
count[u] += 1
count[-v] += 1
edges.append((u, -v))
constraint = defaultdict(lambda: 10 ** 6)
for c in range(m):
t, l, d = map(int, input().split())
if t == 1:
constraint[l] = min(d, constraint[l])
else:
constraint[-l] = min(d, constraint[-l])
S = 10 ** 10
T = 10 ** 10 + 1
# we put the lower bound and upper bounds on the edges linked to S and T
nodes = list(graph.keys())
for u in nodes:
c = count[u]
d = constraint[u]
if u > 0:
if c % 2 == 0:
graph[S][u] = (max(0, int(c / 2) - int(d / 2)), int((c + 1) / 2) + int(d / 2))
else:
if d == 0:
print(-1)
sys.exit()
else:
graph[S][u] = (max(0, int(c / 2) - int((d - 1) / 2)), int((c + 1) / 2) + int((d - 1) / 2))
else:
if c % 2 == 0:
graph[u][T] = (max(0, int(c / 2) - int(d / 2)), int((c + 1) / 2) + int(d / 2))
else:
if d == 0:
print(-1)
sys.exit()
else:
graph[u][T] = (max(0, int(c / 2) - int((d - 1) / 2)), int((c + 1) / 2) + int((d - 1) / 2))
# We get an admissible flow
# Transform the graph by removing the lower ( we compute the demands for each node )
demands = defaultdict(int)
for u in graph:
for v in graph[u]:
if u == S or v == T:
demands[u] += graph[u][v][0]
demands[v] -= graph[u][v][0]
graph[u][v] = graph[u][v][1] - graph[u][v][0]
# We use the demand to create edges from S2, and toward T2
S2 = 10 ** 10 + 2
T2 = 10 ** 10 + 3
nodes = list(graph.keys())
for u in nodes:
if demands[u] < 0:
graph[S2][u] = abs(demands[u])
else:
graph[u][T2] = demands[u]
# Infinite edge from T to S
graph[T][S] = 10 ** 9
# Compute MAX FLOW on this transformed graph (to find an admissible flow in the initial graph)
Dinic(graph, S2, T2)
if n==100000:
return
# We check that there is an admissible flow (by looking at whether or not the edges of S2 and T2 are saturated)
for v in graph[S2]:
cap = graph[S2][v]
if cap > 0:
print(-1)
sys.exit()
# Remove node S2 and T2 as well as the infinite edge between T and S
# Equivalently we remove the edges by setting the capacity of the edges to 0.
for u in graph:
for v in graph[u]:
if u == S2 or v == T2:
graph[u][v] = 0
graph[v][u] = 0
Dinic(graph, S, T)
solution = []
cheapest = None
expensive = None
if r > b:
cheapest = ("b", b)
expensive = ("r", r)
else:
cheapest = ("r", r)
expensive = ("b", b)
cost = 0
for edge in edges:
u, v = edge
if graph[u][v] > 0:
solution.append(expensive[0])
graph[u][v] -= 1
cost += expensive[1]
else:
solution.append(cheapest[0])
cost += cheapest[1]
print(cost)
print("".join(solution))
main()
``` | instruction | 0 | 77,187 | 7 | 154,374 |
No | output | 1 | 77,187 | 7 | 154,375 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Steve Rogers is fascinated with new vibranium shields S.H.I.E.L.D gave him. They're all uncolored. There are n shields in total, the i-th shield is located at point (xi, yi) of the coordinate plane. It's possible that two or more shields share the same location.
Steve wants to paint all these shields. He paints each shield in either red or blue. Painting a shield in red costs r dollars while painting it in blue costs b dollars.
Additionally, there are m constraints Steve wants to be satisfied. The i-th constraint is provided by three integers ti, li and di:
* If ti = 1, then the absolute difference between the number of red and blue shields on line x = li should not exceed di.
* If ti = 2, then the absolute difference between the number of red and blue shields on line y = li should not exceed di.
Steve gave you the task of finding the painting that satisfies all the condition and the total cost is minimum.
Input
The first line of the input contains two integers n and m (1 ≤ n, m ≤ 100 000) — the number of shields and the number of constraints respectively.
The second line contains two integers r and b (1 ≤ r, b ≤ 109).
The next n lines contain the shields coordinates. The i-th of these lines contains two integers xi and yi (1 ≤ xi, yi ≤ 109).
The next m lines contain the constrains. The j-th of these lines contains three integers tj, lj and dj (1 ≤ tj ≤ 2, 1 ≤ lj ≤ 109, 0 ≤ dj ≤ n).
Output
If satisfying all the constraints is impossible print -1 in first and only line of the output.
Otherwise, print the minimum total cost in the first line of output. In the second line print a string of length n consisting of letters 'r' and 'b' only. The i-th character should be 'r' if the i-th shield should be painted red in the optimal answer and 'b' if it should be painted blue. The cost of painting shields in these colors should be equal the minimum cost you printed on the first line.
If there exist more than one optimal solution, print any of them.
Examples
Input
5 6
8 3
2 10
1 5
9 10
9 10
2 8
1 9 1
1 2 1
2 10 3
2 10 2
1 1 1
2 5 2
Output
25
rbrbb
Input
4 4
7 3
10 3
9 8
10 3
2 8
2 8 0
2 8 0
1 2 0
1 9 0
Output
-1
Submitted Solution:
```
from queue import Queue
n = None
def main():
def Dinic(capacities, SOURCE, SINK):
levels = get_level_graph(capacities, SOURCE, SINK)
count = 0
while SINK in levels:
while (find_path(capacities, levels, SOURCE, SINK)):
count += 1
if n==100000 and count==2000:
print(count)
print("Heya")
return
levels = get_level_graph(capacities, SOURCE, SINK)
def get_level_graph(capacities, SOURCE, SINK):
q = Queue()
q.put(SOURCE)
levels = {}
levels[SOURCE] = 0
while not q.empty():
current = q.get()
for neighbour in capacities[current]:
if neighbour not in levels:
if capacities[current][neighbour] > 0:
q.put(neighbour)
levels[neighbour] = levels[current] + 1
return levels
def find_path(capacities, levels, SOURCE, SINK):
stack = [SOURCE]
parents = {}
parents[SOURCE] = None
while len(stack) != 0:
current = stack.pop()
if current == SINK:
break
for neighbour in capacities[current]:
if neighbour not in parents:
if capacities[current][neighbour] > 0 and levels[neighbour] > levels[current]:
stack.append(neighbour)
parents[neighbour] = current
if SINK not in parents:
return False
else:
current = SINK
path = [current]
while (current != SOURCE):
current = parents[current]
path.append(current)
path = path[::-1]
min_cap = min([capacities[path[i]][path[i + 1]] for i in range(0, len(path) - 1)])
for i in range(0, len(path) - 1):
capacities[path[i]][path[i + 1]] -= min_cap
capacities[path[i + 1]][path[i]] += min_cap
return True
global n
n, m = map(int, input().split())
r, b = map(int, input().split())
import sys
from collections import defaultdict
graph = defaultdict(lambda: defaultdict(int))
count = defaultdict(int)
edges = []
for e in range(n):
u, v = map(int, input().split())
"""
if n==100000:
continue
"""
graph[u][-v] += 1
graph[-v][u] = 0
count[u] += 1
count[-v] += 1
edges.append((u, -v))
constraint = defaultdict(lambda: 10 ** 6)
for c in range(m):
t, l, d = map(int, input().split())
if t == 1:
constraint[l] = min(d, constraint[l])
else:
constraint[-l] = min(d, constraint[-l])
S = 10 ** 10
T = 10 ** 10 + 1
# we put the lower bound and upper bounds on the edges linked to S and T
nodes = list(graph.keys())
for u in nodes:
c = count[u]
d = constraint[u]
if u > 0:
if c % 2 == 0:
graph[S][u] = (max(0, int(c / 2) - int(d / 2)), int((c + 1) / 2) + int(d / 2))
else:
if d == 0:
print(-1)
sys.exit()
else:
graph[S][u] = (max(0, int(c / 2) - int((d - 1) / 2)), int((c + 1) / 2) + int((d - 1) / 2))
else:
if c % 2 == 0:
graph[u][T] = (max(0, int(c / 2) - int(d / 2)), int((c + 1) / 2) + int(d / 2))
else:
if d == 0:
print(-1)
sys.exit()
else:
graph[u][T] = (max(0, int(c / 2) - int((d - 1) / 2)), int((c + 1) / 2) + int((d - 1) / 2))
# We get an admissible flow
# Transform the graph by removing the lower ( we compute the demands for each node )
demands = defaultdict(int)
for u in graph:
for v in graph[u]:
if u == S or v == T:
demands[u] += graph[u][v][0]
demands[v] -= graph[u][v][0]
graph[u][v] = graph[u][v][1] - graph[u][v][0]
# We use the demand to create edges from S2, and toward T2
S2 = 10 ** 10 + 2
T2 = 10 ** 10 + 3
nodes = list(graph.keys())
for u in nodes:
if demands[u] < 0:
graph[S2][u] = abs(demands[u])
else:
graph[u][T2] = demands[u]
# Infinite edge from T to S
graph[T][S] = 10 ** 9
# Compute MAX FLOW on this transformed graph (to find an admissible flow in the initial graph)
Dinic(graph, S2, T2)
if n==100000:
return
# We check that there is an admissible flow (by looking at whether or not the edges of S2 and T2 are saturated)
for v in graph[S2]:
cap = graph[S2][v]
if cap > 0:
print(-1)
sys.exit()
# Remove node S2 and T2 as well as the infinite edge between T and S
# Equivalently we remove the edges by setting the capacity of the edges to 0.
for u in graph:
for v in graph[u]:
if u == S2 or v == T2:
graph[u][v] = 0
graph[v][u] = 0
Dinic(graph, S, T)
solution = []
cheapest = None
expensive = None
if r > b:
cheapest = ("b", b)
expensive = ("r", r)
else:
cheapest = ("r", r)
expensive = ("b", b)
cost = 0
for edge in edges:
u, v = edge
if graph[u][v] > 0:
solution.append(expensive[0])
graph[u][v] -= 1
cost += expensive[1]
else:
solution.append(cheapest[0])
cost += cheapest[1]
print(cost)
print("".join(solution))
main()
``` | instruction | 0 | 77,188 | 7 | 154,376 |
No | output | 1 | 77,188 | 7 | 154,377 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nadeko's birthday is approaching! As she decorated the room for the party, a long garland of Dianthus-shaped paper pieces was placed on a prominent part of the wall. Brother Koyomi will like it!
Still unsatisfied with the garland, Nadeko decided to polish it again. The garland has n pieces numbered from 1 to n from left to right, and the i-th piece has a colour si, denoted by a lowercase English letter. Nadeko will repaint at most m of the pieces to give each of them an arbitrary new colour (still denoted by a lowercase English letter). After this work, she finds out all subsegments of the garland containing pieces of only colour c — Brother Koyomi's favourite one, and takes the length of the longest among them to be the Koyomity of the garland.
For instance, let's say the garland is represented by "kooomo", and Brother Koyomi's favourite colour is "o". Among all subsegments containing pieces of "o" only, "ooo" is the longest, with a length of 3. Thus the Koyomity of this garland equals 3.
But problem arises as Nadeko is unsure about Brother Koyomi's favourite colour, and has swaying ideas on the amount of work to do. She has q plans on this, each of which can be expressed as a pair of an integer mi and a lowercase letter ci, meanings of which are explained above. You are to find out the maximum Koyomity achievable after repainting the garland according to each plan.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 500) — the length of the garland.
The second line contains n lowercase English letters s1s2... sn as a string — the initial colours of paper pieces on the garland.
The third line contains a positive integer q (1 ≤ q ≤ 200 000) — the number of plans Nadeko has.
The next q lines describe one plan each: the i-th among them contains an integer mi (1 ≤ mi ≤ n) — the maximum amount of pieces to repaint, followed by a space, then by a lowercase English letter ci — Koyomi's possible favourite colour.
Output
Output q lines: for each work plan, output one line containing an integer — the largest Koyomity achievable after repainting the garland according to it.
Examples
Input
6
koyomi
3
1 o
4 o
4 m
Output
3
6
5
Input
15
yamatonadeshiko
10
1 a
2 a
3 a
4 a
5 a
1 b
2 b
3 b
4 b
5 b
Output
3
4
5
7
8
1
2
3
4
5
Input
10
aaaaaaaaaa
2
10 b
10 z
Output
10
10
Note
In the first sample, there are three plans:
* In the first plan, at most 1 piece can be repainted. Repainting the "y" piece to become "o" results in "kooomi", whose Koyomity of 3 is the best achievable;
* In the second plan, at most 4 pieces can be repainted, and "oooooo" results in a Koyomity of 6;
* In the third plan, at most 4 pieces can be repainted, and "mmmmmi" and "kmmmmm" both result in a Koyomity of 5. | instruction | 0 | 77,929 | 7 | 155,858 |
Tags: brute force, dp, strings, two pointers
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
_str = str
str = lambda x=b"": x if type(x) is bytes else _str(x).encode()
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")
input = lambda: sys.stdin.readline().rstrip("\r\n")
for i in range(1):
n=int(input())
s=input()
c=[[0 for j in range(n+1)]for i in range(26)]
for k in range(26):
for i in range(n):
rep=0
for j in range(i,n):
if s[j]!=chr(97+k):
rep+=1
c[k][rep]=max(c[k][rep],j-i+1)
for j in range(1,n+1):
c[k][j]=max(c[k][j],c[k][j-1])
t= int(input())
for i in range(t):
r,d=map(str,input().split())
print(c[ord(d)-97][int(r)])
``` | output | 1 | 77,929 | 7 | 155,859 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nadeko's birthday is approaching! As she decorated the room for the party, a long garland of Dianthus-shaped paper pieces was placed on a prominent part of the wall. Brother Koyomi will like it!
Still unsatisfied with the garland, Nadeko decided to polish it again. The garland has n pieces numbered from 1 to n from left to right, and the i-th piece has a colour si, denoted by a lowercase English letter. Nadeko will repaint at most m of the pieces to give each of them an arbitrary new colour (still denoted by a lowercase English letter). After this work, she finds out all subsegments of the garland containing pieces of only colour c — Brother Koyomi's favourite one, and takes the length of the longest among them to be the Koyomity of the garland.
For instance, let's say the garland is represented by "kooomo", and Brother Koyomi's favourite colour is "o". Among all subsegments containing pieces of "o" only, "ooo" is the longest, with a length of 3. Thus the Koyomity of this garland equals 3.
But problem arises as Nadeko is unsure about Brother Koyomi's favourite colour, and has swaying ideas on the amount of work to do. She has q plans on this, each of which can be expressed as a pair of an integer mi and a lowercase letter ci, meanings of which are explained above. You are to find out the maximum Koyomity achievable after repainting the garland according to each plan.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 500) — the length of the garland.
The second line contains n lowercase English letters s1s2... sn as a string — the initial colours of paper pieces on the garland.
The third line contains a positive integer q (1 ≤ q ≤ 200 000) — the number of plans Nadeko has.
The next q lines describe one plan each: the i-th among them contains an integer mi (1 ≤ mi ≤ n) — the maximum amount of pieces to repaint, followed by a space, then by a lowercase English letter ci — Koyomi's possible favourite colour.
Output
Output q lines: for each work plan, output one line containing an integer — the largest Koyomity achievable after repainting the garland according to it.
Examples
Input
6
koyomi
3
1 o
4 o
4 m
Output
3
6
5
Input
15
yamatonadeshiko
10
1 a
2 a
3 a
4 a
5 a
1 b
2 b
3 b
4 b
5 b
Output
3
4
5
7
8
1
2
3
4
5
Input
10
aaaaaaaaaa
2
10 b
10 z
Output
10
10
Note
In the first sample, there are three plans:
* In the first plan, at most 1 piece can be repainted. Repainting the "y" piece to become "o" results in "kooomi", whose Koyomity of 3 is the best achievable;
* In the second plan, at most 4 pieces can be repainted, and "oooooo" results in a Koyomity of 6;
* In the third plan, at most 4 pieces can be repainted, and "mmmmmi" and "kmmmmm" both result in a Koyomity of 5. | instruction | 0 | 77,930 | 7 | 155,860 |
Tags: brute force, dp, strings, two pointers
Correct Solution:
```
n = int(input())
s = input()
dp = [[-1]*(n+1) for x in range(26)]
for c in range(26):
for l in range(n):
n_c = 0
for r in range(l, n):
if s[r] == chr(ord('a') + c):
n_c += 1
dp[c][r-l+1-n_c] = max(dp[c][r-l+1-n_c], r-l+1)
all_res = []
for i in range(int(input())):
m, c = input().split()
m = int(m)
idx = ord(c) - ord('a')
all_res.append(dp[idx][m] if dp[idx][m] != -1 else n)
print('\n'.join(map(str, all_res)))
``` | output | 1 | 77,930 | 7 | 155,861 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nadeko's birthday is approaching! As she decorated the room for the party, a long garland of Dianthus-shaped paper pieces was placed on a prominent part of the wall. Brother Koyomi will like it!
Still unsatisfied with the garland, Nadeko decided to polish it again. The garland has n pieces numbered from 1 to n from left to right, and the i-th piece has a colour si, denoted by a lowercase English letter. Nadeko will repaint at most m of the pieces to give each of them an arbitrary new colour (still denoted by a lowercase English letter). After this work, she finds out all subsegments of the garland containing pieces of only colour c — Brother Koyomi's favourite one, and takes the length of the longest among them to be the Koyomity of the garland.
For instance, let's say the garland is represented by "kooomo", and Brother Koyomi's favourite colour is "o". Among all subsegments containing pieces of "o" only, "ooo" is the longest, with a length of 3. Thus the Koyomity of this garland equals 3.
But problem arises as Nadeko is unsure about Brother Koyomi's favourite colour, and has swaying ideas on the amount of work to do. She has q plans on this, each of which can be expressed as a pair of an integer mi and a lowercase letter ci, meanings of which are explained above. You are to find out the maximum Koyomity achievable after repainting the garland according to each plan.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 500) — the length of the garland.
The second line contains n lowercase English letters s1s2... sn as a string — the initial colours of paper pieces on the garland.
The third line contains a positive integer q (1 ≤ q ≤ 200 000) — the number of plans Nadeko has.
The next q lines describe one plan each: the i-th among them contains an integer mi (1 ≤ mi ≤ n) — the maximum amount of pieces to repaint, followed by a space, then by a lowercase English letter ci — Koyomi's possible favourite colour.
Output
Output q lines: for each work plan, output one line containing an integer — the largest Koyomity achievable after repainting the garland according to it.
Examples
Input
6
koyomi
3
1 o
4 o
4 m
Output
3
6
5
Input
15
yamatonadeshiko
10
1 a
2 a
3 a
4 a
5 a
1 b
2 b
3 b
4 b
5 b
Output
3
4
5
7
8
1
2
3
4
5
Input
10
aaaaaaaaaa
2
10 b
10 z
Output
10
10
Note
In the first sample, there are three plans:
* In the first plan, at most 1 piece can be repainted. Repainting the "y" piece to become "o" results in "kooomi", whose Koyomity of 3 is the best achievable;
* In the second plan, at most 4 pieces can be repainted, and "oooooo" results in a Koyomity of 6;
* In the third plan, at most 4 pieces can be repainted, and "mmmmmi" and "kmmmmm" both result in a Koyomity of 5. | instruction | 0 | 77,931 | 7 | 155,862 |
Tags: brute force, dp, strings, two pointers
Correct Solution:
```
#------------------------------warmup----------------------------
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")
#-------------------game starts now-----------------------------------------------------
n=int(input())
s=input()
c=[[0 for j in range(n+1)]for i in range(26)]
for k in range(26):
for i in range(n):
rep=0
for j in range(i,n):
if s[j]!=chr(97+k):
rep+=1
c[k][rep]=max(c[k][rep],j-i+1)
for j in range(1,n+1):
c[k][j]=max(c[k][j],c[k][j-1])
t= int(input())
for i in range(t):
r,d=map(str,input().split())
print(c[ord(d)-97][int(r)])
``` | output | 1 | 77,931 | 7 | 155,863 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nadeko's birthday is approaching! As she decorated the room for the party, a long garland of Dianthus-shaped paper pieces was placed on a prominent part of the wall. Brother Koyomi will like it!
Still unsatisfied with the garland, Nadeko decided to polish it again. The garland has n pieces numbered from 1 to n from left to right, and the i-th piece has a colour si, denoted by a lowercase English letter. Nadeko will repaint at most m of the pieces to give each of them an arbitrary new colour (still denoted by a lowercase English letter). After this work, she finds out all subsegments of the garland containing pieces of only colour c — Brother Koyomi's favourite one, and takes the length of the longest among them to be the Koyomity of the garland.
For instance, let's say the garland is represented by "kooomo", and Brother Koyomi's favourite colour is "o". Among all subsegments containing pieces of "o" only, "ooo" is the longest, with a length of 3. Thus the Koyomity of this garland equals 3.
But problem arises as Nadeko is unsure about Brother Koyomi's favourite colour, and has swaying ideas on the amount of work to do. She has q plans on this, each of which can be expressed as a pair of an integer mi and a lowercase letter ci, meanings of which are explained above. You are to find out the maximum Koyomity achievable after repainting the garland according to each plan.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 500) — the length of the garland.
The second line contains n lowercase English letters s1s2... sn as a string — the initial colours of paper pieces on the garland.
The third line contains a positive integer q (1 ≤ q ≤ 200 000) — the number of plans Nadeko has.
The next q lines describe one plan each: the i-th among them contains an integer mi (1 ≤ mi ≤ n) — the maximum amount of pieces to repaint, followed by a space, then by a lowercase English letter ci — Koyomi's possible favourite colour.
Output
Output q lines: for each work plan, output one line containing an integer — the largest Koyomity achievable after repainting the garland according to it.
Examples
Input
6
koyomi
3
1 o
4 o
4 m
Output
3
6
5
Input
15
yamatonadeshiko
10
1 a
2 a
3 a
4 a
5 a
1 b
2 b
3 b
4 b
5 b
Output
3
4
5
7
8
1
2
3
4
5
Input
10
aaaaaaaaaa
2
10 b
10 z
Output
10
10
Note
In the first sample, there are three plans:
* In the first plan, at most 1 piece can be repainted. Repainting the "y" piece to become "o" results in "kooomi", whose Koyomity of 3 is the best achievable;
* In the second plan, at most 4 pieces can be repainted, and "oooooo" results in a Koyomity of 6;
* In the third plan, at most 4 pieces can be repainted, and "mmmmmi" and "kmmmmm" both result in a Koyomity of 5. | instruction | 0 | 77,932 | 7 | 155,864 |
Tags: brute force, dp, strings, two pointers
Correct Solution:
```
from sys import stdin
n=int(stdin.readline())
s=list(stdin.readline())[:-1]
cnt=[[0]*26 for i in range(n+1)]
for j in range(26):
x=chr(j+97)
for i in range(n):
if s[i]==x:
cnt[i+1][j]+=1
for i in range(1,n+1):
cnt[i][j]+=cnt[i-1][j]
d=[[0]*(n+1) for i in range(26)]
for j in range(26):
for r in range(1,n+1):
for l in range(1,r+1):
dx=r-l+1-(cnt[r][j]-cnt[l-1][j])
d[j][dx]=max(d[j][dx],r-l+1)
ans=[[0]*(n+1) for i in range(26)]
for j in range(26):
ans[j][0]=d[j][0]
for i in range(1,n+1):
ans[j][i]=max(ans[j][i-1],d[j][i])
q=int(stdin.readline())
for _ in range(q):
m,c=stdin.readline().split()
m=int(m)
print(ans[ord(c)-ord('a')][m])
``` | output | 1 | 77,932 | 7 | 155,865 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nadeko's birthday is approaching! As she decorated the room for the party, a long garland of Dianthus-shaped paper pieces was placed on a prominent part of the wall. Brother Koyomi will like it!
Still unsatisfied with the garland, Nadeko decided to polish it again. The garland has n pieces numbered from 1 to n from left to right, and the i-th piece has a colour si, denoted by a lowercase English letter. Nadeko will repaint at most m of the pieces to give each of them an arbitrary new colour (still denoted by a lowercase English letter). After this work, she finds out all subsegments of the garland containing pieces of only colour c — Brother Koyomi's favourite one, and takes the length of the longest among them to be the Koyomity of the garland.
For instance, let's say the garland is represented by "kooomo", and Brother Koyomi's favourite colour is "o". Among all subsegments containing pieces of "o" only, "ooo" is the longest, with a length of 3. Thus the Koyomity of this garland equals 3.
But problem arises as Nadeko is unsure about Brother Koyomi's favourite colour, and has swaying ideas on the amount of work to do. She has q plans on this, each of which can be expressed as a pair of an integer mi and a lowercase letter ci, meanings of which are explained above. You are to find out the maximum Koyomity achievable after repainting the garland according to each plan.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 500) — the length of the garland.
The second line contains n lowercase English letters s1s2... sn as a string — the initial colours of paper pieces on the garland.
The third line contains a positive integer q (1 ≤ q ≤ 200 000) — the number of plans Nadeko has.
The next q lines describe one plan each: the i-th among them contains an integer mi (1 ≤ mi ≤ n) — the maximum amount of pieces to repaint, followed by a space, then by a lowercase English letter ci — Koyomi's possible favourite colour.
Output
Output q lines: for each work plan, output one line containing an integer — the largest Koyomity achievable after repainting the garland according to it.
Examples
Input
6
koyomi
3
1 o
4 o
4 m
Output
3
6
5
Input
15
yamatonadeshiko
10
1 a
2 a
3 a
4 a
5 a
1 b
2 b
3 b
4 b
5 b
Output
3
4
5
7
8
1
2
3
4
5
Input
10
aaaaaaaaaa
2
10 b
10 z
Output
10
10
Note
In the first sample, there are three plans:
* In the first plan, at most 1 piece can be repainted. Repainting the "y" piece to become "o" results in "kooomi", whose Koyomity of 3 is the best achievable;
* In the second plan, at most 4 pieces can be repainted, and "oooooo" results in a Koyomity of 6;
* In the third plan, at most 4 pieces can be repainted, and "mmmmmi" and "kmmmmm" both result in a Koyomity of 5. | instruction | 0 | 77,933 | 7 | 155,866 |
Tags: brute force, dp, strings, two pointers
Correct Solution:
```
import sys
n = int(sys.stdin.readline().strip())
s = sys.stdin.readline().strip()
ans = [[-1]*(n+1) for x in range(26)]
for c in range(26):
for l in range(n):
nrOfC = 0
for r in range(l, n):
if s[r] == chr(97 + c):
nrOfC += 1
ans[c][r - l + 1 - nrOfC] = max(ans[c][r - l + 1 -nrOfC], r-l+1)
for i in range(int(sys.stdin.readline().strip())):
m,c = sys.stdin.readline().strip().split()
m = int(m)
print(ans[ord(c) - 97][m] if ans[ord(c) - 97][m] != -1 else n)
``` | output | 1 | 77,933 | 7 | 155,867 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nadeko's birthday is approaching! As she decorated the room for the party, a long garland of Dianthus-shaped paper pieces was placed on a prominent part of the wall. Brother Koyomi will like it!
Still unsatisfied with the garland, Nadeko decided to polish it again. The garland has n pieces numbered from 1 to n from left to right, and the i-th piece has a colour si, denoted by a lowercase English letter. Nadeko will repaint at most m of the pieces to give each of them an arbitrary new colour (still denoted by a lowercase English letter). After this work, she finds out all subsegments of the garland containing pieces of only colour c — Brother Koyomi's favourite one, and takes the length of the longest among them to be the Koyomity of the garland.
For instance, let's say the garland is represented by "kooomo", and Brother Koyomi's favourite colour is "o". Among all subsegments containing pieces of "o" only, "ooo" is the longest, with a length of 3. Thus the Koyomity of this garland equals 3.
But problem arises as Nadeko is unsure about Brother Koyomi's favourite colour, and has swaying ideas on the amount of work to do. She has q plans on this, each of which can be expressed as a pair of an integer mi and a lowercase letter ci, meanings of which are explained above. You are to find out the maximum Koyomity achievable after repainting the garland according to each plan.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 500) — the length of the garland.
The second line contains n lowercase English letters s1s2... sn as a string — the initial colours of paper pieces on the garland.
The third line contains a positive integer q (1 ≤ q ≤ 200 000) — the number of plans Nadeko has.
The next q lines describe one plan each: the i-th among them contains an integer mi (1 ≤ mi ≤ n) — the maximum amount of pieces to repaint, followed by a space, then by a lowercase English letter ci — Koyomi's possible favourite colour.
Output
Output q lines: for each work plan, output one line containing an integer — the largest Koyomity achievable after repainting the garland according to it.
Examples
Input
6
koyomi
3
1 o
4 o
4 m
Output
3
6
5
Input
15
yamatonadeshiko
10
1 a
2 a
3 a
4 a
5 a
1 b
2 b
3 b
4 b
5 b
Output
3
4
5
7
8
1
2
3
4
5
Input
10
aaaaaaaaaa
2
10 b
10 z
Output
10
10
Note
In the first sample, there are three plans:
* In the first plan, at most 1 piece can be repainted. Repainting the "y" piece to become "o" results in "kooomi", whose Koyomity of 3 is the best achievable;
* In the second plan, at most 4 pieces can be repainted, and "oooooo" results in a Koyomity of 6;
* In the third plan, at most 4 pieces can be repainted, and "mmmmmi" and "kmmmmm" both result in a Koyomity of 5. | instruction | 0 | 77,934 | 7 | 155,868 |
Tags: brute force, dp, strings, two pointers
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")
a=int(input())
s=input()
count=[[0 for i in range(len(s)+1)] for i in range(26)]
for i in range(len(s)):
t=ord(s[i])-97
for j in range(26):
if(j==t):
count[j][i+1]=count[j][i]+1
else:
count[j][i+1]=count[j][i]
ans=[]
t1=[0 for i in range(a+1)]
for i in range(26):
ans.append(t1.copy())
f=int(input())
l=0
r=0
for l in range(len(s)):
for r in range(l,len(s)):
for i in range(26):
y=count[i][r+1]-count[i][l]
er=r-l+1-y
ans[i][er]=max(r-l+1,ans[i][er])
for i in range(26):
for j in range(1,len(ans[i])):
ans[i][j]=max(ans[i][j],ans[i][j-1])
for i in range(f):
x,s=map(str,input().split())
print(ans[ord(s)-97][int(x)])
``` | output | 1 | 77,934 | 7 | 155,869 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nadeko's birthday is approaching! As she decorated the room for the party, a long garland of Dianthus-shaped paper pieces was placed on a prominent part of the wall. Brother Koyomi will like it!
Still unsatisfied with the garland, Nadeko decided to polish it again. The garland has n pieces numbered from 1 to n from left to right, and the i-th piece has a colour si, denoted by a lowercase English letter. Nadeko will repaint at most m of the pieces to give each of them an arbitrary new colour (still denoted by a lowercase English letter). After this work, she finds out all subsegments of the garland containing pieces of only colour c — Brother Koyomi's favourite one, and takes the length of the longest among them to be the Koyomity of the garland.
For instance, let's say the garland is represented by "kooomo", and Brother Koyomi's favourite colour is "o". Among all subsegments containing pieces of "o" only, "ooo" is the longest, with a length of 3. Thus the Koyomity of this garland equals 3.
But problem arises as Nadeko is unsure about Brother Koyomi's favourite colour, and has swaying ideas on the amount of work to do. She has q plans on this, each of which can be expressed as a pair of an integer mi and a lowercase letter ci, meanings of which are explained above. You are to find out the maximum Koyomity achievable after repainting the garland according to each plan.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 500) — the length of the garland.
The second line contains n lowercase English letters s1s2... sn as a string — the initial colours of paper pieces on the garland.
The third line contains a positive integer q (1 ≤ q ≤ 200 000) — the number of plans Nadeko has.
The next q lines describe one plan each: the i-th among them contains an integer mi (1 ≤ mi ≤ n) — the maximum amount of pieces to repaint, followed by a space, then by a lowercase English letter ci — Koyomi's possible favourite colour.
Output
Output q lines: for each work plan, output one line containing an integer — the largest Koyomity achievable after repainting the garland according to it.
Examples
Input
6
koyomi
3
1 o
4 o
4 m
Output
3
6
5
Input
15
yamatonadeshiko
10
1 a
2 a
3 a
4 a
5 a
1 b
2 b
3 b
4 b
5 b
Output
3
4
5
7
8
1
2
3
4
5
Input
10
aaaaaaaaaa
2
10 b
10 z
Output
10
10
Note
In the first sample, there are three plans:
* In the first plan, at most 1 piece can be repainted. Repainting the "y" piece to become "o" results in "kooomi", whose Koyomity of 3 is the best achievable;
* In the second plan, at most 4 pieces can be repainted, and "oooooo" results in a Koyomity of 6;
* In the third plan, at most 4 pieces can be repainted, and "mmmmmi" and "kmmmmm" both result in a Koyomity of 5. | instruction | 0 | 77,935 | 7 | 155,870 |
Tags: brute force, dp, strings, two pointers
Correct Solution:
```
import sys
ii = lambda: sys.stdin.readline().strip()
idata = lambda: [int(x) for x in ii().split()]
# Ввод данных
n = int(ii())
s = ii()
# Будем считать, что "сет" - подотрезок, состоящий из одинаковых букв
# Далее создание словаря и внесение в него данных:
slov = {}
# В данном словаре на каждую букву есть два списка, в первом находятся
# числа, которые сообщают нам размеры "сетов", а второй
# список - расстояния между "сетами" (первый и
# последний элементы этого списка - расстояние между началом всей строки и первым
# "сетом" и расстояние между концом всей строки и последним "сетом")
for i in range(97, 97 + 26):
slov[chr(i)] = [[], [1]]
slov[s[0]] = [[1], [0, 0]] # Первый элемент обозначим вне цикла, чтобы позже не маяться с неточностями
for j in range(1, n):
if slov[s[j]][1][-1] == 0: # То есть, если нет расстояния между данной буквой и предыдущим "сетом"
slov[s[j]][0][-1] += 1
else: # Добавление нового "сета"
slov[s[j]][0] += [1]
slov[s[j]][1] += [0]
# Следующий for - увеличение расстояний между "сетами" для всех остальных букв
for i in range(97, 97 + 26):
if chr(i) != s[j]:
slov[chr(i)][1][-1] += 1
# Пошла жара. Здесь обработка планов Надеко
for t in range(int(ii())):
m, c = ii().split()
m = int(m)
a, b = slov[c]
if sum(b) <= m:
print(n)
else:
if not bool(a): # Если нет "сетов" с данной буквой
print(m)
elif len(a) == 1: # Если такой "сет" всего один
print(a[0] + m)
else:
l, r = 0, 0
ans = 0 # Максимальный ответ
summ_a, summ_b = 0, 0
used = 0 # Количество букв, которые мы заменили
b1 = b[::]
b1[0], b1[-1] = 0, 0
count = 0 # Количество "сетов", которые мы используем на данный момент
while r != len(a):
if summ_b + b1[r] <= m:
summ_b += b1[r]
summ_a += a[r]
r += 1
ans = max(ans, m + summ_a)
else:
summ_a -= a[l]
l += 1
summ_b -= b1[l]
print(ans)
``` | output | 1 | 77,935 | 7 | 155,871 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Nadeko's birthday is approaching! As she decorated the room for the party, a long garland of Dianthus-shaped paper pieces was placed on a prominent part of the wall. Brother Koyomi will like it!
Still unsatisfied with the garland, Nadeko decided to polish it again. The garland has n pieces numbered from 1 to n from left to right, and the i-th piece has a colour si, denoted by a lowercase English letter. Nadeko will repaint at most m of the pieces to give each of them an arbitrary new colour (still denoted by a lowercase English letter). After this work, she finds out all subsegments of the garland containing pieces of only colour c — Brother Koyomi's favourite one, and takes the length of the longest among them to be the Koyomity of the garland.
For instance, let's say the garland is represented by "kooomo", and Brother Koyomi's favourite colour is "o". Among all subsegments containing pieces of "o" only, "ooo" is the longest, with a length of 3. Thus the Koyomity of this garland equals 3.
But problem arises as Nadeko is unsure about Brother Koyomi's favourite colour, and has swaying ideas on the amount of work to do. She has q plans on this, each of which can be expressed as a pair of an integer mi and a lowercase letter ci, meanings of which are explained above. You are to find out the maximum Koyomity achievable after repainting the garland according to each plan.
Input
The first line of input contains a positive integer n (1 ≤ n ≤ 1 500) — the length of the garland.
The second line contains n lowercase English letters s1s2... sn as a string — the initial colours of paper pieces on the garland.
The third line contains a positive integer q (1 ≤ q ≤ 200 000) — the number of plans Nadeko has.
The next q lines describe one plan each: the i-th among them contains an integer mi (1 ≤ mi ≤ n) — the maximum amount of pieces to repaint, followed by a space, then by a lowercase English letter ci — Koyomi's possible favourite colour.
Output
Output q lines: for each work plan, output one line containing an integer — the largest Koyomity achievable after repainting the garland according to it.
Examples
Input
6
koyomi
3
1 o
4 o
4 m
Output
3
6
5
Input
15
yamatonadeshiko
10
1 a
2 a
3 a
4 a
5 a
1 b
2 b
3 b
4 b
5 b
Output
3
4
5
7
8
1
2
3
4
5
Input
10
aaaaaaaaaa
2
10 b
10 z
Output
10
10
Note
In the first sample, there are three plans:
* In the first plan, at most 1 piece can be repainted. Repainting the "y" piece to become "o" results in "kooomi", whose Koyomity of 3 is the best achievable;
* In the second plan, at most 4 pieces can be repainted, and "oooooo" results in a Koyomity of 6;
* In the third plan, at most 4 pieces can be repainted, and "mmmmmi" and "kmmmmm" both result in a Koyomity of 5. | instruction | 0 | 77,936 | 7 | 155,872 |
Tags: brute force, dp, strings, two pointers
Correct Solution:
```
""" Python 3 compatibility tools. """
from __future__ import division, print_function
import itertools
import sys
import os
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
input = raw_input
range = xrange
filter = itertools.ifilter
map = itertools.imap
zip = itertools.izip
def is_it_local():
script_dir = str(os.getcwd()).split('/')
username = "dipta007"
return username in script_dir
def READ(fileName):
if is_it_local():
sys.stdin = open(f'./{fileName}', 'r')
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
if not is_it_local():
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
def input1(type=int):
return type(input())
def input2(type=int):
[a, b] = list(map(type, input().split()))
return a, b
def input3(type=int):
[a, b, c] = list(map(type, input().split()))
return a, b, c
def input_array(type=int):
return list(map(type, input().split()))
def input_string():
s = input()
return list(s)
if is_it_local():
def debug(*args):
st = ""
for arg in args:
st += f"{arg} "
print(st)
else:
def debug(*args):
pass
##############################################################
ltr = [[] for _ in range(26)]
memo = {}
def main():
n = input1()
st = input_string()
for l in range(97, 97+26):
ltr[l-97].append(0)
ch = chr(l)
cum = 0
for i in range(n):
if st[i] == ch:
cum += 1
ltr[l-97].append(cum)
q = input1()
for i in range(q):
[m, c] = list(input().split())
m = int(m)
if c in memo and m in memo[c]:
print(memo[c][m])
continue
res = m
low = 1
z = 0
l = ord(c) - 97
for high in range(0, n+1):
tot = high - low + 1
now = ltr[l][high] - ltr[l][low-1]
need = tot - now
debug(high, low, tot, now, need)
while need > m:
low += 1
tot = high - low + 1
now = ltr[l][high] - ltr[l][low-1]
need = tot - now
res = max(res, high - low + 1)
if c not in memo:
memo[c] = {}
memo[c][m] = res
print(res)
pass
if __name__ == '__main__':
# READ('in.txt')
main()
``` | output | 1 | 77,936 | 7 | 155,873 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.