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.
Pasha loves his phone and also putting his hair up... But the hair is now irrelevant.
Pasha has installed a new game to his phone. The goal of the game is following. There is a rectangular field consisting of n row with m pixels in each row. Initially, all the pixels are colored white. In one move, Pasha can choose any pixel and color it black. In particular, he can choose the pixel that is already black, then after the boy's move the pixel does not change, that is, it remains black. Pasha loses the game when a 2 × 2 square consisting of black pixels is formed.
Pasha has made a plan of k moves, according to which he will paint pixels. Each turn in his plan is represented as a pair of numbers i and j, denoting respectively the row and the column of the pixel to be colored on the current move.
Determine whether Pasha loses if he acts in accordance with his plan, and if he does, on what move the 2 × 2 square consisting of black pixels is formed.
Input
The first line of the input contains three integers n, m, k (1 ≤ n, m ≤ 1000, 1 ≤ k ≤ 105) — the number of rows, the number of columns and the number of moves that Pasha is going to perform.
The next k lines contain Pasha's moves in the order he makes them. Each line contains two integers i and j (1 ≤ i ≤ n, 1 ≤ j ≤ m), representing the row number and column number of the pixel that was painted during a move.
Output
If Pasha loses, print the number of the move when the 2 × 2 square consisting of black pixels is formed.
If Pasha doesn't lose, that is, no 2 × 2 square consisting of black pixels is formed during the given k moves, print 0.
Examples
Input
2 2 4
1 1
1 2
2 1
2 2
Output
4
Input
2 3 6
2 3
2 2
1 3
2 2
1 2
1 1
Output
5
Input
5 3 7
2 3
1 2
1 1
4 1
3 1
5 3
3 2
Output
0
Submitted Solution:
```
n,m,k=map(int,input().split())
a=[]
d={}
for i in range(n+1):
a.append([])
for j in range(m+1):
a[i].append(0)
d[(i,j)]=0
def check_lose(a,i,j):
try:
if a[i][j]==1 and a[i+1][j]==1 and a[i][j+1]==1 and a[i+1][j+1]==1:
return True
except:
return False
return False
got_ans=False
for i in range(1,k+1):
x,y=map(int,input().split())
if got_ans:
continue
if d[(x,y)]>0:
continue
d[(x,y)]=1
a[x][y]=1
if check_lose(a,x,y) or check_lose(a,x-1,y) or check_lose(a,x,y-1) or check_lose(a,x-1,y-1):
print(i)
got_ans=True
if not got_ans:
print(0)
``` | instruction | 0 | 17,215 | 7 | 34,430 |
Yes | output | 1 | 17,215 | 7 | 34,431 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha loves his phone and also putting his hair up... But the hair is now irrelevant.
Pasha has installed a new game to his phone. The goal of the game is following. There is a rectangular field consisting of n row with m pixels in each row. Initially, all the pixels are colored white. In one move, Pasha can choose any pixel and color it black. In particular, he can choose the pixel that is already black, then after the boy's move the pixel does not change, that is, it remains black. Pasha loses the game when a 2 × 2 square consisting of black pixels is formed.
Pasha has made a plan of k moves, according to which he will paint pixels. Each turn in his plan is represented as a pair of numbers i and j, denoting respectively the row and the column of the pixel to be colored on the current move.
Determine whether Pasha loses if he acts in accordance with his plan, and if he does, on what move the 2 × 2 square consisting of black pixels is formed.
Input
The first line of the input contains three integers n, m, k (1 ≤ n, m ≤ 1000, 1 ≤ k ≤ 105) — the number of rows, the number of columns and the number of moves that Pasha is going to perform.
The next k lines contain Pasha's moves in the order he makes them. Each line contains two integers i and j (1 ≤ i ≤ n, 1 ≤ j ≤ m), representing the row number and column number of the pixel that was painted during a move.
Output
If Pasha loses, print the number of the move when the 2 × 2 square consisting of black pixels is formed.
If Pasha doesn't lose, that is, no 2 × 2 square consisting of black pixels is formed during the given k moves, print 0.
Examples
Input
2 2 4
1 1
1 2
2 1
2 2
Output
4
Input
2 3 6
2 3
2 2
1 3
2 2
1 2
1 1
Output
5
Input
5 3 7
2 3
1 2
1 1
4 1
3 1
5 3
3 2
Output
0
Submitted Solution:
```
n,m,k=[int(i) for i in input().split()]
l=[(m+2)*[0] for i in range(n+2)]
c=0
def lose(x,y):
if l[x][y+1] and l[x+1][y] and l[x+1][y+1]:
return True
elif l[x][y+1] and l[x-1][y] and l[x-1][y+1]:
return True
if l[x][y-1] and l[x+1][y] and l[x+1][y-1]:
return True
elif l[x][y-1] and l[x-1][y] and l[x-1][y-1]:
return True
else:
return False
for i in range(k):
x,y=map(int,input().split())
l[x][y]=1
if lose(x,y)==1:
print(i+1)
c=1
break
if c==0:
print(0)
``` | instruction | 0 | 17,216 | 7 | 34,432 |
Yes | output | 1 | 17,216 | 7 | 34,433 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha loves his phone and also putting his hair up... But the hair is now irrelevant.
Pasha has installed a new game to his phone. The goal of the game is following. There is a rectangular field consisting of n row with m pixels in each row. Initially, all the pixels are colored white. In one move, Pasha can choose any pixel and color it black. In particular, he can choose the pixel that is already black, then after the boy's move the pixel does not change, that is, it remains black. Pasha loses the game when a 2 × 2 square consisting of black pixels is formed.
Pasha has made a plan of k moves, according to which he will paint pixels. Each turn in his plan is represented as a pair of numbers i and j, denoting respectively the row and the column of the pixel to be colored on the current move.
Determine whether Pasha loses if he acts in accordance with his plan, and if he does, on what move the 2 × 2 square consisting of black pixels is formed.
Input
The first line of the input contains three integers n, m, k (1 ≤ n, m ≤ 1000, 1 ≤ k ≤ 105) — the number of rows, the number of columns and the number of moves that Pasha is going to perform.
The next k lines contain Pasha's moves in the order he makes them. Each line contains two integers i and j (1 ≤ i ≤ n, 1 ≤ j ≤ m), representing the row number and column number of the pixel that was painted during a move.
Output
If Pasha loses, print the number of the move when the 2 × 2 square consisting of black pixels is formed.
If Pasha doesn't lose, that is, no 2 × 2 square consisting of black pixels is formed during the given k moves, print 0.
Examples
Input
2 2 4
1 1
1 2
2 1
2 2
Output
4
Input
2 3 6
2 3
2 2
1 3
2 2
1 2
1 1
Output
5
Input
5 3 7
2 3
1 2
1 1
4 1
3 1
5 3
3 2
Output
0
Submitted Solution:
```
n, m, k = map(int, input().split())
arr = [[0 for _ in range(m)] for _ in range(n)]
for i in range(1,k+1):
a, b = map(int, input().split())
a = a - 1
b = b - 1
arr[a][b] = i
ans = 100000000000
for i in range(n-1):
for j in range(m-1):
if arr[i][j] > 0 and arr[i+1][j] > 0 and arr[i][j+1] > 0 and arr[i+1][j+1] > 0:
maxval = max(arr[i][j], max(arr[i][j+1], max(arr[i+1][j], arr[i+1][j+1])))
ans = min(ans, maxval)
print(ans if ans != 100000000000 else 0)
``` | instruction | 0 | 17,217 | 7 | 34,434 |
No | output | 1 | 17,217 | 7 | 34,435 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha loves his phone and also putting his hair up... But the hair is now irrelevant.
Pasha has installed a new game to his phone. The goal of the game is following. There is a rectangular field consisting of n row with m pixels in each row. Initially, all the pixels are colored white. In one move, Pasha can choose any pixel and color it black. In particular, he can choose the pixel that is already black, then after the boy's move the pixel does not change, that is, it remains black. Pasha loses the game when a 2 × 2 square consisting of black pixels is formed.
Pasha has made a plan of k moves, according to which he will paint pixels. Each turn in his plan is represented as a pair of numbers i and j, denoting respectively the row and the column of the pixel to be colored on the current move.
Determine whether Pasha loses if he acts in accordance with his plan, and if he does, on what move the 2 × 2 square consisting of black pixels is formed.
Input
The first line of the input contains three integers n, m, k (1 ≤ n, m ≤ 1000, 1 ≤ k ≤ 105) — the number of rows, the number of columns and the number of moves that Pasha is going to perform.
The next k lines contain Pasha's moves in the order he makes them. Each line contains two integers i and j (1 ≤ i ≤ n, 1 ≤ j ≤ m), representing the row number and column number of the pixel that was painted during a move.
Output
If Pasha loses, print the number of the move when the 2 × 2 square consisting of black pixels is formed.
If Pasha doesn't lose, that is, no 2 × 2 square consisting of black pixels is formed during the given k moves, print 0.
Examples
Input
2 2 4
1 1
1 2
2 1
2 2
Output
4
Input
2 3 6
2 3
2 2
1 3
2 2
1 2
1 1
Output
5
Input
5 3 7
2 3
1 2
1 1
4 1
3 1
5 3
3 2
Output
0
Submitted Solution:
```
def check_box(x,y,mapp):
key=True
u=[(0,0),(0,1),(1,0),(1,1)]
try:
u=[(x+u[i][0],y+u[i][1]) for i in range(len(u))]
for w in u:
key&=mapp[w[0]][w[1]]
return key
except Exception:
return False
def checker(x,y,mapp):
u=[(0,0),(0,-1),(-1,0),(-1,-1)]
for w in u:
try:
if check_box(x+w[0],y+w[1],mapp):
return True
except Exception:
pass
return False
x=input()
(n,m,k)=x.split(maxsplit=100)
(n,m,k)=(int(n),int(m),int(k))
mapp=[[0 for j in range(m)] for i in range(n)]
key=False
for i in range(k):
x=input()
if key:
continue
(x,y)=x.split(maxsplit=100)
(x,y)=(int(x)-1,int(y)-1)
mapp[x][y]=1
if checker(x, y, mapp):
print(i+1)
key=True
if not key:
print(0)
``` | instruction | 0 | 17,218 | 7 | 34,436 |
No | output | 1 | 17,218 | 7 | 34,437 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha loves his phone and also putting his hair up... But the hair is now irrelevant.
Pasha has installed a new game to his phone. The goal of the game is following. There is a rectangular field consisting of n row with m pixels in each row. Initially, all the pixels are colored white. In one move, Pasha can choose any pixel and color it black. In particular, he can choose the pixel that is already black, then after the boy's move the pixel does not change, that is, it remains black. Pasha loses the game when a 2 × 2 square consisting of black pixels is formed.
Pasha has made a plan of k moves, according to which he will paint pixels. Each turn in his plan is represented as a pair of numbers i and j, denoting respectively the row and the column of the pixel to be colored on the current move.
Determine whether Pasha loses if he acts in accordance with his plan, and if he does, on what move the 2 × 2 square consisting of black pixels is formed.
Input
The first line of the input contains three integers n, m, k (1 ≤ n, m ≤ 1000, 1 ≤ k ≤ 105) — the number of rows, the number of columns and the number of moves that Pasha is going to perform.
The next k lines contain Pasha's moves in the order he makes them. Each line contains two integers i and j (1 ≤ i ≤ n, 1 ≤ j ≤ m), representing the row number and column number of the pixel that was painted during a move.
Output
If Pasha loses, print the number of the move when the 2 × 2 square consisting of black pixels is formed.
If Pasha doesn't lose, that is, no 2 × 2 square consisting of black pixels is formed during the given k moves, print 0.
Examples
Input
2 2 4
1 1
1 2
2 1
2 2
Output
4
Input
2 3 6
2 3
2 2
1 3
2 2
1 2
1 1
Output
5
Input
5 3 7
2 3
1 2
1 1
4 1
3 1
5 3
3 2
Output
0
Submitted Solution:
```
n,m,k=map(int,input().split())
l1=[[]]
s=0
c=0
M=[[0 for i in range(m+5)] for i in range(n+5)]
for i in range(n+5) :
print(M[i])
for i in range(k) :
a,b=map(int,input().split())
s=s+1
a=a+2
b=b+2
M[a-1][b-1]=1
if M[a-2][b-1]==1 and M[a-2][b-2]==1 and M[a-1][b-2]==1 :
print(s)
c=1
break
if M[a-2][b-1]==1 and M[a-2][b]==1 and M[a-1][b]==1 :
print(s)
c=1
break
if M[a][b-1]==1 and M[a][b-2]==1 and M[a-1][b-2]==1 :
print(s)
c=1
break
if M[a][b-1]==1 and M[a][b]==1 and M[a-1][b]==1 :
print(s)
c=1
break
if c==0 :
print(0)
``` | instruction | 0 | 17,219 | 7 | 34,438 |
No | output | 1 | 17,219 | 7 | 34,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Pasha loves his phone and also putting his hair up... But the hair is now irrelevant.
Pasha has installed a new game to his phone. The goal of the game is following. There is a rectangular field consisting of n row with m pixels in each row. Initially, all the pixels are colored white. In one move, Pasha can choose any pixel and color it black. In particular, he can choose the pixel that is already black, then after the boy's move the pixel does not change, that is, it remains black. Pasha loses the game when a 2 × 2 square consisting of black pixels is formed.
Pasha has made a plan of k moves, according to which he will paint pixels. Each turn in his plan is represented as a pair of numbers i and j, denoting respectively the row and the column of the pixel to be colored on the current move.
Determine whether Pasha loses if he acts in accordance with his plan, and if he does, on what move the 2 × 2 square consisting of black pixels is formed.
Input
The first line of the input contains three integers n, m, k (1 ≤ n, m ≤ 1000, 1 ≤ k ≤ 105) — the number of rows, the number of columns and the number of moves that Pasha is going to perform.
The next k lines contain Pasha's moves in the order he makes them. Each line contains two integers i and j (1 ≤ i ≤ n, 1 ≤ j ≤ m), representing the row number and column number of the pixel that was painted during a move.
Output
If Pasha loses, print the number of the move when the 2 × 2 square consisting of black pixels is formed.
If Pasha doesn't lose, that is, no 2 × 2 square consisting of black pixels is formed during the given k moves, print 0.
Examples
Input
2 2 4
1 1
1 2
2 1
2 2
Output
4
Input
2 3 6
2 3
2 2
1 3
2 2
1 2
1 1
Output
5
Input
5 3 7
2 3
1 2
1 1
4 1
3 1
5 3
3 2
Output
0
Submitted Solution:
```
def pasha():
n, m, k= [int(i) for i in input().split()]
a= []
for ans in range(k):
i, j= [int(p) for p in input().split()]
a.append([i, j])
#print(i, j, a)
b= sorted(a)
for i in ((b)):
if [i[0], i[1]+1] in a:
if [i[0]+ 1, i[1]] in a:
if [i[0]+ 1, i[1]+ 1] in a:
print(max(a.index(i), a.index([i[0], i[1]+1]), a.index([i[0]+ 1, i[1]]), a.index([i[0]+ 1, i[1]+ 1]))+1)
return
print(0)
return
pasha()
``` | instruction | 0 | 17,220 | 7 | 34,440 |
No | output | 1 | 17,220 | 7 | 34,441 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Adaltik discovered japanese crosswords. Japanese crossword is a picture, represented as a table sized a × b squares, and each square is colored white or black. There are integers to the left of the rows and to the top of the columns, encrypting the corresponding row or column. The number of integers represents how many groups of black squares there are in corresponding row or column, and the integers themselves represents the number of consecutive black squares in corresponding group (you can find more detailed explanation in Wikipedia <https://en.wikipedia.org/wiki/Japanese_crossword>).
Adaltik decided that the general case of japanese crossword is too complicated and drew a row consisting of n squares (e.g. japanese crossword sized 1 × n), which he wants to encrypt in the same way as in japanese crossword.
<image> The example of encrypting of a single row of japanese crossword.
Help Adaltik find the numbers encrypting the row he drew.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the length of the row. The second line of the input contains a single string consisting of n characters 'B' or 'W', ('B' corresponds to black square, 'W' — to white square in the row that Adaltik drew).
Output
The first line should contain a single integer k — the number of integers encrypting the row, e.g. the number of groups of black squares in the row.
The second line should contain k integers, encrypting the row, e.g. corresponding to sizes of groups of consecutive black squares in the order from left to right.
Examples
Input
3
BBW
Output
1
2
Input
5
BWBWB
Output
3
1 1 1
Input
4
WWWW
Output
0
Input
4
BBBB
Output
1
4
Input
13
WBBBBWWBWBBBW
Output
3
4 1 3
Note
The last sample case correspond to the picture in the statement. | instruction | 0 | 17,282 | 7 | 34,564 |
Tags: implementation
Correct Solution:
```
a = int(input())
b = input()
def countGroups(x, y):
count = 0
for i in range(0, x - 1):
if y[i] == 'B' and y[i + 1] == 'W':
count += 1
if y[x - 1] == 'B':
count += 1
return count
def blocks(x, y):
count = 0
for i in range(0, x - 1):
if y[i] == 'B':
count += 1
if y[i + 1] == 'W':
print(count)
else:
count = 0
if y[x - 1] == 'B':
print(count + 1)
print(countGroups(a, b))
blocks(a, b)
'''print(blocks(a, b))'''
``` | output | 1 | 17,282 | 7 | 34,565 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Adaltik discovered japanese crosswords. Japanese crossword is a picture, represented as a table sized a × b squares, and each square is colored white or black. There are integers to the left of the rows and to the top of the columns, encrypting the corresponding row or column. The number of integers represents how many groups of black squares there are in corresponding row or column, and the integers themselves represents the number of consecutive black squares in corresponding group (you can find more detailed explanation in Wikipedia <https://en.wikipedia.org/wiki/Japanese_crossword>).
Adaltik decided that the general case of japanese crossword is too complicated and drew a row consisting of n squares (e.g. japanese crossword sized 1 × n), which he wants to encrypt in the same way as in japanese crossword.
<image> The example of encrypting of a single row of japanese crossword.
Help Adaltik find the numbers encrypting the row he drew.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the length of the row. The second line of the input contains a single string consisting of n characters 'B' or 'W', ('B' corresponds to black square, 'W' — to white square in the row that Adaltik drew).
Output
The first line should contain a single integer k — the number of integers encrypting the row, e.g. the number of groups of black squares in the row.
The second line should contain k integers, encrypting the row, e.g. corresponding to sizes of groups of consecutive black squares in the order from left to right.
Examples
Input
3
BBW
Output
1
2
Input
5
BWBWB
Output
3
1 1 1
Input
4
WWWW
Output
0
Input
4
BBBB
Output
1
4
Input
13
WBBBBWWBWBBBW
Output
3
4 1 3
Note
The last sample case correspond to the picture in the statement. | instruction | 0 | 17,283 | 7 | 34,566 |
Tags: implementation
Correct Solution:
```
nb = int(input())
ls = input()
liste = [x for x in ls]
liste2 = []
compteur =0
for loop in range(len(liste)):
if liste[loop] =="B":
compteur +=1
else:
if compteur !=0:
liste2.append(str(compteur))
compteur = 0
if compteur!=0:
liste2.append(str(compteur))
print(len(liste2))
if len(liste2) !=0:
print(" ".join(liste2))
``` | output | 1 | 17,283 | 7 | 34,567 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Adaltik discovered japanese crosswords. Japanese crossword is a picture, represented as a table sized a × b squares, and each square is colored white or black. There are integers to the left of the rows and to the top of the columns, encrypting the corresponding row or column. The number of integers represents how many groups of black squares there are in corresponding row or column, and the integers themselves represents the number of consecutive black squares in corresponding group (you can find more detailed explanation in Wikipedia <https://en.wikipedia.org/wiki/Japanese_crossword>).
Adaltik decided that the general case of japanese crossword is too complicated and drew a row consisting of n squares (e.g. japanese crossword sized 1 × n), which he wants to encrypt in the same way as in japanese crossword.
<image> The example of encrypting of a single row of japanese crossword.
Help Adaltik find the numbers encrypting the row he drew.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the length of the row. The second line of the input contains a single string consisting of n characters 'B' or 'W', ('B' corresponds to black square, 'W' — to white square in the row that Adaltik drew).
Output
The first line should contain a single integer k — the number of integers encrypting the row, e.g. the number of groups of black squares in the row.
The second line should contain k integers, encrypting the row, e.g. corresponding to sizes of groups of consecutive black squares in the order from left to right.
Examples
Input
3
BBW
Output
1
2
Input
5
BWBWB
Output
3
1 1 1
Input
4
WWWW
Output
0
Input
4
BBBB
Output
1
4
Input
13
WBBBBWWBWBBBW
Output
3
4 1 3
Note
The last sample case correspond to the picture in the statement. | instruction | 0 | 17,284 | 7 | 34,568 |
Tags: implementation
Correct Solution:
```
n = int(input())
s = list(input())
freq = [0]*len(s)
j, flag, ans, pointer = 0, 0, 0, 0
for i in range(len(s)):
if (s[i] == "B"):
if (pointer == 0):
ans += 1
freq[j] += 1
flag = 1
pointer = 1
else:
freq[j] += 1
flag = 1
else:
pointer = 0
if (flag == 1):
flag = 0
j += 1
print(ans)
for i in freq:
if i != 0:
print(i, end = " ")
``` | output | 1 | 17,284 | 7 | 34,569 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Adaltik discovered japanese crosswords. Japanese crossword is a picture, represented as a table sized a × b squares, and each square is colored white or black. There are integers to the left of the rows and to the top of the columns, encrypting the corresponding row or column. The number of integers represents how many groups of black squares there are in corresponding row or column, and the integers themselves represents the number of consecutive black squares in corresponding group (you can find more detailed explanation in Wikipedia <https://en.wikipedia.org/wiki/Japanese_crossword>).
Adaltik decided that the general case of japanese crossword is too complicated and drew a row consisting of n squares (e.g. japanese crossword sized 1 × n), which he wants to encrypt in the same way as in japanese crossword.
<image> The example of encrypting of a single row of japanese crossword.
Help Adaltik find the numbers encrypting the row he drew.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the length of the row. The second line of the input contains a single string consisting of n characters 'B' or 'W', ('B' corresponds to black square, 'W' — to white square in the row that Adaltik drew).
Output
The first line should contain a single integer k — the number of integers encrypting the row, e.g. the number of groups of black squares in the row.
The second line should contain k integers, encrypting the row, e.g. corresponding to sizes of groups of consecutive black squares in the order from left to right.
Examples
Input
3
BBW
Output
1
2
Input
5
BWBWB
Output
3
1 1 1
Input
4
WWWW
Output
0
Input
4
BBBB
Output
1
4
Input
13
WBBBBWWBWBBBW
Output
3
4 1 3
Note
The last sample case correspond to the picture in the statement. | instruction | 0 | 17,285 | 7 | 34,570 |
Tags: implementation
Correct Solution:
```
n = int(input())
s = input()
X = 0
new = True
L = []
for each in s:
if each == "W":
new = True
if X != 0:
L.append(X)
X = 0
else:
if new:
new = False
X = 1
else:
X += 1
if not new and X != 0:
L.append(X)
print(len(L))
print(*L)
``` | output | 1 | 17,285 | 7 | 34,571 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Adaltik discovered japanese crosswords. Japanese crossword is a picture, represented as a table sized a × b squares, and each square is colored white or black. There are integers to the left of the rows and to the top of the columns, encrypting the corresponding row or column. The number of integers represents how many groups of black squares there are in corresponding row or column, and the integers themselves represents the number of consecutive black squares in corresponding group (you can find more detailed explanation in Wikipedia <https://en.wikipedia.org/wiki/Japanese_crossword>).
Adaltik decided that the general case of japanese crossword is too complicated and drew a row consisting of n squares (e.g. japanese crossword sized 1 × n), which he wants to encrypt in the same way as in japanese crossword.
<image> The example of encrypting of a single row of japanese crossword.
Help Adaltik find the numbers encrypting the row he drew.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the length of the row. The second line of the input contains a single string consisting of n characters 'B' or 'W', ('B' corresponds to black square, 'W' — to white square in the row that Adaltik drew).
Output
The first line should contain a single integer k — the number of integers encrypting the row, e.g. the number of groups of black squares in the row.
The second line should contain k integers, encrypting the row, e.g. corresponding to sizes of groups of consecutive black squares in the order from left to right.
Examples
Input
3
BBW
Output
1
2
Input
5
BWBWB
Output
3
1 1 1
Input
4
WWWW
Output
0
Input
4
BBBB
Output
1
4
Input
13
WBBBBWWBWBBBW
Output
3
4 1 3
Note
The last sample case correspond to the picture in the statement. | instruction | 0 | 17,286 | 7 | 34,572 |
Tags: implementation
Correct Solution:
```
n = int(input())
s = input()
x = s.split('W')
f = [len(i) for i in x if len(i) != 0]
print(len(f))
for i in f:
print(i, end=' ')
``` | output | 1 | 17,286 | 7 | 34,573 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Adaltik discovered japanese crosswords. Japanese crossword is a picture, represented as a table sized a × b squares, and each square is colored white or black. There are integers to the left of the rows and to the top of the columns, encrypting the corresponding row or column. The number of integers represents how many groups of black squares there are in corresponding row or column, and the integers themselves represents the number of consecutive black squares in corresponding group (you can find more detailed explanation in Wikipedia <https://en.wikipedia.org/wiki/Japanese_crossword>).
Adaltik decided that the general case of japanese crossword is too complicated and drew a row consisting of n squares (e.g. japanese crossword sized 1 × n), which he wants to encrypt in the same way as in japanese crossword.
<image> The example of encrypting of a single row of japanese crossword.
Help Adaltik find the numbers encrypting the row he drew.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the length of the row. The second line of the input contains a single string consisting of n characters 'B' or 'W', ('B' corresponds to black square, 'W' — to white square in the row that Adaltik drew).
Output
The first line should contain a single integer k — the number of integers encrypting the row, e.g. the number of groups of black squares in the row.
The second line should contain k integers, encrypting the row, e.g. corresponding to sizes of groups of consecutive black squares in the order from left to right.
Examples
Input
3
BBW
Output
1
2
Input
5
BWBWB
Output
3
1 1 1
Input
4
WWWW
Output
0
Input
4
BBBB
Output
1
4
Input
13
WBBBBWWBWBBBW
Output
3
4 1 3
Note
The last sample case correspond to the picture in the statement. | instruction | 0 | 17,287 | 7 | 34,574 |
Tags: implementation
Correct Solution:
```
n = int(input())
crossword = list(input())
count = 0
res = []
for c in crossword:
if c == 'B':
count += 1
else:
if count != 0:
res.append(count)
count = 0
if count != 0:
res.append(count)
print(len(res))
for x in res:
print(x, end=" ")
``` | output | 1 | 17,287 | 7 | 34,575 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Adaltik discovered japanese crosswords. Japanese crossword is a picture, represented as a table sized a × b squares, and each square is colored white or black. There are integers to the left of the rows and to the top of the columns, encrypting the corresponding row or column. The number of integers represents how many groups of black squares there are in corresponding row or column, and the integers themselves represents the number of consecutive black squares in corresponding group (you can find more detailed explanation in Wikipedia <https://en.wikipedia.org/wiki/Japanese_crossword>).
Adaltik decided that the general case of japanese crossword is too complicated and drew a row consisting of n squares (e.g. japanese crossword sized 1 × n), which he wants to encrypt in the same way as in japanese crossword.
<image> The example of encrypting of a single row of japanese crossword.
Help Adaltik find the numbers encrypting the row he drew.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the length of the row. The second line of the input contains a single string consisting of n characters 'B' or 'W', ('B' corresponds to black square, 'W' — to white square in the row that Adaltik drew).
Output
The first line should contain a single integer k — the number of integers encrypting the row, e.g. the number of groups of black squares in the row.
The second line should contain k integers, encrypting the row, e.g. corresponding to sizes of groups of consecutive black squares in the order from left to right.
Examples
Input
3
BBW
Output
1
2
Input
5
BWBWB
Output
3
1 1 1
Input
4
WWWW
Output
0
Input
4
BBBB
Output
1
4
Input
13
WBBBBWWBWBBBW
Output
3
4 1 3
Note
The last sample case correspond to the picture in the statement. | instruction | 0 | 17,288 | 7 | 34,576 |
Tags: implementation
Correct Solution:
```
n = int(input())
s = input() + "W"
c = 0
m = 0
a = []
for i in range(n+1):
if s[i]=='B':
m +=1
else:
if m>0:
c += 1
a.append(m)
m = 0
print(c)
if len(a) > 0:
print(*a, sep = ' ')
``` | output | 1 | 17,288 | 7 | 34,577 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recently Adaltik discovered japanese crosswords. Japanese crossword is a picture, represented as a table sized a × b squares, and each square is colored white or black. There are integers to the left of the rows and to the top of the columns, encrypting the corresponding row or column. The number of integers represents how many groups of black squares there are in corresponding row or column, and the integers themselves represents the number of consecutive black squares in corresponding group (you can find more detailed explanation in Wikipedia <https://en.wikipedia.org/wiki/Japanese_crossword>).
Adaltik decided that the general case of japanese crossword is too complicated and drew a row consisting of n squares (e.g. japanese crossword sized 1 × n), which he wants to encrypt in the same way as in japanese crossword.
<image> The example of encrypting of a single row of japanese crossword.
Help Adaltik find the numbers encrypting the row he drew.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the length of the row. The second line of the input contains a single string consisting of n characters 'B' or 'W', ('B' corresponds to black square, 'W' — to white square in the row that Adaltik drew).
Output
The first line should contain a single integer k — the number of integers encrypting the row, e.g. the number of groups of black squares in the row.
The second line should contain k integers, encrypting the row, e.g. corresponding to sizes of groups of consecutive black squares in the order from left to right.
Examples
Input
3
BBW
Output
1
2
Input
5
BWBWB
Output
3
1 1 1
Input
4
WWWW
Output
0
Input
4
BBBB
Output
1
4
Input
13
WBBBBWWBWBBBW
Output
3
4 1 3
Note
The last sample case correspond to the picture in the statement. | instruction | 0 | 17,289 | 7 | 34,578 |
Tags: implementation
Correct Solution:
```
n = int(input())
vec = input()
nv = 0
la = 0
res = ""
espacio = ""
for i in range(len(vec)):
#print(vec[i])
if vec[i] == 'B':
la += 1
else:
if la > 0:
nv += 1
res += espacio + str(la)
la = 0
espacio = " "
if la > 0:
nv += 1
res += espacio + str(la)
la = 0
espacio = " "
print (nv)
if nv > 0:
print (res)
``` | output | 1 | 17,289 | 7 | 34,579 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra. | instruction | 0 | 17,392 | 7 | 34,784 |
Tags: implementation
Correct Solution:
```
n = int(input())
line = list(map(int, input().split()))
ans = [1]
prev = line[0]
k = 1
for i in range(1, n):
if line[i] == prev:
ans[-1] += 1
else:
k += 1
prev = line[i]
ans.append(1)
if [ans[0]] * k != ans:
print('NO')
else:
print('YES')
``` | output | 1 | 17,392 | 7 | 34,785 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra. | instruction | 0 | 17,393 | 7 | 34,786 |
Tags: implementation
Correct Solution:
```
n = int(input())
x = list(map(int, input().split()))
d = None
s = 1
c = x[0]
for i in range(1, n):
if x[i] == c:
s += 1
else:
if d is None:
d = s
else:
if (s != d):
print("NO")
break
s = 1
c = x[i]
else:
if (d is None) or (s == d):
print("YES")
else:
print("NO")
``` | output | 1 | 17,393 | 7 | 34,787 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra. | instruction | 0 | 17,394 | 7 | 34,788 |
Tags: implementation
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
i=0
while a[i] == a[0]:
i+=1
if i==n:
break
b=[]
b.append([a[0] for i in range(0,i)])
b.append([(a[0] +1) % 2 for i in range(0,i)])
c=[]
for i in range(n//i):
c += b[i % 2]
if c == a:
print("YES")
else:
print("NO")
``` | output | 1 | 17,394 | 7 | 34,789 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra. | instruction | 0 | 17,395 | 7 | 34,790 |
Tags: implementation
Correct Solution:
```
def f():
N = int(input())
if N == 1:
print('YES')
return
strZebza = input().split(' ')
if strZebza[-1] ==' ' or strZebza[-1] == '\n':
del strZebza[-1]
mass = [ int(el) for el in strZebza]
if mass[0] == 1:
startColour = 1
secondColour = 0
else:
startColour = 0
secondColour = 1
ind = 1;
while(True):
if(mass[ind]!=startColour):
break
ind +=1
if ind == N:
print('YES')
return
size = ind;
if(N % size !=0):
print('NO')
return
for i in range(int(N / size )):
a = sum( mass[i*size : (i+1)*size] )
if i % 2 != 0:
if a!= secondColour*size:
print('NO')
return
else:
if a!= startColour*size:
print('NO')
return
print('YES')
return
f()
``` | output | 1 | 17,395 | 7 | 34,791 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra. | instruction | 0 | 17,396 | 7 | 34,792 |
Tags: implementation
Correct Solution:
```
input()
picture = input().split()
cur_col = picture[0]
cur_len = 0
last_len = -1
for i in picture:
if i == cur_col:
cur_len += 1
else:
if last_len != -1 and cur_len != last_len:
print("NO")
exit(0)
else:
last_len = cur_len
cur_len = 1
cur_col = i
if last_len != -1 and cur_len != last_len:
print("NO")
exit(0)
print("YES")
``` | output | 1 | 17,396 | 7 | 34,793 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra. | instruction | 0 | 17,397 | 7 | 34,794 |
Tags: implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
v = list()
last, cnt = a[0], 0
for i in range(n):
if a[i] == last:
cnt += 1
else:
v.append(cnt)
cnt = 1
last = a[i]
v.append(cnt)
f = True
for e in v:
if e != v[0]:
f = False
if (f):
print('YES')
else:
print('NO')
``` | output | 1 | 17,397 | 7 | 34,795 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra. | instruction | 0 | 17,398 | 7 | 34,796 |
Tags: implementation
Correct Solution:
```
from itertools import groupby
n = int(input())
mas = ''.join([i for i in input().split()])
zebra = []
zebra = [len(list(j)) for i, j in groupby(mas)]
a = [len(list(j)) for i, j in groupby(zebra)]
if len(a)==1:
print('YES')
else:
print('NO')
``` | output | 1 | 17,398 | 7 | 34,797 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra. | instruction | 0 | 17,399 | 7 | 34,798 |
Tags: implementation
Correct Solution:
```
n = int(input())
num = []
num = list(map(int, input().split()))
firstZifr = 1
flag = 0
cnt = 0
nowCnt = 0
ans = 0
for i in range(n):
if (i == 0):
firstZifr = num[0]
cnt = cnt + 1
elif (num[i] == firstZifr and flag == 0):
cnt = cnt + 1
elif (num[i] != firstZifr and flag == 0):
flag = 1;
if (firstZifr == 0):
firstZifr = 1
else:
firstZifr = 0
nowCnt = 1
elif (num[i] == firstZifr and flag == 1):
nowCnt = nowCnt + 1
elif (num[i] != firstZifr and flag == 1):
if (firstZifr == 0):
firstZifr = 1
else:
firstZifr = 0
if (nowCnt != cnt):
ans = 1
nowCnt = 1
if (nowCnt != cnt and flag == 1):
ans = 1
if (ans == 0):
print("YES")
else:
print("NO")
``` | output | 1 | 17,399 | 7 | 34,799 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra.
Submitted Solution:
```
n=int(input())
a=input()
a=a.split()
x=1
for i in range(1,n):
if a[i]!=a[i-1]:
break
else:
x=x+1
if n%x!=0:
print('NO')
else:
q=0
for i in range(0,n,x):
for j in range(x-1):
if a[i+j]!=a[i+j+1]:
q=1
if i+x<n:
if a[i]==a[i+x]:
q=1
if q==0:
print('YES')
else:
print('NO')
``` | instruction | 0 | 17,400 | 7 | 34,800 |
Yes | output | 1 | 17,400 | 7 | 34,801 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra.
Submitted Solution:
```
def solve():
n = int(input())
p = [int(x) for x in (input().split())]
c = dict()
cnt = 0
for i in range(n):
if i == 0:
cnt += 1
continue
if p[i] == p[i - 1]:
cnt += 1
if p[i] != p[i - 1]:
c[cnt] = 1
cnt = 1
if i == n - 1:
c[cnt] = 1
if len(c) < 2:
print('YES')
else:
print('NO')
solve()
``` | instruction | 0 | 17,401 | 7 | 34,802 |
Yes | output | 1 | 17,401 | 7 | 34,803 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra.
Submitted Solution:
```
n=(int)(input())
a = [int(i) for i in input().split()]
S=set()
p=1
for i in range(1,n):
if a[i]!=a[i-1]:
S.add(p)
p=0
p=p+1
S.add(p)
if len(S)!=1:
print('NO\n')
else:
print('YES\n')
``` | instruction | 0 | 17,402 | 7 | 34,804 |
Yes | output | 1 | 17,402 | 7 | 34,805 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra.
Submitted Solution:
```
n = int(input())
a = input().split()
s = ''.join(a)
w = set(s.split('0')) - {''}
b = set(s.split('1')) - {''}
if len(w) > 1 or len(b) > 1:
print("NO")
elif len(w) == 0 or len(b) == 0:
print("YES")
elif len(list(w)[0]) == len(list(b)[0]):
print("YES")
else:
print("NO")
``` | instruction | 0 | 17,403 | 7 | 34,806 |
Yes | output | 1 | 17,403 | 7 | 34,807 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra.
Submitted Solution:
```
n=int(input())
count=0
px=0
f=0
a = list(map(int, input().split()))
i=1
while (a[i]==a[i-1]):
i+=1
for x in range(0,n):
if a[x]==1:
count+=1
else:
count-=1
if (abs(count)>i):
f=1
if (f==0)and((count==0)or(count==i)):
print("YES")
else:
print("NO")
``` | instruction | 0 | 17,404 | 7 | 34,808 |
No | output | 1 | 17,404 | 7 | 34,809 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra.
Submitted Solution:
```
n=int(input())
a=input().split()
for i in range(n):
a[i]=int(a[i])
try:
a.index(1-a[0])
except:
print('YES')
exit()
s=a.index(abs(a[0]-1))
c=1-a[0]
for i in range(n):
try:
ss=a.index(1-c,s)
print(ss)
c=1-c
if ss!=s:
print('NO')
exit()
except:
print('YES')
exit()
``` | instruction | 0 | 17,405 | 7 | 34,810 |
No | output | 1 | 17,405 | 7 | 34,811 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra.
Submitted Solution:
```
n = int(input())
num = []
num = list(map(int, input().split()))
firstZifr = 1
flag = 0
cnt = 0
nowCnt = 0
ans = 0
for i in range(n):
if (i == 0):
firstZifr = num[0]
cnt = cnt + 1
if (num[i] == firstZifr and flag == 0):
cnt = cnt + 1
if (num[i] != firstZifr and flag == 0):
flag = 1;
if (firstZifr == 0):
firstZifr = 1
else:
firstZifr = 0
nowCnt = 1
if (num[i] == firstZifr and flag == 1):
nowCnt = nowCnt + 1
if (num[i] != firstZifr and flag == 1):
if (firstZifr == 0):
firstZifr = 1
else:
firstZifr = 0
if (nowCnt != cnt):
ans = 1
if (nowCnt != cnt and flag == 1):
ans = 1
if (ans == 0):
print("YES")
else:
print("NO")
``` | instruction | 0 | 17,406 | 7 | 34,812 |
No | output | 1 | 17,406 | 7 | 34,813 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A camera you have accidentally left in a desert has taken an interesting photo. The photo has a resolution of n pixels width, and each column of this photo is all white or all black. Thus, we can represent the photo as a sequence of n zeros and ones, where 0 means that the corresponding column is all white, and 1 means that the corresponding column is black.
You think that this photo can contain a zebra. In this case the whole photo should consist of several (possibly, only one) alternating black and white stripes of equal width. For example, the photo [0, 0, 0, 1, 1, 1, 0, 0, 0] can be a photo of zebra, while the photo [0, 0, 0, 1, 1, 1, 1] can not, because the width of the black stripe is 3, while the width of the white stripe is 4. Can the given photo be a photo of zebra or not?
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the width of the photo.
The second line contains a sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 1) — the description of the photo. If ai is zero, the i-th column is all black. If ai is one, then the i-th column is all white.
Output
If the photo can be a photo of zebra, print "YES" (without quotes). Otherwise, print "NO".
You can print each letter in any case (upper or lower).
Examples
Input
9
0 0 0 1 1 1 0 0 0
Output
YES
Input
7
0 0 0 1 1 1 1
Output
NO
Input
5
1 1 1 1 1
Output
YES
Input
8
1 1 1 0 0 0 1 1
Output
NO
Input
9
1 1 0 1 1 0 1 1 0
Output
NO
Note
The first two examples are described in the statements.
In the third example all pixels are white, so the photo can be a photo of zebra.
In the fourth example the width of the first stripe is equal to three (white color), the width of the second stripe is equal to three (black), and the width of the third stripe is equal to two (white). Thus, not all stripes have equal length, so this photo is not a photo of zebra.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
countFirst = 0
countSecond = 0
i = 0
j = 0
fFirst = 0
fSecond = 0
while i < len(a):
#print('im here, i =', i)
if i + 1 >= len(a):
if a[i - 1] == a[i]:
countFirst += 1
break
else:
countSecond += 1
break
if a[i] == a[i + 1]:
countFirst += 1
i += 1
else:
countFirst += 1
fFirst = countFirst
countFirst = 0
j = i + 1
while j < len(a):
#print('now here, j =', j)
if j + 1 >= len(a):
if a[j - 1] == a[j]:
countSecond += 1
break
else:
countFirst += 1
break
if a[j] == a[j + 1]:
countSecond += 1
j += 1
else:
countSecond += 1
fSecond = countSecond
countSecond = 0
i = j + 1
break
i = j + 1
flag = True
#print(countFirst, fFirst, countSecond, fSecond)
if countSecond != 0:
if countSecond != fFirst and fFirst != 0:
flag = False
if countFirst != 0:
if countFirst != fSecond and fSecond != 0:
flag = False
if flag and (fFirst == fSecond or (fFirst + fSecond == abs(fFirst - fSecond))):
print("YES")
else:
print("NO")
``` | instruction | 0 | 17,407 | 7 | 34,814 |
No | output | 1 | 17,407 | 7 | 34,815 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0]. | instruction | 0 | 17,869 | 7 | 35,738 |
Tags: dp, greedy
Correct Solution:
```
for i in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
n=int(input())
b=list(map(int,input().split()))
sum=0
ma1=0
for p in a:
sum+=p
ma1=max(ma1,sum)
sum=0
ma2=0
for j in b:
sum+=j
ma2=max(ma2,sum)
print(ma1+ma2)
``` | output | 1 | 17,869 | 7 | 35,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0]. | instruction | 0 | 17,870 | 7 | 35,740 |
Tags: dp, greedy
Correct Solution:
```
for j in range(int(input())):
n=int(input())
a=[int(j) for j in input().split()]
m=int(input())
b=[int(j) for j in input().split()]
s=0
t=0
S=[]
T=[]
for i in a:
s+=i
S.append(s)
for i in b:
t+=i
T.append(t)
if max(S)*max(T)<0:
print(max(max(S),max(T)))
elif max(S)>=0 and max(T)>=0:
print(max(S)+max(T))
else:
print(0)
``` | output | 1 | 17,870 | 7 | 35,741 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0]. | instruction | 0 | 17,871 | 7 | 35,742 |
Tags: dp, greedy
Correct Solution:
```
import math
import sys
import bisect # https://pythonworld.ru/moduli/modul-bisect.html
from heapq import heapify, heappop, heappush
from itertools import * # https://pythonworld.ru/moduli/modul-itertools.html
from collections import deque, OrderedDict
from pprint import pprint
sys.setrecursionlimit(10 ** 6)
# f = open('input.txt')
# f.close()
II = lambda: sys.stdin.readline() # f.readline()
inp = lambda: int(II())
inpm = lambda: map(int, II().split())
inpl = lambda: list(inpm())
arr_mn = lambda _n, _m: [[0 for __ in range(_m)] for _ in range(_n)]
arr_nn = lambda _n: arr_mn(_n, _n)
WHITE, GREY, BLACK, RED = 0, 1, 2, 3
EPS = 1e-9
INF = 1000000001 #int(1e18)
MOD = int(1e9) + 7 # 998244353
N = 2000009
"""
"""
def solve():
n = inp()
a = inpl()
m = inp()
b = inpl()
x = 0
p = 0
for i in range(n):
p += a[i]
x = max(p, x)
y = 0
p = 0
for i in range(m):
p += b[i]
y = max(p, y)
print(x + y)
'''
'''
def main():
t = inp() # 1 #
for i in range(t):
solve()
# print()
main()
``` | output | 1 | 17,871 | 7 | 35,743 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0]. | instruction | 0 | 17,872 | 7 | 35,744 |
Tags: dp, greedy
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
A = list(map(int, input().split()))
m = int(input())
B = list(map(int, input().split()))
pref_A = [0]
pref_B = [0]
for i in A:
pref_A.append(pref_A[-1]+i)
for i in B:
pref_B.append(pref_B[-1]+i)
print(max(pref_B) + max(pref_A))
``` | output | 1 | 17,872 | 7 | 35,745 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0]. | instruction | 0 | 17,873 | 7 | 35,746 |
Tags: dp, greedy
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = [int(x) for x in input().split()]
m = int(input())
b = [int(x) for x in input().split()]
dp = [[-10**9 for j in range(m + 1)] for i in range(n + 1)]
dp[0][0] = 0
ans = 0
for i in range(n + 1):
for j in range(m + 1):
if i < n:
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + a[i])
if j < m:
dp[i][j + 1] = max(dp[i][j + 1], dp[i][j] + b[j])
ans = max(ans, dp[i][j])
print(ans)
``` | output | 1 | 17,873 | 7 | 35,747 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0]. | instruction | 0 | 17,874 | 7 | 35,748 |
Tags: dp, greedy
Correct Solution:
```
import collections
import math
from heapq import *
for t in range(1,int(input())+1):
n=int(input())
r=list(map(int,input().split()))
m=int(input())
b=list(map(int,input().split()))
out=0
val=v1=v2=0
for i in r:
val+=i
v1=max(v1,val)
val=0
for i in b:
val+=i
v2=max(v2,val)
print(v1+v2)
``` | output | 1 | 17,874 | 7 | 35,749 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0]. | instruction | 0 | 17,875 | 7 | 35,750 |
Tags: dp, greedy
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = [int(x) for x in input().split()]
m = int(input())
b = [int(x) for x in input().split()]
def mpref(arr):
cur = 0
res = 0
for x in arr:
cur += x
res = max(res, cur)
return res
print(mpref(a) + mpref(b))
``` | output | 1 | 17,875 | 7 | 35,751 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0]. | instruction | 0 | 17,876 | 7 | 35,752 |
Tags: dp, greedy
Correct Solution:
```
from itertools import accumulate
s = lambda x: max(0, max(accumulate(x)))
for _ in range(int(input())):
n = int(input())
r = list(map(int, input().split()))
m = int(input())
b = list(map(int, input().split()))
print(s(r)+s(b))
``` | output | 1 | 17,876 | 7 | 35,753 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0].
Submitted Solution:
```
# @author
import sys
class BRedAndBlue:
def solve(self, tc=0):
for _ in range(int(input())):
n = int(input())
r = [int(_) for _ in input().split()]
m = int(input())
b = [int(_) for _ in input().split()]
ri = bi = 0
answers = [0]
prer = [0]
preb = [0]
for i in range(len(r)):
prer.append(prer[-1] + r[i])
for i in range(len(b)):
preb.append(preb[-1] + b[i])
print(max(prer) + max(preb))
# while ri < n or bi < m:
# ans = answers[-1]
# if ri < n and bi < m:
# if ans + r[ri] > ans + b[bi]:
# ans += r[ri]
# ri += 1
# else:
# ans += b[bi]
# bi += 1
# elif ri < n:
# ans += r[ri]
# ri += 1
# elif bi < m:
# ans += b[bi]
# bi += 1
# answers.append(ans)
#
# print(max(answers))
solver = BRedAndBlue()
input = sys.stdin.readline
solver.solve()
``` | instruction | 0 | 17,877 | 7 | 35,754 |
Yes | output | 1 | 17,877 | 7 | 35,755 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0].
Submitted Solution:
```
t = int(input())
for testCaseCounter in range(t):
n = int(input())
reds = [int(amit) for amit in input().split(" ")]
m = int(input())
blues = [int(amit) for amit in input().split(" ")]
rpref = [0] * len(reds)
rpref[0] = reds[0]
for i in range(1, len(reds)):
rpref[i] = rpref[i-1] + reds[i]
bpref = [0] * len(blues)
bpref[0] = blues[0]
for i in range(1, len(blues)):
bpref[i] = bpref[i-1] + blues[i]
rprefMaxVal = -1
for i in range(len(rpref)):
if rpref[i] > 0 and rpref[i] > rprefMaxVal:
rprefMaxVal = rpref[i]
rCont = max(0, rprefMaxVal)
bprefMaxVal = -1
for i in range(len(bpref)):
if bpref[i] > 0 and bpref[i] > bprefMaxVal:
bprefMaxVal = bpref[i]
bCont = max(0, bprefMaxVal)
print (rCont + bCont)
``` | instruction | 0 | 17,878 | 7 | 35,756 |
Yes | output | 1 | 17,878 | 7 | 35,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0].
Submitted Solution:
```
for i in range(0,int(input())):
n=int(input())
l=list(map(int,input().split()))
for i in range(1,n):
l[i]+=l[i-1]
m=int(input())
p=list(map(int,input().split()))
for i in range(1,m):
p[i]+=p[i-1]
print(max(max(l)+max(p),max(l),max(p),0))
``` | instruction | 0 | 17,879 | 7 | 35,758 |
Yes | output | 1 | 17,879 | 7 | 35,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0].
Submitted Solution:
```
# from __future__ import print_function,division
# range = xrange
import sys
input = sys.stdin.readline
# sys.setrecursionlimit(10**9)
from sys import stdin, stdout
from collections import defaultdict, Counter
M = 10**9+7
def main():
for _ in range(int(input())):
n = int(input())
r = [int(s) for s in input().split()]
m = int(input())
b = [int(s) for s in input().split()]
pre1 = [r[0]]*n
pre2 = [b[0]]*m
ans = max(0,max(r[0],b[0]))
for i in range(1,n):
pre1[i] = pre1[i-1]+r[i]
ans = max(ans,pre1[i])
for i in range(1,m):
pre2[i] = pre2[i-1]+b[i]
ans = max(ans,pre2[i])
for i in range(n):
for j in range(m):
ans = max(ans,pre1[i]+pre2[j])
print(ans)
if __name__== '__main__':
main()
``` | instruction | 0 | 17,880 | 7 | 35,760 |
Yes | output | 1 | 17,880 | 7 | 35,761 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0].
Submitted Solution:
```
# Code Submission
#
# Author : sudoSieg
# Date : 28:12:2020
# Time : 20:09:50
#
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
from itertools import accumulate
for _ in range(int(input())):
n, r, m, b = int(input()), [*map(int, input().split())], int(input()), [*map(int, input().split())]
print(max(0, max([*accumulate(r)]) + max([*accumulate(b)])))
``` | instruction | 0 | 17,881 | 7 | 35,762 |
No | output | 1 | 17,881 | 7 | 35,763 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0].
Submitted Solution:
```
import sys
rl = lambda : list(map(int, sys.stdin.readline().split()))
def solve(i, j):
if i == -1 or j == -1:
return 0
ret = cache[i][j]
if ret != -1:
return ret
# if i != -1:
# ret = R[i]
# if j != -1:
# ret += B[j]
ret = max(solve(i - 1, j), solve(i, j - 1), sum(R[:i+1]) + sum(B[:j+1]))
cache[i][j] = ret
return ret
for _ in range(int(input())):
n = int(input())
R = rl()
m = int(input())
B = rl()
cache = [[-1 for _ in range(101)] for _ in range(101)]
print(solve(n - 1, m - 1))
``` | instruction | 0 | 17,882 | 7 | 35,764 |
No | output | 1 | 17,882 | 7 | 35,765 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0].
Submitted Solution:
```
res = []
for i in range(int(input())):
n = int(input())
r = list(map(int,input().split()))
m = int(input())
l = list(map(int, input().split()))
u = 0
for j in range(n):
r[j]+= u
u = r[j]
u = 0
for j in range(m):
l[j]+= u
u = l[j]
res.append(max(0, max(l)+ max(r)))
print(*res, sep = '\n')
``` | instruction | 0 | 17,883 | 7 | 35,766 |
No | output | 1 | 17,883 | 7 | 35,767 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Monocarp had a sequence a consisting of n + m integers a_1, a_2, ..., a_{n + m}. He painted the elements into two colors, red and blue; n elements were painted red, all other m elements were painted blue.
After painting the elements, he has written two sequences r_1, r_2, ..., r_n and b_1, b_2, ..., b_m. The sequence r consisted of all red elements of a in the order they appeared in a; similarly, the sequence b consisted of all blue elements of a in the order they appeared in a as well.
Unfortunately, the original sequence was lost, and Monocarp only has the sequences r and b. He wants to restore the original sequence. In case there are multiple ways to restore it, he wants to choose a way to restore that maximizes the value of
$$$f(a) = max(0, a_1, (a_1 + a_2), (a_1 + a_2 + a_3), ..., (a_1 + a_2 + a_3 + ... + a_{n + m}))$$$
Help Monocarp to calculate the maximum possible value of f(a).
Input
The first line contains one integer t (1 ≤ t ≤ 1000) — the number of test cases. Then the test cases follow. Each test case consists of four lines.
The first line of each test case contains one integer n (1 ≤ n ≤ 100).
The second line contains n integers r_1, r_2, ..., r_n (-100 ≤ r_i ≤ 100).
The third line contains one integer m (1 ≤ m ≤ 100).
The fourth line contains m integers b_1, b_2, ..., b_m (-100 ≤ b_i ≤ 100).
Output
For each test case, print one integer — the maximum possible value of f(a).
Example
Input
4
4
6 -5 7 -3
3
2 3 -4
2
1 1
4
10 -3 2 2
5
-1 -2 -3 -4 -5
5
-1 -2 -3 -4 -5
1
0
1
0
Output
13
13
0
0
Note
In the explanations for the sample test cases, red elements are marked as bold.
In the first test case, one of the possible sequences a is [6, 2, -5, 3, 7, -3, -4].
In the second test case, one of the possible sequences a is [10, 1, -3, 1, 2, 2].
In the third test case, one of the possible sequences a is [-1, -1, -2, -3, -2, -4, -5, -3, -4, -5].
In the fourth test case, one of the possible sequences a is [0, 0].
Submitted Solution:
```
t = int(input())
for i in range(t):
n = int(input())
arr1 = [int(x) for x in input().split()]
m = int(input())
arr2 = [int(x) for x in input().split()]
curr_max = 0
ans = 0
i = 0
j = 0
for i in range(min(n,m)):
if arr1[i]>= arr2[i]:
curr_max += arr1[i]
# print('curr_max, arr1[i]', curr_max, arr1[i])
ans = max(ans, curr_max)
curr_max += arr2[i]
# print('curr_max, arr2[i]', curr_max, arr2[i])
ans = max(ans, curr_max)
# print(ans)
else:
curr_max += arr2[i]
ans = max(ans, curr_max)
# print('curr_max, arr1[i]', curr_max, arr1[i])
curr_max += arr1[i]
ans = max(ans, curr_max)
# print('curr_max, arr2[i]', curr_max, arr2[i])
if n > m:
for k in range(i+1, n):
# print('k, arr1[k]', k, arr1[k])
curr_max += arr1[k]
ans = max(ans, curr_max)
# print('curr_max, ans, first', curr_max, ans)
else:
for k in range(i+1, m):
curr_max += arr2[k]
ans = max(ans, curr_max)
# print('curr_max, ans, second', curr_max, ans)
print(ans)
``` | instruction | 0 | 17,884 | 7 | 35,768 |
No | output | 1 | 17,884 | 7 | 35,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is training for the IOI. What is a better way to train than playing a Zuma-like game?
There are n balls put in a row. Each ball is colored in one of k colors. Initially the row doesn't contain three or more contiguous balls with the same color. Iahub has a single ball of color x. He can insert his ball at any position in the row (probably, between two other balls). If at any moment there are three or more contiguous balls of the same color in the row, they are destroyed immediately. This rule is applied multiple times, until there are no more sets of 3 or more contiguous balls of the same color.
For example, if Iahub has the row of balls [black, black, white, white, black, black] and a white ball, he can insert the ball between two white balls. Thus three white balls are destroyed, and then four black balls become contiguous, so all four balls are destroyed. The row will not contain any ball in the end, so Iahub can destroy all 6 balls.
Iahub wants to destroy as many balls as possible. You are given the description of the row of balls, and the color of Iahub's ball. Help Iahub train for the IOI by telling him the maximum number of balls from the row he can destroy.
Input
The first line of input contains three integers: n (1 ≤ n ≤ 100), k (1 ≤ k ≤ 100) and x (1 ≤ x ≤ k). The next line contains n space-separated integers c1, c2, ..., cn (1 ≤ ci ≤ k). Number ci means that the i-th ball in the row has color ci.
It is guaranteed that the initial row of balls will never contain three or more contiguous balls of the same color.
Output
Print a single integer — the maximum number of balls Iahub can destroy.
Examples
Input
6 2 2
1 1 2 2 1 1
Output
6
Input
1 1 1
1
Output
0 | instruction | 0 | 18,058 | 7 | 36,116 |
Tags: brute force, two pointers
Correct Solution:
```
n, k, x = map(int, input().split())
bolas = list(map(int, input().split()))
resp = 0
for c in range(n):
s = bolas.copy()
s.insert(c, x)
while len(s) > 2:
l = len(s)
for i in range(2, len(s)):
if s[i-2] == s[i-1] == s[i]:
p = i + 1
while p < len(s):
if s[i] != s[p]:
break
p += 1
s = s[:i-2] + s[p:]
break
if len(s) == l:
break
resp = max(resp, n - len(s))
print(resp)
``` | output | 1 | 18,058 | 7 | 36,117 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is training for the IOI. What is a better way to train than playing a Zuma-like game?
There are n balls put in a row. Each ball is colored in one of k colors. Initially the row doesn't contain three or more contiguous balls with the same color. Iahub has a single ball of color x. He can insert his ball at any position in the row (probably, between two other balls). If at any moment there are three or more contiguous balls of the same color in the row, they are destroyed immediately. This rule is applied multiple times, until there are no more sets of 3 or more contiguous balls of the same color.
For example, if Iahub has the row of balls [black, black, white, white, black, black] and a white ball, he can insert the ball between two white balls. Thus three white balls are destroyed, and then four black balls become contiguous, so all four balls are destroyed. The row will not contain any ball in the end, so Iahub can destroy all 6 balls.
Iahub wants to destroy as many balls as possible. You are given the description of the row of balls, and the color of Iahub's ball. Help Iahub train for the IOI by telling him the maximum number of balls from the row he can destroy.
Input
The first line of input contains three integers: n (1 ≤ n ≤ 100), k (1 ≤ k ≤ 100) and x (1 ≤ x ≤ k). The next line contains n space-separated integers c1, c2, ..., cn (1 ≤ ci ≤ k). Number ci means that the i-th ball in the row has color ci.
It is guaranteed that the initial row of balls will never contain three or more contiguous balls of the same color.
Output
Print a single integer — the maximum number of balls Iahub can destroy.
Examples
Input
6 2 2
1 1 2 2 1 1
Output
6
Input
1 1 1
1
Output
0 | instruction | 0 | 18,059 | 7 | 36,118 |
Tags: brute force, two pointers
Correct Solution:
```
def solve(a):
for i in range(len(a)-1):
j = i + 1
while j < len(a) and a[j] == a[i]:
j += 1
num = j - i
if num >= 3:
return num + solve(a[:i] + a[j:])
return 0
n, k, x = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
best = 0
for i in range(len(c)):
if c[i] == x:
best = max(best, solve(c[:i] + [x] + c[i:])-1)
print(best)
``` | output | 1 | 18,059 | 7 | 36,119 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is training for the IOI. What is a better way to train than playing a Zuma-like game?
There are n balls put in a row. Each ball is colored in one of k colors. Initially the row doesn't contain three or more contiguous balls with the same color. Iahub has a single ball of color x. He can insert his ball at any position in the row (probably, between two other balls). If at any moment there are three or more contiguous balls of the same color in the row, they are destroyed immediately. This rule is applied multiple times, until there are no more sets of 3 or more contiguous balls of the same color.
For example, if Iahub has the row of balls [black, black, white, white, black, black] and a white ball, he can insert the ball between two white balls. Thus three white balls are destroyed, and then four black balls become contiguous, so all four balls are destroyed. The row will not contain any ball in the end, so Iahub can destroy all 6 balls.
Iahub wants to destroy as many balls as possible. You are given the description of the row of balls, and the color of Iahub's ball. Help Iahub train for the IOI by telling him the maximum number of balls from the row he can destroy.
Input
The first line of input contains three integers: n (1 ≤ n ≤ 100), k (1 ≤ k ≤ 100) and x (1 ≤ x ≤ k). The next line contains n space-separated integers c1, c2, ..., cn (1 ≤ ci ≤ k). Number ci means that the i-th ball in the row has color ci.
It is guaranteed that the initial row of balls will never contain three or more contiguous balls of the same color.
Output
Print a single integer — the maximum number of balls Iahub can destroy.
Examples
Input
6 2 2
1 1 2 2 1 1
Output
6
Input
1 1 1
1
Output
0 | instruction | 0 | 18,060 | 7 | 36,120 |
Tags: brute force, two pointers
Correct Solution:
```
R = lambda: list(map(int, input().split()))
def dfs(a):
cnt = 0
n = len(a)
a.append(10000000)
for i in range(1, n):
if a[i] != a[i - 1]:
cnt = 0
else:
cnt += 1
if cnt >= 2:
j = i
while a[j] == a[i]:
j += 1
return j - i + 2 + dfs(a[:i - 2] + a[j:n])
return 0
n, k, x = R()
a = R()
ans=1
for i in range(n+1):
ans=max(ans, dfs(a[:i]+[x]+a[i:]))
print(ans-1)
``` | output | 1 | 18,060 | 7 | 36,121 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Iahub is training for the IOI. What is a better way to train than playing a Zuma-like game?
There are n balls put in a row. Each ball is colored in one of k colors. Initially the row doesn't contain three or more contiguous balls with the same color. Iahub has a single ball of color x. He can insert his ball at any position in the row (probably, between two other balls). If at any moment there are three or more contiguous balls of the same color in the row, they are destroyed immediately. This rule is applied multiple times, until there are no more sets of 3 or more contiguous balls of the same color.
For example, if Iahub has the row of balls [black, black, white, white, black, black] and a white ball, he can insert the ball between two white balls. Thus three white balls are destroyed, and then four black balls become contiguous, so all four balls are destroyed. The row will not contain any ball in the end, so Iahub can destroy all 6 balls.
Iahub wants to destroy as many balls as possible. You are given the description of the row of balls, and the color of Iahub's ball. Help Iahub train for the IOI by telling him the maximum number of balls from the row he can destroy.
Input
The first line of input contains three integers: n (1 ≤ n ≤ 100), k (1 ≤ k ≤ 100) and x (1 ≤ x ≤ k). The next line contains n space-separated integers c1, c2, ..., cn (1 ≤ ci ≤ k). Number ci means that the i-th ball in the row has color ci.
It is guaranteed that the initial row of balls will never contain three or more contiguous balls of the same color.
Output
Print a single integer — the maximum number of balls Iahub can destroy.
Examples
Input
6 2 2
1 1 2 2 1 1
Output
6
Input
1 1 1
1
Output
0 | instruction | 0 | 18,061 | 7 | 36,122 |
Tags: brute force, two pointers
Correct Solution:
```
import sys
from math import *
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
z,n,c = None, None, None
def DOIT(l, r):
#if z[l][r]:
# return z[l][r]
if l > 0 and r < n:
ll = l-1
rr = r
x = c[ll]
if x == c[rr]:
while ll > 0 and x == c[ll - 1]:
ll -= 1
while rr + 1 < n and x == c[rr + 1]:
rr += 1
if (l-ll)+(rr-r+1) > 2:
#print(ll,l,r,rr)
#z[l][r] = (l-ll)+(rr-r+1)+DOIT(ll,rr+1)
#return z[l][r]
return (l-ll)+(rr-r+1)+DOIT(ll,rr+1)
#z[l][r] = 0
return 0
n,k,x = mints()
z = [[None]*(n+1) for i in range(n+1)]
c = list(mints())
r = 0
i = 0
while i < n:
j = i + 1
while j < n and c[j] == c[i]:
j += 1
if x == c[i] and j - i > 1:
r = max(r, DOIT(i, j) + j - i)
i = j
print(r)
``` | output | 1 | 18,061 | 7 | 36,123 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.