message stringlengths 2 67k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 463 109k | cluster float64 19 19 | __index_level_0__ int64 926 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Before the start of the football season in Berland a strange magic ritual is held. The most experienced magicians have to find a magic matrix of the size n × n (n is even number). Gods will never allow to start the championship without it. Matrix should contain integers from 0 to n - 1, main diagonal should contain only zeroes and matrix should be symmetric. Moreover, all numbers in each row should be different. Magicians are very tired of the thinking process, so they ask you to write a program to find such matrix.
Input
The first line contains one integer n (2 ≤ n ≤ 1000), n is even.
Output
Output n lines with n numbers each — the required matrix. Separate numbers with spaces. If there are several solutions, output any.
Examples
Input
2
Output
0 1
1 0
Input
4
Output
0 1 3 2
1 0 2 3
3 2 0 1
2 3 1 0 | instruction | 0 | 31,111 | 19 | 62,222 |
Tags: constructive algorithms
Correct Solution:
```
import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n = int(input())
if n == 2:
print('0 1\n1 0')
exit()
matrix = [[0] * n for _ in range(n)]
for i in range(n - 1):
for j in range(n - 1):
matrix[i][j] = (i + j) % (n - 1)
for i in range(n - 1):
matrix[i][n - i - 1] = matrix[n - i - 1][i] = n - 1
matrix[i][i] = 0
if i > 0:
matrix[i][-1] = matrix[-1][i] = (matrix[i - 1][i] + 1) % (n - 1)
ans = '\n'.join(' '.join(map(str, matrix[i])) for i in range(n))
sys.stdout.buffer.write(ans.encode('utf-8'))
``` | output | 1 | 31,111 | 19 | 62,223 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Before the start of the football season in Berland a strange magic ritual is held. The most experienced magicians have to find a magic matrix of the size n × n (n is even number). Gods will never allow to start the championship without it. Matrix should contain integers from 0 to n - 1, main diagonal should contain only zeroes and matrix should be symmetric. Moreover, all numbers in each row should be different. Magicians are very tired of the thinking process, so they ask you to write a program to find such matrix.
Input
The first line contains one integer n (2 ≤ n ≤ 1000), n is even.
Output
Output n lines with n numbers each — the required matrix. Separate numbers with spaces. If there are several solutions, output any.
Examples
Input
2
Output
0 1
1 0
Input
4
Output
0 1 3 2
1 0 2 3
3 2 0 1
2 3 1 0 | instruction | 0 | 31,114 | 19 | 62,228 |
Tags: constructive algorithms
Correct Solution:
```
import sys
from array import array # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
n = int(input())
matrix = [[0] * n for _ in range(n)]
for i in range(n - 1):
for j in range(n - 1):
matrix[i][j] = i + j - (n - 1 if i + j >= n - 1 else 0)
matrix[i][-1] = matrix[-1][i] = (matrix[i - 1][i] + 1) % (n - 1)
matrix[i][n - i - 1] = matrix[n - i - 1][i] = n - 1
matrix[i][i] = 0
ans = '\n'.join(' '.join(map(str, matrix[i])) for i in range(n))
sys.stdout.buffer.write(ans.encode('utf-8'))
``` | output | 1 | 31,114 | 19 | 62,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Before the start of the football season in Berland a strange magic ritual is held. The most experienced magicians have to find a magic matrix of the size n × n (n is even number). Gods will never allow to start the championship without it. Matrix should contain integers from 0 to n - 1, main diagonal should contain only zeroes and matrix should be symmetric. Moreover, all numbers in each row should be different. Magicians are very tired of the thinking process, so they ask you to write a program to find such matrix.
Input
The first line contains one integer n (2 ≤ n ≤ 1000), n is even.
Output
Output n lines with n numbers each — the required matrix. Separate numbers with spaces. If there are several solutions, output any.
Examples
Input
2
Output
0 1
1 0
Input
4
Output
0 1 3 2
1 0 2 3
3 2 0 1
2 3 1 0
Submitted Solution:
```
class A:
def rotate_keypad(self, keypad):
reversed_rows = list(reversed(keypad))
return ["".join(list(reversed(x))) for x in reversed_rows]
def solve(self):
keypad = [input(), input(), input()]
if keypad == self.rotate_keypad(keypad):
print("YES")
else:
print("NO")
class B:
def solve(self):
alice = input()
bob = input()
if bob[0] == '0' and alice[0] != '0':
print("WRONG_ANSWER")
return
bob = int(bob)
from itertools import permutations
smallest = int(alice)
if smallest == 0:
if bob == 0:
print("OK")
else:
print("WRONG_ANSWER")
else:
smallest = min([int("".join(list(perm))) for perm in permutations(sorted(alice)) if perm[0] != '0'])
if smallest == bob:
print("OK")
else:
print("WRONG_ANSWER")
class C:
def solve(self):
[n, m] = [int(x) for x in input().split(" ")]
prices = sorted([int(x) for x in input().split(" ")])
fruits = []
for i in range(m):
fruits.append(input())
from collections import Counter
frequent_fruits = [f for (f, p) in Counter(fruits).most_common()]
price_assignment = {}
for f, p in zip(frequent_fruits, prices):
price_assignment[f] = p
smallest_price = sum([price_assignment[f] for f in fruits])
for f, p in zip(frequent_fruits, list(reversed(prices))):
price_assignment[f] = p
largest_price = sum([price_assignment[f] for f in fruits])
print("{} {}".format(smallest_price, largest_price))
class D:
def solve(self):
n = int(input())
ladies = []
for x in input().split(" "):
ladies.append([x])
for i, x in enumerate(input().split(" ")):
ladies[i].append(x)
for i, x in enumerate(input().split(" ")):
ladies[i].append(x)
self_murderers = 0
for i in range(n):
if any([ladies[i][0] < ladies[x][0] and\
ladies[i][1] < ladies[x][1] and\
ladies[i][2] < ladies[x][2] for x in range(n) if x != i]):
self_murderers += 1
print(self_murderers)
class E:
def generate_matrix(self, i, j, n, matrix):
if i == j:
matrix[i][j] = 0
else:
if matrix[i][j] == 0:
used_numbers = set(matrix[i]).union(matrix[j])
for index in range(2**(2*n)):
if index not in used_numbers:
matrix[i][j] = index
matrix[j][i] = index
break
def solve(self):
n = int(input())
matrix = [[0 for i in range(n)] for j in range(n)]
for i in range(n):
for j in range(n):
self.generate_matrix(i, j, n, matrix)
print("\n".join([" ".join([str(y) for y in x]) for x in matrix]))
E().solve()
``` | instruction | 0 | 31,115 | 19 | 62,230 |
No | output | 1 | 31,115 | 19 | 62,231 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left. | instruction | 0 | 31,139 | 19 | 62,278 |
Tags: games, greedy, implementation
Correct Solution:
```
def countSetBits(n):
count = 0
while (n):
count += n & 1
n >>= 1
return count
import math
def mycool(i,j,l):
for oo in range(m):
if(l[i][oo]==1):
return 0
for oo in range(n):
if(l[oo][j]==1):
return 0
return 1
t=int(input())
while t:
t-=1
n,m=map(int,input().split())
l = []
for i in range(n):
r = list(map(int, input().split()))
l.append(r[:])
cnt=0
for i in range(n):
for j in range(m):
if(mycool(i,j,l)):
cnt+=1
l[i][j]=1
if(cnt%2):
print("Ashish")
else:
print("Vivek")
``` | output | 1 | 31,139 | 19 | 62,279 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left. | instruction | 0 | 31,140 | 19 | 62,280 |
Tags: games, greedy, implementation
Correct Solution:
```
for lo in range(int(input())):
#n = int(input())
n,m = map(int,input().split())
ls = []
for i in range(n):
a = [int(x) for x in input().split()]
ls.append(a)
a = [ 0 for i in range(n)]
b = [ 0 for i in range(m)]
for i in range(n):
for j in range(m):
if ls[i][j]==1:
a[i]=1
b[j]=1
c=c1=0
for i in range(n):
if a[i]==0:
c+=1
for j in range(m):
if b[j]==0:
c1+=1
res = min(c,c1)
if res%2!=0:
print("Ashish")
else:
print("Vivek")
``` | output | 1 | 31,140 | 19 | 62,281 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left. | instruction | 0 | 31,141 | 19 | 62,282 |
Tags: games, greedy, implementation
Correct Solution:
```
from sys import stdin, exit, setrecursionlimit
from math import *
from collections import deque
setrecursionlimit(10000000)
input = stdin.readline
lmi = lambda: list(map(int, input().split()))
mi = lambda: map(int, input().split())
si = lambda: input().strip('\n')
ssi = lambda: input().strip('\n').split()
for _ in range(int(input())):
n, m = mi()
grid = [lmi() for i in range(n)]
a = [False for i in range(n)]
b = [False for i in range(m)]
cnt = n
cnt2 = m
for i in range(n):
if 1 in grid[i]:
a[i] = True
cnt -= 1
for j in range(m):
if any(1 == grid[i][j] for i in range(n)):
b[j] = True
cnt2 -= 1
print("Vivek" if min(cnt, cnt2) % 2 == 0 else "Ashish")
``` | output | 1 | 31,141 | 19 | 62,283 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left. | instruction | 0 | 31,142 | 19 | 62,284 |
Tags: games, greedy, implementation
Correct Solution:
```
from sys import stdin, stdout
def main():
t = int(stdin.readline())
for _ in range(t):
n,m = list(map(int, stdin.readline().split()))
ta = []
for _ in range(n):
arr = list(map(int, stdin.readline().split()))
ta.append(arr)
taken_i = [False] * n
taken_j = [False] * m
for i in range(n):
for j in range(m):
if ta[i][j] == 1:
taken_i[i] = True
taken_j[j] = True
cnt = 0
for i in range(n):
for j in range(m):
if taken_i[i] == False and taken_j[j] == False:
taken_i[i] = True
taken_j[j] = True
cnt += 1
if cnt % 2 == 0:
stdout.write("Vivek\n")
else:
stdout.write("Ashish\n")
main()
``` | output | 1 | 31,142 | 19 | 62,285 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left. | instruction | 0 | 31,143 | 19 | 62,286 |
Tags: games, greedy, implementation
Correct Solution:
```
for _ in range(int(input())):
n,m=map(int,input().split())
l=[]
for i in range(n):
temp=list(map(int,input().split()))
l.append(temp)
a=[0]*n
b=[0]*m
for i in range(n):
for j in range(m):
if(l[i][j]==1):
a[i]=1
b[j]=1
x1=len(a)-sum(a)
x2=len(b)-sum(b)
if(x1<x2):
c=0
for i in range(n):
if(a[i]==0):
j=0
while(b[j]!=0):
j+=1
break
b[j]=1
a[i]=1
c+=1
if(c%2==0):
print("Vivek")
else:
print("Ashish")
else:
c=0
for i in range(m):
if(b[i]==0):
j=0
while(a[j]!=0):
j+=1
break
a[j]=1
b[i]=1
c+=1
if(c%2==0):
print("Vivek")
else:
print("Ashish")
``` | output | 1 | 31,143 | 19 | 62,287 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left. | instruction | 0 | 31,144 | 19 | 62,288 |
Tags: games, greedy, implementation
Correct Solution:
```
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now----------------------------------------------------
for t in range (int(input())):
n,m=map(int,input().split())
row=[0]*n
column=[0]*m
a=[[0 for i in range (m)]for j in range (n)]
for i in range (n):
curr=0
b=list(map(int,input().split()))
for j in range (m):
a[i][j]=b[j]
if b[j]==1:
curr+=1
column[j]+=1
row[i]+=curr
tot=0
#print(row)
#print(column)
for i in row:
if i!=0:
continue
for j in range (m):
if column[j]==0:
column[j]=1
tot+=1
break
#print(tot)
if tot%2==1:
print("Ashish")
else:
print("Vivek")
``` | output | 1 | 31,144 | 19 | 62,289 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left. | instruction | 0 | 31,145 | 19 | 62,290 |
Tags: games, greedy, implementation
Correct Solution:
```
t=int(input())
for _ in range(t):
n,m=map(int,input().split())
rowmat=[]
for i in range(n):
rowmat.append(list(map(int,input().split())))
clmat=[]
for i in range(m):
l=[]
for j in range(n):
l.append(rowmat[j][i])
clmat.append(l)
places=0
a=0
b=0
for i in range(n):
if sum(rowmat[i])==0:
a+=1
for j in range(m):
if sum(clmat[j])==0:
b+=1
#print(rowmat)
#print(clmat)
#print(places)
places=min(a,b)
if places%2==0:
print("Vivek")
else:
print("Ashish")
#4
#2 2
#0 0
#0 0
#2 2
#0 0
#0 1
#2 3
#1 0 1
#1 1 0
#3 3
#1 0 0
#0 0 0
#1 0 0
``` | output | 1 | 31,145 | 19 | 62,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left. | instruction | 0 | 31,146 | 19 | 62,292 |
Tags: games, greedy, implementation
Correct Solution:
```
for _ in range(int(input())):
n, m = map(int, input().split())
arr = [list(map(int, input().split())) for _ in range(n)]
rows = 0
for i in range(n):
if 1 in arr[i]:
rows += 1
rows = n-rows
cols = 0
for j in range(m):
for i in range(n):
if arr[i][j] == 1:
cols += 1
break
cols = m-cols
if min(cols, rows) % 2 == 0:
print("Vivek")
else:
print("Ashish")
``` | output | 1 | 31,146 | 19 | 62,293 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left.
Submitted Solution:
```
import math as m
t=int(input())
for _ in range(t):
n,m=list(map(int,input().split()))
a=[]
for i in range(n):
a.append(list(map(int,input().split())))
c=0
for i in range(n):
for j in range(m):
if a[i][j]==0:
if 1 not in a[i]:
e=0
for k in range(n):
if a[k][j]==1:
e=1
break
if e==0:
a[i][j]=1
c+=1
if c%2==0:
print("Vivek")
else:
print("Ashish")
``` | instruction | 0 | 31,147 | 19 | 62,294 |
Yes | output | 1 | 31,147 | 19 | 62,295 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left.
Submitted Solution:
```
t = int(input())
for i in range(0, t):
n, m = map(int, input().split())
row = [False for i in range(n)]
col = [False for i in range(m)]
for i in range(n):
x = []
x = list(map(int, input().split()))
for j in range(m):
if (x[j] == 1):
row[i] = True
col[j] = True
cnt_row = 0
cnt_col = 0
for i in range(n):
if(row[i] == 0):
cnt_row += 1
for j in range(m):
if(col[j] == 0):
cnt_col += 1
if(min(cnt_row, cnt_col)%2):
print("Ashish")
else:
print("Vivek")
``` | instruction | 0 | 31,148 | 19 | 62,296 |
Yes | output | 1 | 31,148 | 19 | 62,297 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left.
Submitted Solution:
```
def transpose(matrix):
res = []
n = len(matrix)
m = len(matrix[0])
for j in range(m):
tmp = []
for i in range(n):
tmp = tmp + [matrix[i][j]]
res = res + [tmp]
return res
for i in range(int(input())):
x, y = map(int, input().split())
matrix = []
for j in range(x):
matrix.append(input().split())
rows = 0
cols = 0
transparency = transpose(matrix)
for arr in matrix:
if '1' not in arr:
rows += 1
for row in range(y):
for col in range(x):
transparency[row][col] = matrix[col][row]
for arr in transparency:
if '1' not in arr:
cols += 1
if not min(rows, cols) % 2:
print('Vivek')
else:
print('Ashish')
``` | instruction | 0 | 31,149 | 19 | 62,298 |
Yes | output | 1 | 31,149 | 19 | 62,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left.
Submitted Solution:
```
T = int(input())
for _ in range(T):
n,m = map(int,input().split())
a = []
r,c = 0,0
for i in range(n):
ar = list(map(int,input().split()))
a.append(ar)
for i in range(n):
for j in range(m):
if a[i][j] == 1:
break
else:
r += 1
for k in range(m):
for l in range(n):
if a[l][k] == 1:
break
else:
c += 1
if min(r,c)%2 != 0:
print("Ashish")
else:
print("Vivek")
``` | instruction | 0 | 31,150 | 19 | 62,300 |
Yes | output | 1 | 31,150 | 19 | 62,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left.
Submitted Solution:
```
t=int(input())
while t>0:
t-=1
c=0
n,m=map(int,input().split())
l=[]
for i in range(n):
p=list(map(int,input().split()))
if 1 not in p:
c+=1
l.append(p)
flag=0
if c==0:
print("Vivek")
else:
for i in range(m):
k=0
for j in range(n):
if l[j][i]==1:
k=1
break
if k==0:
flag+=1
#print("col=",flag,"row=",c)
if flag==c:
if c%2==0:
print("Vivek")
else:
print("Ashish")
else:
a=abs(flag-c)
if a%2==0:
print("Vivek")
else:
print("Ashish")
``` | instruction | 0 | 31,151 | 19 | 62,302 |
No | output | 1 | 31,151 | 19 | 62,303 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left.
Submitted Solution:
```
for _ in range(int(input())):
n, m = map(int, input().split())
mat = []
for i in range(n):
mat.append(list(map(int, input().split())))
non_move_x = []
non_move_y = []
# for x, i in enumerate(mat):
# for y, j in enumerate(i):
# if j == 1:
# non_move_x.append(x)
# non_move_y.append(y)
zero_count = 0
for x, i in enumerate(mat):
for y, j in enumerate(i):
if j == 1:
non_move_x.append(x)
non_move_y.append(y)
elif x in non_move_x or y in non_move_y:
continue
else:
zero_count += 1
non_move_x.append(x)
non_move_y.append(y)
ans = ["Vivek", "Ashish"]
print(ans[zero_count % 2])
``` | instruction | 0 | 31,152 | 19 | 62,304 |
No | output | 1 | 31,152 | 19 | 62,305 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left.
Submitted Solution:
```
n=int(input())
for i in range(n):
a,b=map(int,input().split())
r=[]
r1=0
for i in range(a):
k=0
l=list(map(int,input().split()))
r.append(l)
for i in l:
k=k+i
if(k==0):
r1=r1+1
# print(r1)
c=0
for i in range(b):
r2=0
for j in range(a):
r2=r2+r[j][i]
if(r2==0):
c=c+1
# print(c)
sol=int((r1+c)/2)
if(sol%2==0):
print('Vivek')
else:
print('Ashish')
``` | instruction | 0 | 31,153 | 19 | 62,306 |
No | output | 1 | 31,153 | 19 | 62,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ashish and Vivek play a game on a matrix consisting of n rows and m columns, where they take turns claiming cells. Unclaimed cells are represented by 0, while claimed cells are represented by 1. The initial state of the matrix is given. There can be some claimed cells in the initial state.
In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.
If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.
Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.
Input
The first line consists of a single integer t (1 ≤ t ≤ 50) — the number of test cases. The description of the test cases follows.
The first line of each test case consists of two space-separated integers n, m (1 ≤ n, m ≤ 50) — the number of rows and columns in the matrix.
The following n lines consist of m integers each, the j-th integer on the i-th line denoting a_{i,j} (a_{i,j} ∈ \{0, 1\}).
Output
For each test case if Ashish wins the game print "Ashish" otherwise print "Vivek" (without quotes).
Example
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0
Output
Vivek
Ashish
Vivek
Ashish
Note
For the first case: One possible scenario could be: Ashish claims cell (1, 1), Vivek then claims cell (2, 2). Ashish can neither claim cell (1, 2), nor cell (2, 1) as cells (1, 1) and (2, 2) are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win.
For the second case: Ashish claims cell (1, 1), the only cell that can be claimed in the first move. After that Vivek has no moves left.
For the third case: Ashish cannot make a move, so Vivek wins.
For the fourth case: If Ashish claims cell (2, 3), Vivek will have no moves left.
Submitted Solution:
```
"""609C"""
# import math
# import sys
def main():
n ,m= map(int,input().split())
# a = list(map(int,input().split()))
arr = []
for _ in range(n):
arr.append( list(map(int,input().split())) )
dpr = [0 for _ in range(n)]
dpc = [0 for _ in range(m)]
for i in range(n):
flag = True
for j in range(m):
if arr[i][j]==1:
dpr[i]=1
dpc[j]=1
mx = max(sum(dpr),sum(dpc))
ans = max(0,min(m,n)-mx)
if ans%2:
print("Ashish")
else:
print("Vivek")
return
# main()
def test():
t = int(input())
while t:
main()
t-=1
test()
``` | instruction | 0 | 31,154 | 19 | 62,308 |
No | output | 1 | 31,154 | 19 | 62,309 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel is playing a game with numbers now.
Ciel has n positive integers: x1, x2, ..., xn. She can do the following operation as many times as needed: select two different indexes i and j such that xi > xj hold, and then apply assignment xi = xi - xj. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
Input
The first line contains an integer n (2 ≤ n ≤ 100). Then the second line contains n integers: x1, x2, ..., xn (1 ≤ xi ≤ 100).
Output
Output a single integer — the required minimal sum.
Examples
Input
2
1 2
Output
2
Input
3
2 4 6
Output
6
Input
2
12 18
Output
12
Input
5
45 12 27 30 18
Output
15
Note
In the first example the optimal way is to do the assignment: x2 = x2 - x1.
In the second example the optimal sequence of operations is: x3 = x3 - x2, x2 = x2 - x1. | instruction | 0 | 31,309 | 19 | 62,618 |
Tags: greedy, math
Correct Solution:
```
import sys
from collections import defaultdict
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return (int(input()))
def inlt():
return (list(map(int, input().split())))
def insr():
s = input()
return (list(s[:len(s) - 1]))
def invr():
return (map(int, input().split()))
def main():
d = inp()
v = inlt()
v.sort()
while True:
f = False
for i in range(1, d):
if v[i]>v[i-1]:
r = v[i] - v[i - 1]
v[i] = r
f = True
break
if not f:
break
v.sort()
print(sum(v))
if __name__ == "__main__":
# sys.setrecursionlimit(10 ** 6)
# threading.stack_size(10 ** 8)
# t = threading.Thread(target=main)
# t.start()
# t.join()
main()
``` | output | 1 | 31,309 | 19 | 62,619 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel is playing a game with numbers now.
Ciel has n positive integers: x1, x2, ..., xn. She can do the following operation as many times as needed: select two different indexes i and j such that xi > xj hold, and then apply assignment xi = xi - xj. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
Input
The first line contains an integer n (2 ≤ n ≤ 100). Then the second line contains n integers: x1, x2, ..., xn (1 ≤ xi ≤ 100).
Output
Output a single integer — the required minimal sum.
Examples
Input
2
1 2
Output
2
Input
3
2 4 6
Output
6
Input
2
12 18
Output
12
Input
5
45 12 27 30 18
Output
15
Note
In the first example the optimal way is to do the assignment: x2 = x2 - x1.
In the second example the optimal sequence of operations is: x3 = x3 - x2, x2 = x2 - x1. | instruction | 0 | 31,311 | 19 | 62,622 |
Tags: greedy, math
Correct Solution:
```
n = int(input())
x = list(map(int, input().split()))
while True:
x.sort()
if x[-2] == 0:
print(x[-1]*n)
exit()
else:
x[-1] = x[-1] - x[-2]
``` | output | 1 | 31,311 | 19 | 62,623 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel is playing a game with numbers now.
Ciel has n positive integers: x1, x2, ..., xn. She can do the following operation as many times as needed: select two different indexes i and j such that xi > xj hold, and then apply assignment xi = xi - xj. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
Input
The first line contains an integer n (2 ≤ n ≤ 100). Then the second line contains n integers: x1, x2, ..., xn (1 ≤ xi ≤ 100).
Output
Output a single integer — the required minimal sum.
Examples
Input
2
1 2
Output
2
Input
3
2 4 6
Output
6
Input
2
12 18
Output
12
Input
5
45 12 27 30 18
Output
15
Note
In the first example the optimal way is to do the assignment: x2 = x2 - x1.
In the second example the optimal sequence of operations is: x3 = x3 - x2, x2 = x2 - x1. | instruction | 0 | 31,312 | 19 | 62,624 |
Tags: greedy, math
Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
a.sort()
while True:
k = 0
for i in range(n-1,0,-1):
if a[i] > a[i-1]:
a[i]=a[i]-a[i-1]
k = k + 1
a.sort()
if k == 0:
break
print(sum(a))
``` | output | 1 | 31,312 | 19 | 62,625 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel is playing a game with numbers now.
Ciel has n positive integers: x1, x2, ..., xn. She can do the following operation as many times as needed: select two different indexes i and j such that xi > xj hold, and then apply assignment xi = xi - xj. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
Input
The first line contains an integer n (2 ≤ n ≤ 100). Then the second line contains n integers: x1, x2, ..., xn (1 ≤ xi ≤ 100).
Output
Output a single integer — the required minimal sum.
Examples
Input
2
1 2
Output
2
Input
3
2 4 6
Output
6
Input
2
12 18
Output
12
Input
5
45 12 27 30 18
Output
15
Note
In the first example the optimal way is to do the assignment: x2 = x2 - x1.
In the second example the optimal sequence of operations is: x3 = x3 - x2, x2 = x2 - x1. | instruction | 0 | 31,313 | 19 | 62,626 |
Tags: greedy, math
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
flag=0
for i in range(100):
a.sort()
for i in range(len(a)-1,0,-1):
if((a[i]-a[i-1])>0):
a[i]=a[i]-a[i-1]
print(sum(a))
``` | output | 1 | 31,313 | 19 | 62,627 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Fox Ciel is playing a game with numbers now.
Ciel has n positive integers: x1, x2, ..., xn. She can do the following operation as many times as needed: select two different indexes i and j such that xi > xj hold, and then apply assignment xi = xi - xj. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
Input
The first line contains an integer n (2 ≤ n ≤ 100). Then the second line contains n integers: x1, x2, ..., xn (1 ≤ xi ≤ 100).
Output
Output a single integer — the required minimal sum.
Examples
Input
2
1 2
Output
2
Input
3
2 4 6
Output
6
Input
2
12 18
Output
12
Input
5
45 12 27 30 18
Output
15
Note
In the first example the optimal way is to do the assignment: x2 = x2 - x1.
In the second example the optimal sequence of operations is: x3 = x3 - x2, x2 = x2 - x1. | instruction | 0 | 31,315 | 19 | 62,630 |
Tags: greedy, math
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
for i in range(1000):
a=sorted(a)
a.reverse()
for j in range(n-1):
if(a[j]>a[j+1]):
a[j]-=a[j+1]
print(sum(a))
``` | output | 1 | 31,315 | 19 | 62,631 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel is playing a game with numbers now.
Ciel has n positive integers: x1, x2, ..., xn. She can do the following operation as many times as needed: select two different indexes i and j such that xi > xj hold, and then apply assignment xi = xi - xj. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
Input
The first line contains an integer n (2 ≤ n ≤ 100). Then the second line contains n integers: x1, x2, ..., xn (1 ≤ xi ≤ 100).
Output
Output a single integer — the required minimal sum.
Examples
Input
2
1 2
Output
2
Input
3
2 4 6
Output
6
Input
2
12 18
Output
12
Input
5
45 12 27 30 18
Output
15
Note
In the first example the optimal way is to do the assignment: x2 = x2 - x1.
In the second example the optimal sequence of operations is: x3 = x3 - x2, x2 = x2 - x1.
Submitted Solution:
```
import copy
n = int(input())
x = list(map(int, input().split()))
x = sorted(x)
y = []
while x[0] != x[-1]:
for i in range(n-1):
if x[-i-1] > x[-i-2]:
y.append(x[-i-1]-x[-i-2])
else:
y.append(x[-i-1])
y.append(x[0])
x = copy.copy(y)
x = sorted(x)
y = []
print(x[0]*n)
``` | instruction | 0 | 31,317 | 19 | 62,634 |
Yes | output | 1 | 31,317 | 19 | 62,635 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel is playing a game with numbers now.
Ciel has n positive integers: x1, x2, ..., xn. She can do the following operation as many times as needed: select two different indexes i and j such that xi > xj hold, and then apply assignment xi = xi - xj. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
Input
The first line contains an integer n (2 ≤ n ≤ 100). Then the second line contains n integers: x1, x2, ..., xn (1 ≤ xi ≤ 100).
Output
Output a single integer — the required minimal sum.
Examples
Input
2
1 2
Output
2
Input
3
2 4 6
Output
6
Input
2
12 18
Output
12
Input
5
45 12 27 30 18
Output
15
Note
In the first example the optimal way is to do the assignment: x2 = x2 - x1.
In the second example the optimal sequence of operations is: x3 = x3 - x2, x2 = x2 - x1.
Submitted Solution:
```
import sys
sys.setrecursionlimit(1500)
def fun(list):
list=sorted(list)
c,d,i=list[0],len(list),1
if list.count(c)==d:return list
else:
list=sorted(list)
while i<d:
if list[i]==c:
i=i+1
continue
else:
list[i]=list[i]-c
i=i+1
return(fun(list))
a,list=int(input()),[int(x) for x in input().split()]
print(sum(fun(list)))
``` | instruction | 0 | 31,318 | 19 | 62,636 |
Yes | output | 1 | 31,318 | 19 | 62,637 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel is playing a game with numbers now.
Ciel has n positive integers: x1, x2, ..., xn. She can do the following operation as many times as needed: select two different indexes i and j such that xi > xj hold, and then apply assignment xi = xi - xj. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
Input
The first line contains an integer n (2 ≤ n ≤ 100). Then the second line contains n integers: x1, x2, ..., xn (1 ≤ xi ≤ 100).
Output
Output a single integer — the required minimal sum.
Examples
Input
2
1 2
Output
2
Input
3
2 4 6
Output
6
Input
2
12 18
Output
12
Input
5
45 12 27 30 18
Output
15
Note
In the first example the optimal way is to do the assignment: x2 = x2 - x1.
In the second example the optimal sequence of operations is: x3 = x3 - x2, x2 = x2 - x1.
Submitted Solution:
```
n = int(input())
stro = list(map(int, input().split()))
while min(stro)!=max(stro):
for i in range(n):
for j in range(n):
if stro[i]>stro[j]:
stro[i]=stro[i]-stro[j]
print(sum(stro))
``` | instruction | 0 | 31,319 | 19 | 62,638 |
Yes | output | 1 | 31,319 | 19 | 62,639 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel is playing a game with numbers now.
Ciel has n positive integers: x1, x2, ..., xn. She can do the following operation as many times as needed: select two different indexes i and j such that xi > xj hold, and then apply assignment xi = xi - xj. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
Input
The first line contains an integer n (2 ≤ n ≤ 100). Then the second line contains n integers: x1, x2, ..., xn (1 ≤ xi ≤ 100).
Output
Output a single integer — the required minimal sum.
Examples
Input
2
1 2
Output
2
Input
3
2 4 6
Output
6
Input
2
12 18
Output
12
Input
5
45 12 27 30 18
Output
15
Note
In the first example the optimal way is to do the assignment: x2 = x2 - x1.
In the second example the optimal sequence of operations is: x3 = x3 - x2, x2 = x2 - x1.
Submitted Solution:
```
n = int(input())
x = list(map(int,input().split()))
m = 101
if x.count(x[0])==len(x) or n==2:
print(min(x)*2)
else:
for i in x:
t = []
for j in x:
if i!=j:
t.append(abs(i-j))
m = min(m,min(t))
print(m*n)
``` | instruction | 0 | 31,321 | 19 | 62,642 |
No | output | 1 | 31,321 | 19 | 62,643 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Fox Ciel is playing a game with numbers now.
Ciel has n positive integers: x1, x2, ..., xn. She can do the following operation as many times as needed: select two different indexes i and j such that xi > xj hold, and then apply assignment xi = xi - xj. The goal is to make the sum of all numbers as small as possible.
Please help Ciel to find this minimal sum.
Input
The first line contains an integer n (2 ≤ n ≤ 100). Then the second line contains n integers: x1, x2, ..., xn (1 ≤ xi ≤ 100).
Output
Output a single integer — the required minimal sum.
Examples
Input
2
1 2
Output
2
Input
3
2 4 6
Output
6
Input
2
12 18
Output
12
Input
5
45 12 27 30 18
Output
15
Note
In the first example the optimal way is to do the assignment: x2 = x2 - x1.
In the second example the optimal sequence of operations is: x3 = x3 - x2, x2 = x2 - x1.
Submitted Solution:
```
n = int(input())
x = []
m = map(int,input().split())
for k in m:
x.append(k)
x.sort(reverse=True)
n1 = n
while n1>0:
n1-=1
x.sort(reverse=True)
for i in range(n-1):
if x[i]>x[i+1]:
x[i]-=x[i+1]
sum = 0
for i in range(n):
sum += x[i]
print(sum)
``` | instruction | 0 | 31,323 | 19 | 62,646 |
No | output | 1 | 31,323 | 19 | 62,647 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Everyone who has played Cut the Rope knows full well how the gameplay is organized. All levels in the game are divided into boxes. Initially only one box with some levels is available. Player should complete levels to earn stars, collecting stars opens new box with levels.
<image>
Imagine that you are playing Cut the Rope for the first time. Currently you have only the levels of the first box (by the way, it is called "Cardboard Box"). Each level is characterized by two integers: ai — how long it takes to complete the level for one star, bi — how long it takes to complete the level for two stars (ai < bi).
You want to open the next box as quickly as possible. So, you need to earn at least w stars. How do make it happen? Note that the level can be passed only once: either for one star or for two. You do not necessarily need to pass all the levels.
Input
The first line contains two integers n and w (1 ≤ n ≤ 3·105; 1 ≤ w ≤ 2n) — the number of levels in the first box and the number of stars you need to open another box. Each of the following n lines contains two integers ai and bi (1 ≤ ai < bi ≤ 109) — the attributes of the i-th level.
Output
In the first line print integer t — the minimum time you need to open the next box.
In the next line, print n digits without spaces — the description of the optimal scenario:
* if you need to pass the i-th level for one star, the i-th digit should equal 1;
* if you need to pass the i-th level for two stars, the i-th digit should equal 2;
* if you do not need to pass the i-th level at all, the i-th digit should equal 0.
Examples
Input
2 3
1 2
1 2
Output
3
12
Input
5 3
10 20
5 10
10 20
6 9
25 30
Output
14
01020
Note
In the first test sample, answer 21 is also assumed correct.
Submitted Solution:
```
n, w = [int(c) for c in input().split()]
levels = []
for i in range(n):
levels.append([int(c) for c in input().split()])
count = [[-1 for j in range(w + 1)] for i in range(n)]
count[0][w] = [0, '0']
count[0][w - 1] = [levels[0][0], '1']
count[0][w - 2] = [levels[0][1], '2']
def count_res(cur, stars):
if cur == -1:
return [0, '']
if stars <= 0:
return [0, '0' * cur]
if count[cur][w - stars] != -1:
return count[cur][w - stars]
else:
a = count_res(cur - 1, stars)
b = count_res(cur - 1, stars - 1)
c = count_res(cur - 1, stars - 2)
av = a[0]
bv = b[0] + levels[cur][0]
cv = c[0] + levels[cur][1]
if a[1] != '0' and av < bv and av < cv:
count[cur][w - stars] = [av, a[1] + '0']
elif bv < cv:
count[cur][w - stars] = [bv, b[1] + '1']
else:
count[cur][w - stars] = [cv, c[1] + '2']
return count[cur][w - stars]
rrr = count_res(n - 1, w)
print(rrr[0])
print(('0' * (n - len(rrr[1]))) + rrr[1])
``` | instruction | 0 | 31,341 | 19 | 62,682 |
No | output | 1 | 31,341 | 19 | 62,683 |
Provide a correct Python 3 solution for this coding contest problem.
There are a number of ways to shuffle a deck of cards. Riffle shuffle is one such example. The following is how to perform riffle shuffle.
There is a deck of n cards. First, we divide it into two decks; deck A which consists of the top half of it and deck B of the bottom half. Deck A will have one more card when n is odd.
Next, c cards are pulled from bottom of deck A and are stacked on deck C, which is empty initially. Then c cards are pulled from bottom of deck B and stacked on deck C, likewise. This operation is repeated until deck A and B become empty. When the number of cards of deck A(B) is less than c, all cards are pulled. Finally we obtain shuffled deck C. See an example below:
- A single riffle operation where n = 9, c = 3
for given deck [0 1 2 3 4 5 6 7 8] (right is top)
- Step 0
deck A [4 5 6 7 8]
deck B [0 1 2 3]
deck C []
- Step 1
deck A [7 8]
deck B [0 1 2 3]
deck C [4 5 6]
- Step 2
deck A [7 8]
deck B [3]
deck C [4 5 6 0 1 2]
- Step 3
deck A []
deck B [3]
deck C [4 5 6 0 1 2 7 8]
- Step 4
deck A []
deck B []
deck C [4 5 6 0 1 2 7 8 3]
shuffled deck [4 5 6 0 1 2 7 8 3]
This operation, called riffle operation, is repeated several times.
Write a program that simulates Riffle shuffle and answer which card will be finally placed on the top of the deck.
Input
The input consists of multiple data sets. Each data set starts with a line containing two positive integers n(1 ≤ n ≤ 50) and r(1 ≤ r ≤ 50); n and r are the number of cards in the deck and the number of riffle operations, respectively.
r more positive integers follow, each of which represents a riffle operation. These riffle operations are performed in the listed order. Each integer represents c, which is explained above.
The end of the input is indicated by EOF. The number of data sets is less than 100.
Output
For each data set in the input, your program should print the number of the top card after the shuffle. Assume that at the beginning the cards are numbered from 0 to n-1, from the bottom to the top. Each number should be written in a sparate line without any superfluous characters such as leading or following spaces.
Example
Input
9 1
3
9 4
1 2 3 4
Output
3
0 | instruction | 0 | 31,719 | 19 | 63,438 |
"Correct Solution:
```
while True:
try:
n, r = map(int, input().split())
cc = list(map(int, input().split()))
card = [v for v in range(n)]
for c in cc:
A, B, C = card[n//2:], card[:n//2], []
while len(A) or len(B):
C += A[:c]
del A[:c]
C += B[:c]
del B[:c]
card = C
print(C[-1])
except: break
``` | output | 1 | 31,719 | 19 | 63,439 |
Provide a correct Python 3 solution for this coding contest problem.
There are a number of ways to shuffle a deck of cards. Riffle shuffle is one such example. The following is how to perform riffle shuffle.
There is a deck of n cards. First, we divide it into two decks; deck A which consists of the top half of it and deck B of the bottom half. Deck A will have one more card when n is odd.
Next, c cards are pulled from bottom of deck A and are stacked on deck C, which is empty initially. Then c cards are pulled from bottom of deck B and stacked on deck C, likewise. This operation is repeated until deck A and B become empty. When the number of cards of deck A(B) is less than c, all cards are pulled. Finally we obtain shuffled deck C. See an example below:
- A single riffle operation where n = 9, c = 3
for given deck [0 1 2 3 4 5 6 7 8] (right is top)
- Step 0
deck A [4 5 6 7 8]
deck B [0 1 2 3]
deck C []
- Step 1
deck A [7 8]
deck B [0 1 2 3]
deck C [4 5 6]
- Step 2
deck A [7 8]
deck B [3]
deck C [4 5 6 0 1 2]
- Step 3
deck A []
deck B [3]
deck C [4 5 6 0 1 2 7 8]
- Step 4
deck A []
deck B []
deck C [4 5 6 0 1 2 7 8 3]
shuffled deck [4 5 6 0 1 2 7 8 3]
This operation, called riffle operation, is repeated several times.
Write a program that simulates Riffle shuffle and answer which card will be finally placed on the top of the deck.
Input
The input consists of multiple data sets. Each data set starts with a line containing two positive integers n(1 ≤ n ≤ 50) and r(1 ≤ r ≤ 50); n and r are the number of cards in the deck and the number of riffle operations, respectively.
r more positive integers follow, each of which represents a riffle operation. These riffle operations are performed in the listed order. Each integer represents c, which is explained above.
The end of the input is indicated by EOF. The number of data sets is less than 100.
Output
For each data set in the input, your program should print the number of the top card after the shuffle. Assume that at the beginning the cards are numbered from 0 to n-1, from the bottom to the top. Each number should be written in a sparate line without any superfluous characters such as leading or following spaces.
Example
Input
9 1
3
9 4
1 2 3 4
Output
3
0 | instruction | 0 | 31,720 | 19 | 63,440 |
"Correct Solution:
```
import sys
lines=[]
for line in sys.stdin:
line= line.rstrip()
lines.append(line)
for i in range(len(lines)//2):
N,R=map(int,lines[2*i].split())
ops=list(map(int,lines[2*i+1].split()))
cards=[i for i in range(N)]
for c in ops:
deck_a=cards[N//2:N]
deck_b=cards[0:N//2]
deck_c=cards[0:0]
while len(deck_a)>0 or len(deck_b)>0:
d=deck_a[0:c]
deck_a=deck_a[c:]
deck_c+=d
d=deck_b[0:c]
deck_b=deck_b[c:]
deck_c+=d
cards=deck_c
print(cards[-1])
``` | output | 1 | 31,720 | 19 | 63,441 |
Provide a correct Python 3 solution for this coding contest problem.
There are a number of ways to shuffle a deck of cards. Riffle shuffle is one such example. The following is how to perform riffle shuffle.
There is a deck of n cards. First, we divide it into two decks; deck A which consists of the top half of it and deck B of the bottom half. Deck A will have one more card when n is odd.
Next, c cards are pulled from bottom of deck A and are stacked on deck C, which is empty initially. Then c cards are pulled from bottom of deck B and stacked on deck C, likewise. This operation is repeated until deck A and B become empty. When the number of cards of deck A(B) is less than c, all cards are pulled. Finally we obtain shuffled deck C. See an example below:
- A single riffle operation where n = 9, c = 3
for given deck [0 1 2 3 4 5 6 7 8] (right is top)
- Step 0
deck A [4 5 6 7 8]
deck B [0 1 2 3]
deck C []
- Step 1
deck A [7 8]
deck B [0 1 2 3]
deck C [4 5 6]
- Step 2
deck A [7 8]
deck B [3]
deck C [4 5 6 0 1 2]
- Step 3
deck A []
deck B [3]
deck C [4 5 6 0 1 2 7 8]
- Step 4
deck A []
deck B []
deck C [4 5 6 0 1 2 7 8 3]
shuffled deck [4 5 6 0 1 2 7 8 3]
This operation, called riffle operation, is repeated several times.
Write a program that simulates Riffle shuffle and answer which card will be finally placed on the top of the deck.
Input
The input consists of multiple data sets. Each data set starts with a line containing two positive integers n(1 ≤ n ≤ 50) and r(1 ≤ r ≤ 50); n and r are the number of cards in the deck and the number of riffle operations, respectively.
r more positive integers follow, each of which represents a riffle operation. These riffle operations are performed in the listed order. Each integer represents c, which is explained above.
The end of the input is indicated by EOF. The number of data sets is less than 100.
Output
For each data set in the input, your program should print the number of the top card after the shuffle. Assume that at the beginning the cards are numbered from 0 to n-1, from the bottom to the top. Each number should be written in a sparate line without any superfluous characters such as leading or following spaces.
Example
Input
9 1
3
9 4
1 2 3 4
Output
3
0 | instruction | 0 | 31,721 | 19 | 63,442 |
"Correct Solution:
```
try:
while 1:
N, R = map(int, input().split())
*C, = map(int, input().split())
*A, = range(N)
for c in C:
lb = N//2; la = N - lb
TA = A[N//2:]
TB = A[:N//2]
A = []
a = b = 0
while a < la and b < lb:
A.extend(TA[a:min(a+c, la)])
a += c
A.extend(TB[b:min(b+c, lb)])
b += c
if a < la:
A.extend(TA[a:])
if b < lb:
A.extend(TB[b:])
print(A[-1])
except EOFError:
...
``` | output | 1 | 31,721 | 19 | 63,443 |
Provide a correct Python 3 solution for this coding contest problem.
There are a number of ways to shuffle a deck of cards. Riffle shuffle is one such example. The following is how to perform riffle shuffle.
There is a deck of n cards. First, we divide it into two decks; deck A which consists of the top half of it and deck B of the bottom half. Deck A will have one more card when n is odd.
Next, c cards are pulled from bottom of deck A and are stacked on deck C, which is empty initially. Then c cards are pulled from bottom of deck B and stacked on deck C, likewise. This operation is repeated until deck A and B become empty. When the number of cards of deck A(B) is less than c, all cards are pulled. Finally we obtain shuffled deck C. See an example below:
- A single riffle operation where n = 9, c = 3
for given deck [0 1 2 3 4 5 6 7 8] (right is top)
- Step 0
deck A [4 5 6 7 8]
deck B [0 1 2 3]
deck C []
- Step 1
deck A [7 8]
deck B [0 1 2 3]
deck C [4 5 6]
- Step 2
deck A [7 8]
deck B [3]
deck C [4 5 6 0 1 2]
- Step 3
deck A []
deck B [3]
deck C [4 5 6 0 1 2 7 8]
- Step 4
deck A []
deck B []
deck C [4 5 6 0 1 2 7 8 3]
shuffled deck [4 5 6 0 1 2 7 8 3]
This operation, called riffle operation, is repeated several times.
Write a program that simulates Riffle shuffle and answer which card will be finally placed on the top of the deck.
Input
The input consists of multiple data sets. Each data set starts with a line containing two positive integers n(1 ≤ n ≤ 50) and r(1 ≤ r ≤ 50); n and r are the number of cards in the deck and the number of riffle operations, respectively.
r more positive integers follow, each of which represents a riffle operation. These riffle operations are performed in the listed order. Each integer represents c, which is explained above.
The end of the input is indicated by EOF. The number of data sets is less than 100.
Output
For each data set in the input, your program should print the number of the top card after the shuffle. Assume that at the beginning the cards are numbered from 0 to n-1, from the bottom to the top. Each number should be written in a sparate line without any superfluous characters such as leading or following spaces.
Example
Input
9 1
3
9 4
1 2 3 4
Output
3
0 | instruction | 0 | 31,722 | 19 | 63,444 |
"Correct Solution:
```
from collections import deque
import sys
def suffle(deck, c):
l = len(deck)
if l % 2 == 0: mid = l//2
else: mid = (l-1)//2
deckA = deck[mid:]
deckB = deck[:mid]
deckC = []
while(len(deckA) != 0 or len(deckB) != 0):
deckC.extend(deckA[:c])
deckA = deckA[c:]
deckC.extend(deckB[:c])
deckB = deckB[c:]
return deckC
while(True):
inp = sys.stdin.readline()
if not inp: break
deck = []
n, r = map(int, inp[:-1].split())
deck = [i for i in range(n)]
c_list = map(int, sys.stdin.readline()[:-1].split())
for c in c_list:
deck = suffle(deck, c)
print(deck[-1])
#print(" ".join(map(str, deck)))
``` | output | 1 | 31,722 | 19 | 63,445 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are a number of ways to shuffle a deck of cards. Riffle shuffle is one such example. The following is how to perform riffle shuffle.
There is a deck of n cards. First, we divide it into two decks; deck A which consists of the top half of it and deck B of the bottom half. Deck A will have one more card when n is odd.
Next, c cards are pulled from bottom of deck A and are stacked on deck C, which is empty initially. Then c cards are pulled from bottom of deck B and stacked on deck C, likewise. This operation is repeated until deck A and B become empty. When the number of cards of deck A(B) is less than c, all cards are pulled. Finally we obtain shuffled deck C. See an example below:
- A single riffle operation where n = 9, c = 3
for given deck [0 1 2 3 4 5 6 7 8] (right is top)
- Step 0
deck A [4 5 6 7 8]
deck B [0 1 2 3]
deck C []
- Step 1
deck A [7 8]
deck B [0 1 2 3]
deck C [4 5 6]
- Step 2
deck A [7 8]
deck B [3]
deck C [4 5 6 0 1 2]
- Step 3
deck A []
deck B [3]
deck C [4 5 6 0 1 2 7 8]
- Step 4
deck A []
deck B []
deck C [4 5 6 0 1 2 7 8 3]
shuffled deck [4 5 6 0 1 2 7 8 3]
This operation, called riffle operation, is repeated several times.
Write a program that simulates Riffle shuffle and answer which card will be finally placed on the top of the deck.
Input
The input consists of multiple data sets. Each data set starts with a line containing two positive integers n(1 ≤ n ≤ 50) and r(1 ≤ r ≤ 50); n and r are the number of cards in the deck and the number of riffle operations, respectively.
r more positive integers follow, each of which represents a riffle operation. These riffle operations are performed in the listed order. Each integer represents c, which is explained above.
The end of the input is indicated by EOF. The number of data sets is less than 100.
Output
For each data set in the input, your program should print the number of the top card after the shuffle. Assume that at the beginning the cards are numbered from 0 to n-1, from the bottom to the top. Each number should be written in a sparate line without any superfluous characters such as leading or following spaces.
Example
Input
9 1
3
9 4
1 2 3 4
Output
3
0
Submitted Solution:
```
while True:
try:
n, r = map(int, input().split())
c = list(map(int, input().split()))
card = [v for v in range(n)]
A, B, C = card[n//2:], card[:n//2], []
for k, v in zip(c, range(r)):
if v % 2 == 0:
C += A[:k]
del A[:k]
else:
C += B[:k]
del B[:k]
print(C[-1])
except: break
``` | instruction | 0 | 31,723 | 19 | 63,446 |
No | output | 1 | 31,723 | 19 | 63,447 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are a number of ways to shuffle a deck of cards. Riffle shuffle is one such example. The following is how to perform riffle shuffle.
There is a deck of n cards. First, we divide it into two decks; deck A which consists of the top half of it and deck B of the bottom half. Deck A will have one more card when n is odd.
Next, c cards are pulled from bottom of deck A and are stacked on deck C, which is empty initially. Then c cards are pulled from bottom of deck B and stacked on deck C, likewise. This operation is repeated until deck A and B become empty. When the number of cards of deck A(B) is less than c, all cards are pulled. Finally we obtain shuffled deck C. See an example below:
- A single riffle operation where n = 9, c = 3
for given deck [0 1 2 3 4 5 6 7 8] (right is top)
- Step 0
deck A [4 5 6 7 8]
deck B [0 1 2 3]
deck C []
- Step 1
deck A [7 8]
deck B [0 1 2 3]
deck C [4 5 6]
- Step 2
deck A [7 8]
deck B [3]
deck C [4 5 6 0 1 2]
- Step 3
deck A []
deck B [3]
deck C [4 5 6 0 1 2 7 8]
- Step 4
deck A []
deck B []
deck C [4 5 6 0 1 2 7 8 3]
shuffled deck [4 5 6 0 1 2 7 8 3]
This operation, called riffle operation, is repeated several times.
Write a program that simulates Riffle shuffle and answer which card will be finally placed on the top of the deck.
Input
The input consists of multiple data sets. Each data set starts with a line containing two positive integers n(1 ≤ n ≤ 50) and r(1 ≤ r ≤ 50); n and r are the number of cards in the deck and the number of riffle operations, respectively.
r more positive integers follow, each of which represents a riffle operation. These riffle operations are performed in the listed order. Each integer represents c, which is explained above.
The end of the input is indicated by EOF. The number of data sets is less than 100.
Output
For each data set in the input, your program should print the number of the top card after the shuffle. Assume that at the beginning the cards are numbered from 0 to n-1, from the bottom to the top. Each number should be written in a sparate line without any superfluous characters such as leading or following spaces.
Example
Input
9 1
3
9 4
1 2 3 4
Output
3
0
Submitted Solution:
```
while True:
try:
n, r = map(int, input().split())
c = list(map(int, input().split()))
card = [v for v in range(n)]
A, B, C = card[n//2:], card[:n//2], []
for k, v in zip(c, range(r)):
if v % 2 == 0:
C += A[:k]
del A[:k]
else:
C += B[:k]
del B[:k]
except: break
``` | instruction | 0 | 31,724 | 19 | 63,448 |
No | output | 1 | 31,724 | 19 | 63,449 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are a number of ways to shuffle a deck of cards. Riffle shuffle is one such example. The following is how to perform riffle shuffle.
There is a deck of n cards. First, we divide it into two decks; deck A which consists of the top half of it and deck B of the bottom half. Deck A will have one more card when n is odd.
Next, c cards are pulled from bottom of deck A and are stacked on deck C, which is empty initially. Then c cards are pulled from bottom of deck B and stacked on deck C, likewise. This operation is repeated until deck A and B become empty. When the number of cards of deck A(B) is less than c, all cards are pulled. Finally we obtain shuffled deck C. See an example below:
- A single riffle operation where n = 9, c = 3
for given deck [0 1 2 3 4 5 6 7 8] (right is top)
- Step 0
deck A [4 5 6 7 8]
deck B [0 1 2 3]
deck C []
- Step 1
deck A [7 8]
deck B [0 1 2 3]
deck C [4 5 6]
- Step 2
deck A [7 8]
deck B [3]
deck C [4 5 6 0 1 2]
- Step 3
deck A []
deck B [3]
deck C [4 5 6 0 1 2 7 8]
- Step 4
deck A []
deck B []
deck C [4 5 6 0 1 2 7 8 3]
shuffled deck [4 5 6 0 1 2 7 8 3]
This operation, called riffle operation, is repeated several times.
Write a program that simulates Riffle shuffle and answer which card will be finally placed on the top of the deck.
Input
The input consists of multiple data sets. Each data set starts with a line containing two positive integers n(1 ≤ n ≤ 50) and r(1 ≤ r ≤ 50); n and r are the number of cards in the deck and the number of riffle operations, respectively.
r more positive integers follow, each of which represents a riffle operation. These riffle operations are performed in the listed order. Each integer represents c, which is explained above.
The end of the input is indicated by EOF. The number of data sets is less than 100.
Output
For each data set in the input, your program should print the number of the top card after the shuffle. Assume that at the beginning the cards are numbered from 0 to n-1, from the bottom to the top. Each number should be written in a sparate line without any superfluous characters such as leading or following spaces.
Example
Input
9 1
3
9 4
1 2 3 4
Output
3
0
Submitted Solution:
```
from collections import deque
import sys
def suffle(deck, c):
l = len(deck)
if l % 2 == 0: mid = l//2
else: mid = (l-1)//2
deckA = deck[mid:]
deckB = deck[:mid]
deckC = []
while(len(deckA) != 0 or len(deckB) != 0):
deckC.extend(deckA[:c])
deckA = deckA[c:]
deckC.extend(deckB[:c])
deckB = deckB[c:]
return deckC
while(True):
deck = []
n, r = map(int, sys.stdin.readline()[:-1].split())
deck = [i for i in range(n)]
c_list = map(int, sys.stdin.readline()[:-1].split())
for c in c_list:
deck = suffle(deck, c)
print(deck[-1])
#print(" ".join(map(str, deck)))
``` | instruction | 0 | 31,725 | 19 | 63,450 |
No | output | 1 | 31,725 | 19 | 63,451 |
Provide a correct Python 3 solution for this coding contest problem.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 ≤ n ≤ 50 and 2 ≤ p ≤ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13 | instruction | 0 | 31,726 | 19 | 63,452 |
"Correct Solution:
```
while 1:
n,p = map(int,input().split())
if n==0:break
man = [0]*n
ball,a = p,0
while 1:
a%=n
if ball >0:
ball-=1
man[a]+=1
elif ball == 0:ball,man[a] = man[a],ball
if man[a]==p:break
a+=1
print(a)
``` | output | 1 | 31,726 | 19 | 63,453 |
Provide a correct Python 3 solution for this coding contest problem.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 ≤ n ≤ 50 and 2 ≤ p ≤ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13 | instruction | 0 | 31,727 | 19 | 63,454 |
"Correct Solution:
```
while True:
n, p = map(int, input().split())
pp = p
if n == p == 0:
break
stones = [0] * n
for i in range(1000000):
er = i % n
if p >= 1:
stones[er] += 1
p -= 1
if p == 0 and stones[er] == pp:
print(er)
break
else:
p = stones[er]
stones[er] = 0
``` | output | 1 | 31,727 | 19 | 63,455 |
Provide a correct Python 3 solution for this coding contest problem.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 ≤ n ≤ 50 and 2 ≤ p ≤ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13 | instruction | 0 | 31,728 | 19 | 63,456 |
"Correct Solution:
```
while True:
(n, p) = [int(x) for x in input().split()]
if n==0 and p==0:
exit()
s = [0 for _ in range(n)]
i = 0
q = p
while True:
# print(i,q,s)
if q == 0:
q = s[i]
s[i] = 0
else:
s[i] += 1
q -= 1
if q==0 and s[i]==p:
print(i)
break
i = (i+1)%n
``` | output | 1 | 31,728 | 19 | 63,457 |
Provide a correct Python 3 solution for this coding contest problem.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 ≤ n ≤ 50 and 2 ≤ p ≤ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13 | instruction | 0 | 31,729 | 19 | 63,458 |
"Correct Solution:
```
while True :
n, p = map(int, input().split())
if(n == 0 and p == 0) :
break
else :
stone = [0 for i in range(n)]
P = p
cnt = 0
for i in range(1000000) :
cnt = cnt % n
if(p == 0) :
if(stone[cnt] == P) :
print(cnt)
break
else :
p = stone[cnt]
stone[cnt] = 0
cnt += 1
else :
stone[cnt] += 1
p -= 1
cnt += 1
``` | output | 1 | 31,729 | 19 | 63,459 |
Provide a correct Python 3 solution for this coding contest problem.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 ≤ n ≤ 50 and 2 ≤ p ≤ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13 | instruction | 0 | 31,730 | 19 | 63,460 |
"Correct Solution:
```
from sys import stdin, stdout, stderr
a = [0] * 50
while 1:
n, p = map(int, stdin.readline().split())
if n + p == 0:
break
wan = p
i = 0
while a[i] < p:
if wan > 0:
a[i] += 1
wan -= 1
else:
wan += a[i]
a[i] = 0
i = (i + 1) % n
print(i)
a[i] = 0
``` | output | 1 | 31,730 | 19 | 63,461 |
Provide a correct Python 3 solution for this coding contest problem.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 ≤ n ≤ 50 and 2 ≤ p ≤ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13 | instruction | 0 | 31,731 | 19 | 63,462 |
"Correct Solution:
```
while 1:
n,p=map(int,input().split())
if n==0:break
a=[0]*n
b,c=0,p
while 1:
b%=n
if c==0:c,a[b]=a[b],0
else:
c-=1
a[b]+=1
if a[b]==p:break
b+=1
print(b)
``` | output | 1 | 31,731 | 19 | 63,463 |
Provide a correct Python 3 solution for this coding contest problem.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 ≤ n ≤ 50 and 2 ≤ p ≤ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13 | instruction | 0 | 31,732 | 19 | 63,464 |
"Correct Solution:
```
while True:
n, p = map(int, input().split())
if n == 0 or p == 0:
break
stones = [0] * n
i = 0
num = p
while True:
if num == 0:
num += stones[i]
stones[i] = 0
else:
stones[i] += 1
num -= 1
if stones[i] == p:
print(i)
break
i = (i + 1) % n
``` | output | 1 | 31,732 | 19 | 63,465 |
Provide a correct Python 3 solution for this coding contest problem.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 ≤ n ≤ 50 and 2 ≤ p ≤ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13 | instruction | 0 | 31,733 | 19 | 63,466 |
"Correct Solution:
```
while True:
n, p = map(int, input().split())
if (n, p) == (0, 0):
break
i = 0
m = p;
a = [0] * n
while True:
if p == 0:
p = a[i]
a[i] = 0
else:
p -= 1
a[i] += 1
if a[i] == m:
print(i)
break
i += 1
i %= n
``` | output | 1 | 31,733 | 19 | 63,467 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 ≤ n ≤ 50 and 2 ≤ p ≤ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13
Submitted Solution:
```
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
sys.setrecursionlimit(10**7)
inf = 10**3
eps = 1.0 / 10**10
mod = 10**9+7
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)
def main():
rr = []
while True:
n,p = LI()
mp = p
if n == 0:
break
a = [0] * n
i = 0
while True:
if p == 0:
p = a[i]
a[i] = 0
else:
a[i] += 1
p -= 1
if a[i] == mp:
break
i = (i+1) % n
rr.append(i)
return '\n'.join(map(str, rr))
print(main())
``` | instruction | 0 | 31,734 | 19 | 63,468 |
Yes | output | 1 | 31,734 | 19 | 63,469 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 ≤ n ≤ 50 and 2 ≤ p ≤ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13
Submitted Solution:
```
# AOJ 1159: Next Mayor
# Python3 2018.7.14 bal4u
while True:
n, p = map(int, input().split())
if n == 0: break
ans, m = 0, p
x = [0]*53
while True:
m -= 1
if m >= 0:
x[ans] += 1
if x[ans] == p: break
else: m = x[ans]; x[ans] = 0
ans += 1
if ans == n: ans = 0
print(ans)
``` | instruction | 0 | 31,735 | 19 | 63,470 |
Yes | output | 1 | 31,735 | 19 | 63,471 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 ≤ n ≤ 50 and 2 ≤ p ≤ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13
Submitted Solution:
```
while True:
n, p = [ int(i) for i in input().split() ]
if n == p == 0:
break
# print("start: ", n, p)
leaders = [0] * n
result = 0
index = 0
stone_num = p
while True:
if stone_num > 0:
leaders[index] += 1
stone_num -= 1
# ??¨??¨????????£??????????????????
if leaders[index] == p:
result = index
break
elif leaders[index] > 0:
stone_num = leaders[index]
leaders[index] = 0
index = (index + 1) % n
print(result)
``` | instruction | 0 | 31,736 | 19 | 63,472 |
Yes | output | 1 | 31,736 | 19 | 63,473 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 ≤ n ≤ 50 and 2 ≤ p ≤ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13
Submitted Solution:
```
# -*- coding: utf-8 -*-
def main():
while 1:
n, p = list(map(int, input().split()))
if n + p == 0:
return 1
s = [0] * n
ans = -1
while 1:
if p > n:
i = p // n
p = p % n
s = [s_ + i for s_ in s]
else:
for i in range(n):
if p > 0:
p -= 1
s[i] +=1
if p == 0 and sum(s)==s[i]:
ans = i
break
else:
p = s[i]
s[i] = 0
if ans >-1:
break
print(ans)
if __name__ == "__main__":
main()
``` | instruction | 0 | 31,737 | 19 | 63,474 |
Yes | output | 1 | 31,737 | 19 | 63,475 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One of the oddest traditions of the town of Gameston may be that even the town mayor of the next term is chosen according to the result of a game. When the expiration of the term of the mayor approaches, at least three candidates, including the mayor of the time, play a game of pebbles, and the winner will be the next mayor.
The rule of the game of pebbles is as follows. In what follows, n is the number of participating candidates.
Requisites A round table, a bowl, and plenty of pebbles. Start of the Game A number of pebbles are put into the bowl; the number is decided by the Administration Commission using some secret stochastic process. All the candidates, numbered from 0 to n-1 sit around the round table, in a counterclockwise order. Initially, the bowl is handed to the serving mayor at the time, who is numbered 0. Game Steps When a candidate is handed the bowl and if any pebbles are in it, one pebble is taken out of the bowl and is kept, together with those already at hand, if any. If no pebbles are left in the bowl, the candidate puts all the kept pebbles, if any, into the bowl. Then, in either case, the bowl is handed to the next candidate to the right. This step is repeated until the winner is decided. End of the Game When a candidate takes the last pebble in the bowl, and no other candidates keep any pebbles, the game ends and that candidate with all the pebbles is the winner.
A math teacher of Gameston High, through his analysis, concluded that this game will always end within a finite number of steps, although the number of required steps can be very large.
Input
The input is a sequence of datasets. Each dataset is a line containing two integers n and p separated by a single space. The integer n is the number of the candidates including the current mayor, and the integer p is the total number of the pebbles initially put in the bowl. You may assume 3 ≤ n ≤ 50 and 2 ≤ p ≤ 50.
With the settings given in the input datasets, the game will end within 1000000 (one million) steps.
The end of the input is indicated by a line containing two zeros separated by a single space.
Output
The output should be composed of lines corresponding to input datasets in the same order, each line of which containing the candidate number of the winner. No other characters should appear in the output.
Sample Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output for the Sample Input
1
0
1
5
30
1
13
Example
Input
3 2
3 3
3 50
10 29
31 32
50 2
50 50
0 0
Output
1
0
1
5
30
1
13
Submitted Solution:
```
#!/usr/bin/python
# -*- coding: utf-8 -*-
def is_winner(turn):
if having_amount.count(0) == len(having_amount) - 1:
return True
else:
return False
# having_amount[i] represents the amount of pebbles the
# candidate numbered i is having
winner_number = []
# initialize
turn = 0
while True:
mayors, pebbles_in_bowl = map(int, input().split())
having_amount = [0 for i in range(mayors)]
# action of a candidate
if mayors == 0 and pebbles_in_bowl == 0:
break
elif pebbles_in_bowl == 0:
pebbles_in_bowl += having_amount[turn]
having_amount[turn] = 0
elif pebbles_in_bowl == 1:
if is_winner(turn):
print(turn)
break
else:
having_amount[turn] += 1
pebbles_in_bowl -= 1
else:
having_amount[turn] += 1
pebbles_in_bowl -= 1
# go to the next turn
if turn == mayors:
turn = 0
else:
turn += 1
print(*having_amount)
``` | instruction | 0 | 31,738 | 19 | 63,476 |
No | output | 1 | 31,738 | 19 | 63,477 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.