message stringlengths 2 22.7k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 145 109k | cluster float64 9 9 | __index_level_0__ int64 290 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Ann and Borya have n piles with candies and n is even number. There are ai candies in pile with number i.
Ann likes numbers which are square of some integer and Borya doesn't like numbers which are square of any integer. During one move guys can select some pile with candies and add one candy to it (this candy is new and doesn't belong to any other pile) or remove one candy (if there is at least one candy in this pile).
Find out minimal number of moves that is required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer.
Input
First line contains one even integer n (2 ≤ n ≤ 200 000) — number of piles with candies.
Second line contains sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 109) — amounts of candies in each pile.
Output
Output minimal number of steps required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer. If condition is already satisfied output 0.
Examples
Input
4
12 14 30 4
Output
2
Input
6
0 0 0 0 0 0
Output
6
Input
6
120 110 23 34 25 45
Output
3
Input
10
121 56 78 81 45 100 1 0 54 78
Output
0
Note
In first example you can satisfy condition in two moves. During each move you should add one candy to second pile. After it size of second pile becomes 16. After that Borya and Ann will have two piles with number of candies which is a square of integer (second and fourth pile) and two piles with number of candies which is not a square of any integer (first and third pile).
In second example you should add two candies to any three piles. | instruction | 0 | 81,394 | 9 | 162,788 |
Tags: constructive algorithms, greedy
Correct Solution:
```
from math import sqrt
def check(x):
sq = int(sqrt(x))
while sq * sq < x:
sq += 1
return sq * sq == x, sq
n = int(input())
a = map(int, input().split())
sq, non_sq = 0, 0
sqs, non_sqs = [], []
for _ in a:
res, root = check(_)
sq += res
non_sq += 1 - res
if res:
sqs.append(2 - bool(_))
else:
non_sqs.append(min(_ - (root - 1) ** 2, root ** 2 - _))
sqs.sort()
non_sqs.sort()
ans = 0
if sq > non_sq:
for i in range((sq - non_sq) >> 1):
ans += sqs[i]
elif sq < non_sq:
for i in range((non_sq - sq) >> 1):
ans += non_sqs[i]
else:
pass
print(ans)
``` | output | 1 | 81,394 | 9 | 162,789 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Ann and Borya have n piles with candies and n is even number. There are ai candies in pile with number i.
Ann likes numbers which are square of some integer and Borya doesn't like numbers which are square of any integer. During one move guys can select some pile with candies and add one candy to it (this candy is new and doesn't belong to any other pile) or remove one candy (if there is at least one candy in this pile).
Find out minimal number of moves that is required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer.
Input
First line contains one even integer n (2 ≤ n ≤ 200 000) — number of piles with candies.
Second line contains sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 109) — amounts of candies in each pile.
Output
Output minimal number of steps required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer. If condition is already satisfied output 0.
Examples
Input
4
12 14 30 4
Output
2
Input
6
0 0 0 0 0 0
Output
6
Input
6
120 110 23 34 25 45
Output
3
Input
10
121 56 78 81 45 100 1 0 54 78
Output
0
Note
In first example you can satisfy condition in two moves. During each move you should add one candy to second pile. After it size of second pile becomes 16. After that Borya and Ann will have two piles with number of candies which is a square of integer (second and fourth pile) and two piles with number of candies which is not a square of any integer (first and third pile).
In second example you should add two candies to any three piles. | instruction | 0 | 81,395 | 9 | 162,790 |
Tags: constructive algorithms, greedy
Correct Solution:
```
sq=[i*i for i in range(10**5+5)]
a=[]
nules=0
ap=a.append
from bisect import bisect_left
n=int(input())//2
for i in map(int,input().split()):
if i==0:
ap(0)
nules+=1
else:
ind=bisect_left(sq,i)
#print(ind)
ap(min(i-sq[ind-1],sq[ind]-i))
a=sorted(a)
s=sum(a[:n])
#print(a,n,s)
#print(a,s)
if s==0:
print(n-a[::-1].index(0)+max(0,nules-n))
else:
print(s)
``` | output | 1 | 81,395 | 9 | 162,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ann and Borya have n piles with candies and n is even number. There are ai candies in pile with number i.
Ann likes numbers which are square of some integer and Borya doesn't like numbers which are square of any integer. During one move guys can select some pile with candies and add one candy to it (this candy is new and doesn't belong to any other pile) or remove one candy (if there is at least one candy in this pile).
Find out minimal number of moves that is required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer.
Input
First line contains one even integer n (2 ≤ n ≤ 200 000) — number of piles with candies.
Second line contains sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 109) — amounts of candies in each pile.
Output
Output minimal number of steps required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer. If condition is already satisfied output 0.
Examples
Input
4
12 14 30 4
Output
2
Input
6
0 0 0 0 0 0
Output
6
Input
6
120 110 23 34 25 45
Output
3
Input
10
121 56 78 81 45 100 1 0 54 78
Output
0
Note
In first example you can satisfy condition in two moves. During each move you should add one candy to second pile. After it size of second pile becomes 16. After that Borya and Ann will have two piles with number of candies which is a square of integer (second and fourth pile) and two piles with number of candies which is not a square of any integer (first and third pile).
In second example you should add two candies to any three piles.
Submitted Solution:
```
import math
n = int(input())
l = list(map(int,input().split()))
zero = l.count(0)
for i in range(n):
r = round(math.sqrt(l[i]))
l[i] = abs(l[i]-r*r)
l.sort()
rzero = max(0,zero-n//2)
print(sum(l[0:n//2]) + rzero*2 + l[n//2:n].count(0)-rzero)
``` | instruction | 0 | 81,396 | 9 | 162,792 |
Yes | output | 1 | 81,396 | 9 | 162,793 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ann and Borya have n piles with candies and n is even number. There are ai candies in pile with number i.
Ann likes numbers which are square of some integer and Borya doesn't like numbers which are square of any integer. During one move guys can select some pile with candies and add one candy to it (this candy is new and doesn't belong to any other pile) or remove one candy (if there is at least one candy in this pile).
Find out minimal number of moves that is required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer.
Input
First line contains one even integer n (2 ≤ n ≤ 200 000) — number of piles with candies.
Second line contains sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 109) — amounts of candies in each pile.
Output
Output minimal number of steps required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer. If condition is already satisfied output 0.
Examples
Input
4
12 14 30 4
Output
2
Input
6
0 0 0 0 0 0
Output
6
Input
6
120 110 23 34 25 45
Output
3
Input
10
121 56 78 81 45 100 1 0 54 78
Output
0
Note
In first example you can satisfy condition in two moves. During each move you should add one candy to second pile. After it size of second pile becomes 16. After that Borya and Ann will have two piles with number of candies which is a square of integer (second and fourth pile) and two piles with number of candies which is not a square of any integer (first and third pile).
In second example you should add two candies to any three piles.
Submitted Solution:
```
n = input()
m = input().split()
a = []
b = []
for s in m:
i = int(s)
if int(i**(1/2))**2 == i:
a.append(i)
else:
b.append(i)
if len(a)>=len(b):
ans = 0
a = sorted(a)
for i in range(len(a)-1,len(a)-(len(a)-len(b))//2-1,-1):
if a[i]!=0:
ans+=1
else:
ans+=2
print(ans)
else:
k = 0
r = len(b) - len(a)
r = int(r/2)
a = []
for i in b:
q = int(i**(1/2))
q1=q**2
q2=(q+1)**2
q1 = i-q1
q2 = q2-i
if q1<q2:
q = q1
else:
q = q2
a.append(q)
print(sum(sorted(a)[:r]))
``` | instruction | 0 | 81,397 | 9 | 162,794 |
Yes | output | 1 | 81,397 | 9 | 162,795 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ann and Borya have n piles with candies and n is even number. There are ai candies in pile with number i.
Ann likes numbers which are square of some integer and Borya doesn't like numbers which are square of any integer. During one move guys can select some pile with candies and add one candy to it (this candy is new and doesn't belong to any other pile) or remove one candy (if there is at least one candy in this pile).
Find out minimal number of moves that is required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer.
Input
First line contains one even integer n (2 ≤ n ≤ 200 000) — number of piles with candies.
Second line contains sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 109) — amounts of candies in each pile.
Output
Output minimal number of steps required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer. If condition is already satisfied output 0.
Examples
Input
4
12 14 30 4
Output
2
Input
6
0 0 0 0 0 0
Output
6
Input
6
120 110 23 34 25 45
Output
3
Input
10
121 56 78 81 45 100 1 0 54 78
Output
0
Note
In first example you can satisfy condition in two moves. During each move you should add one candy to second pile. After it size of second pile becomes 16. After that Borya and Ann will have two piles with number of candies which is a square of integer (second and fourth pile) and two piles with number of candies which is not a square of any integer (first and third pile).
In second example you should add two candies to any three piles.
Submitted Solution:
```
import math
def my_dist(n):
low = math.floor(math.sqrt(n))
high = math.ceil(math.sqrt(n))
return int(min(n - low*low, high*high - n))
def sol(n, my_list):
my_list = sorted(my_list, key = lambda x: x[1])
#print(my_list)
square_count_zero = 0
square_count = 0
total = 0
for i in range(n):
if my_list[i][0] == 0:
square_count_zero += 1
if my_list[i][1] == 0:
square_count += 1
else:
break
#print(square_count)
#print(square_count_zero)
if square_count == n//2:
return 0
if square_count < n//2:
for i in range(square_count, n//2):
total += my_list[i][1]
return total
if square_count > n//2:
square_pos = square_count - square_count_zero
if square_pos >= square_count - n//2:
return square_count - n//2
else:
total = square_count + square_count_zero - n
return total
n = int(input())
my_list = [[int(x), my_dist(int(x))] for x in input().strip().split()]
print(sol(n, my_list))
``` | instruction | 0 | 81,398 | 9 | 162,796 |
Yes | output | 1 | 81,398 | 9 | 162,797 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ann and Borya have n piles with candies and n is even number. There are ai candies in pile with number i.
Ann likes numbers which are square of some integer and Borya doesn't like numbers which are square of any integer. During one move guys can select some pile with candies and add one candy to it (this candy is new and doesn't belong to any other pile) or remove one candy (if there is at least one candy in this pile).
Find out minimal number of moves that is required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer.
Input
First line contains one even integer n (2 ≤ n ≤ 200 000) — number of piles with candies.
Second line contains sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 109) — amounts of candies in each pile.
Output
Output minimal number of steps required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer. If condition is already satisfied output 0.
Examples
Input
4
12 14 30 4
Output
2
Input
6
0 0 0 0 0 0
Output
6
Input
6
120 110 23 34 25 45
Output
3
Input
10
121 56 78 81 45 100 1 0 54 78
Output
0
Note
In first example you can satisfy condition in two moves. During each move you should add one candy to second pile. After it size of second pile becomes 16. After that Borya and Ann will have two piles with number of candies which is a square of integer (second and fourth pile) and two piles with number of candies which is not a square of any integer (first and third pile).
In second example you should add two candies to any three piles.
Submitted Solution:
```
import math
def closest(n):
f = math.pow(math.floor(math.sqrt(n)), 2)
c = math.pow(math.ceil(math.sqrt(n)), 2)
return [int(f),int(c)]
n = int(input())
piles = [int(x) for x in input().split()]
squares = []
notsquares = []
for p in range(len(piles)):
if piles[p] == 0:
f,c = [0,1]
else:
f,c = closest(piles[p])
if piles[p] in [f,c]:
squares.append(piles[p])
else:
notsquares.append(min(abs(piles[p]) - f, abs(piles[p] - c)))
price = 0
dif =len(squares) - n//2
if dif == 0:
print(0)
exit()
if dif < 0:
count = -dif
notsquares.sort()
price += sum(notsquares[:count])
if dif > 0:
np = sorted(squares, reverse=True)
for i in range(dif):
if np[i] == 0:
price +=2
else:
price +=1
print(price)
``` | instruction | 0 | 81,399 | 9 | 162,798 |
Yes | output | 1 | 81,399 | 9 | 162,799 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ann and Borya have n piles with candies and n is even number. There are ai candies in pile with number i.
Ann likes numbers which are square of some integer and Borya doesn't like numbers which are square of any integer. During one move guys can select some pile with candies and add one candy to it (this candy is new and doesn't belong to any other pile) or remove one candy (if there is at least one candy in this pile).
Find out minimal number of moves that is required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer.
Input
First line contains one even integer n (2 ≤ n ≤ 200 000) — number of piles with candies.
Second line contains sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 109) — amounts of candies in each pile.
Output
Output minimal number of steps required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer. If condition is already satisfied output 0.
Examples
Input
4
12 14 30 4
Output
2
Input
6
0 0 0 0 0 0
Output
6
Input
6
120 110 23 34 25 45
Output
3
Input
10
121 56 78 81 45 100 1 0 54 78
Output
0
Note
In first example you can satisfy condition in two moves. During each move you should add one candy to second pile. After it size of second pile becomes 16. After that Borya and Ann will have two piles with number of candies which is a square of integer (second and fourth pile) and two piles with number of candies which is not a square of any integer (first and third pile).
In second example you should add two candies to any three piles.
Submitted Solution:
```
n = int(input())
A = list(map(int,input().split()))
ns=0;s=0
N = [];S = []
for i in range(n):
if(A[i]**0.5!=int(A[i]**0.5)):
ns+=1
N.append(A[i])
else:
S.append(A[i])
s = n-ns
if(ns<n//2):
a = n//2-ns
for i in range(len(S)):
if(S[i]==0):
S[i]+=2
else:
S[i]+=1
S.sort()
ans = 0
for i in range(a):
ans+=S[i]
print(ans)
else:
a = n//2-s
for i in range(ns):
c = int(N[i]**0.5)
b = c**2;d=(c+1)**2
if(N[i]-b<=d-N[i]):
N[i] = N[i]-b
else:
N[i] = d-N[i]
N.sort()
ans = 0
for i in range(a):
ans+=N[i]
print(ans)
``` | instruction | 0 | 81,400 | 9 | 162,800 |
No | output | 1 | 81,400 | 9 | 162,801 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ann and Borya have n piles with candies and n is even number. There are ai candies in pile with number i.
Ann likes numbers which are square of some integer and Borya doesn't like numbers which are square of any integer. During one move guys can select some pile with candies and add one candy to it (this candy is new and doesn't belong to any other pile) or remove one candy (if there is at least one candy in this pile).
Find out minimal number of moves that is required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer.
Input
First line contains one even integer n (2 ≤ n ≤ 200 000) — number of piles with candies.
Second line contains sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 109) — amounts of candies in each pile.
Output
Output minimal number of steps required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer. If condition is already satisfied output 0.
Examples
Input
4
12 14 30 4
Output
2
Input
6
0 0 0 0 0 0
Output
6
Input
6
120 110 23 34 25 45
Output
3
Input
10
121 56 78 81 45 100 1 0 54 78
Output
0
Note
In first example you can satisfy condition in two moves. During each move you should add one candy to second pile. After it size of second pile becomes 16. After that Borya and Ann will have two piles with number of candies which is a square of integer (second and fourth pile) and two piles with number of candies which is not a square of any integer (first and third pile).
In second example you should add two candies to any three piles.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Sat Dec 16 19:33:27 2017
@author: ms
"""
from math import sqrt
def main():
n = int(input())
piles = [int(x) for x in input().split()]
nearest = []
cost = []
for a in piles:
tmp = (int(sqrt(a)))
lower = tmp**2
upper = (tmp+1)**2
if (a-lower)<=(upper-a):
nearest.append(lower)
else:
nearest.append(upper)
cost.append(abs(a-nearest[-1]))
cost = sorted(cost)
summ = 0
for i in range(int(n/2)):
summ += cost[i]
for j in range(int(n/2),n):
if (cost[j] == 0):
summ += 1
else:
break
print(summ)
main()
``` | instruction | 0 | 81,401 | 9 | 162,802 |
No | output | 1 | 81,401 | 9 | 162,803 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ann and Borya have n piles with candies and n is even number. There are ai candies in pile with number i.
Ann likes numbers which are square of some integer and Borya doesn't like numbers which are square of any integer. During one move guys can select some pile with candies and add one candy to it (this candy is new and doesn't belong to any other pile) or remove one candy (if there is at least one candy in this pile).
Find out minimal number of moves that is required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer.
Input
First line contains one even integer n (2 ≤ n ≤ 200 000) — number of piles with candies.
Second line contains sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 109) — amounts of candies in each pile.
Output
Output minimal number of steps required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer. If condition is already satisfied output 0.
Examples
Input
4
12 14 30 4
Output
2
Input
6
0 0 0 0 0 0
Output
6
Input
6
120 110 23 34 25 45
Output
3
Input
10
121 56 78 81 45 100 1 0 54 78
Output
0
Note
In first example you can satisfy condition in two moves. During each move you should add one candy to second pile. After it size of second pile becomes 16. After that Borya and Ann will have two piles with number of candies which is a square of integer (second and fourth pile) and two piles with number of candies which is not a square of any integer (first and third pile).
In second example you should add two candies to any three piles.
Submitted Solution:
```
def ispow(c):
x = int(c ** 0.5)
return (x) * (x) == c or (x + 1) * (x + 1) == c or (x + 2) * (x + 2) == c
n = int(input())
a = list(map(int, input().split()))
kb = []
nk = []
for i in range(n):
if ispow(a[i]):
kb.append(a[i])
else:
c = int(a[i] ** 0.5)
nk.append((min(abs(c * c - a[i]), abs((c + 1) * (c + 1) - a[i]))))
if len(kb) > len(nk):
print(len(kb) - n // 2)
elif len(kb) == len(nk):
print(0)
else:
nk.sort()
s = 0
print(nk)
for i in range(len(nk) - n // 2):
s += nk[i]
print(s)
``` | instruction | 0 | 81,402 | 9 | 162,804 |
No | output | 1 | 81,402 | 9 | 162,805 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ann and Borya have n piles with candies and n is even number. There are ai candies in pile with number i.
Ann likes numbers which are square of some integer and Borya doesn't like numbers which are square of any integer. During one move guys can select some pile with candies and add one candy to it (this candy is new and doesn't belong to any other pile) or remove one candy (if there is at least one candy in this pile).
Find out minimal number of moves that is required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer.
Input
First line contains one even integer n (2 ≤ n ≤ 200 000) — number of piles with candies.
Second line contains sequence of integers a1, a2, ..., an (0 ≤ ai ≤ 109) — amounts of candies in each pile.
Output
Output minimal number of steps required to make exactly n / 2 piles contain number of candies that is a square of some integer and exactly n / 2 piles contain number of candies that is not a square of any integer. If condition is already satisfied output 0.
Examples
Input
4
12 14 30 4
Output
2
Input
6
0 0 0 0 0 0
Output
6
Input
6
120 110 23 34 25 45
Output
3
Input
10
121 56 78 81 45 100 1 0 54 78
Output
0
Note
In first example you can satisfy condition in two moves. During each move you should add one candy to second pile. After it size of second pile becomes 16. After that Borya and Ann will have two piles with number of candies which is a square of integer (second and fourth pile) and two piles with number of candies which is not a square of any integer (first and third pile).
In second example you should add two candies to any three piles.
Submitted Solution:
```
n=int(input())
t=[]
l=[]
j=0
s=0
d=0
sum=0
def rtu(f):
c=0
for i in range(1,int(f**0.5)+1):
if(f%i==0):
c=c+1
if(c>1):
break
if(c==1):
return(1)
else:
return(0)
t=input()
t=list(map(int ,t.split(' ')))
for k in range(0,n):
r=t[k]**0.5
s=t[k]-(int(r))**2
d=(int(r)+1)**2-t[k]
if(s>d):
l.append(d)
else:
l.append(s)
l.sort()
for i in range(0,(n//2)):
sum=sum+l[i]
for i in range((n//2),n):
if(l[i]==0):
sum=sum+2
if(l[i]>=1 and rtu(l[i])==1):
sum=sum+1
print(sum)
``` | instruction | 0 | 81,403 | 9 | 162,806 |
No | output | 1 | 81,403 | 9 | 162,807 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy. | instruction | 0 | 81,790 | 9 | 163,580 |
Tags: math
Correct Solution:
```
T = int(input())
for counter in range(T):
n, s, t = [int(i) for i in input().split()]
print(n - min(s, t) + 1)
``` | output | 1 | 81,790 | 9 | 163,581 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy. | instruction | 0 | 81,791 | 9 | 163,582 |
Tags: math
Correct Solution:
```
"""
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that
exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
it can contain a single sticker and no toy;
it can contain a single toy and no sticker;
it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs
look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be
sure that, whichever types they are, you'll obtain at least one sticker and
at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you
just buy some number of eggs. It's guaranteed that the answer always
exists.
Input
The first line contains the single integer T (1≤T≤100) — the number of
queries.
Next T lines contain three integers n, s and t each (1≤n≤109, 1≤s,t≤n,
s+t≥n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder
Surprise Eggs you have to buy to be sure that, whichever types they are,
you'll obtain at least one sticker and one toy
Example
inputCopy
3
10 5 7
10 10 10
2 1 1
outputCopy
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5
eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's
why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one
with a toy.
"""
if __name__ == "__main__":
N = int(input())
for i in range(N):
n, s, t = map(int, input().split())
print(n+1-min(s, t))
``` | output | 1 | 81,791 | 9 | 163,583 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy. | instruction | 0 | 81,792 | 9 | 163,584 |
Tags: math
Correct Solution:
```
# -*- coding: utf-8 -*-
for _ in[0]*int(input()):
n,s,t = map(int,input().split(" "))
ans = max(n-s+1, n-t + 1)
print(ans)
``` | output | 1 | 81,792 | 9 | 163,585 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy. | instruction | 0 | 81,793 | 9 | 163,586 |
Tags: math
Correct Solution:
```
for _ in [0] * int(input()):
n, s, t = map(int, input().split())
print(1 if (s+t) // n == 2 else n - min(s, t) + 1)
``` | output | 1 | 81,793 | 9 | 163,587 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy. | instruction | 0 | 81,794 | 9 | 163,588 |
Tags: math
Correct Solution:
```
test=int(input())
while(test>0):
test-=1
n,s,t=[int(x) for x in input().split()]
if(s+t==n):
if(s>t):
print(n-t+1)
else:
print(n-s+1)
else:
if(s==t):
print(n-s+1)
else:
if(s>t):
print(n-t+1)
else:
print(n-s+1)
``` | output | 1 | 81,794 | 9 | 163,589 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy. | instruction | 0 | 81,795 | 9 | 163,590 |
Tags: math
Correct Solution:
```
def f(i):
n,s,t = i
res = max(n-t,n-s)+1
return res
l = []
for _ in range(int(input())):
n,s,t = map(int,input().split())
l.append((n,s,t))
ans = [f(i) for i in l]
for i in ans :
print(i)
``` | output | 1 | 81,795 | 9 | 163,591 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy. | instruction | 0 | 81,796 | 9 | 163,592 |
Tags: math
Correct Solution:
```
import sys
import math
import re
from functools import reduce
n = int(input())
for _ in range(n):
n, s, t = map(int, sys.stdin.readline().split())
if s == t and s == n:
print(1)
elif s == t:
print(n - s + 1)
else:
print(n - min(s, t) + 1)
``` | output | 1 | 81,796 | 9 | 163,593 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy. | instruction | 0 | 81,797 | 9 | 163,594 |
Tags: math
Correct Solution:
```
t=int(input())
for i in range(t):
n,s,t=list(map(int,input().split()))
b=s+t-n
s=s-b
t=t-b
print(max(s,t)+1)
``` | output | 1 | 81,797 | 9 | 163,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy.
Submitted Solution:
```
for _ in range(int(input())):
a,b,c=map(int,input().split())
x=b+c-a
y=b-x
z=c-x
print(max(y,z)+(min(y,z) if max(y,z)==0 else 1)+(1 if y==0 and z==0 else 0))
``` | instruction | 0 | 81,798 | 9 | 163,596 |
Yes | output | 1 | 81,798 | 9 | 163,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy.
Submitted Solution:
```
for x in range(int(input())):
a,b,c=map(int,input().split())
if a==b==c:
print(1)
elif c==1 or b==1:
print(a)
else:
print(a-min(b,c)+1)
``` | instruction | 0 | 81,799 | 9 | 163,598 |
Yes | output | 1 | 81,799 | 9 | 163,599 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy.
Submitted Solution:
```
tests = int(input())
for test in range(tests):
n, s, t = map(int, input().split())
c = s+t-n
a = s - c
b = t - c
print(max(a,b)+1)
``` | instruction | 0 | 81,800 | 9 | 163,600 |
Yes | output | 1 | 81,800 | 9 | 163,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy.
Submitted Solution:
```
for i in range(int(input())):
n,m,k=map(int,input().split())
print(n-min(m,k)+1)
``` | instruction | 0 | 81,801 | 9 | 163,602 |
Yes | output | 1 | 81,801 | 9 | 163,603 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy.
Submitted Solution:
```
for _ in range(int(input())):
n,s,t = map(int, input().split())
if n==s==t:
print(n)
else:
print(min(s,t)+1)
``` | instruction | 0 | 81,802 | 9 | 163,604 |
No | output | 1 | 81,802 | 9 | 163,605 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy.
Submitted Solution:
```
n=int(input())
for i in range(n):
a,b,c=map(int,input().split())
if(min(b,c)==1):
print(max(b,c)+1)
elif(min(b,c)<a):
print(min(b,c)+1)
else:
print(1)
``` | instruction | 0 | 81,803 | 9 | 163,606 |
No | output | 1 | 81,803 | 9 | 163,607 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy.
Submitted Solution:
```
t = int(input())
for _ in range(t):
n, s, toys = map(int, input().split())
mi = min(s, toys)
ad = n - mi
if(ad>0):
print(mi+1)
continue
print(mi)
``` | instruction | 0 | 81,804 | 9 | 163,608 |
No | output | 1 | 81,804 | 9 | 163,609 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your favorite shop sells n Kinder Surprise chocolate eggs. You know that exactly s stickers and exactly t toys are placed in n eggs in total.
Each Kinder Surprise can be one of three types:
* it can contain a single sticker and no toy;
* it can contain a single toy and no sticker;
* it can contain both a single sticker and a single toy.
But you don't know which type a particular Kinder Surprise has. All eggs look identical and indistinguishable from each other.
What is the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and at least one toy?
Note that you do not open the eggs in the purchasing process, that is, you just buy some number of eggs. It's guaranteed that the answer always exists.
Input
The first line contains the single integer T (1 ≤ T ≤ 100) — the number of queries.
Next T lines contain three integers n, s and t each (1 ≤ n ≤ 10^9, 1 ≤ s, t ≤ n, s + t ≥ n) — the number of eggs, stickers and toys.
All queries are independent.
Output
Print T integers (one number per query) — the minimum number of Kinder Surprise Eggs you have to buy to be sure that, whichever types they are, you'll obtain at least one sticker and one toy
Example
Input
3
10 5 7
10 10 10
2 1 1
Output
6
1
2
Note
In the first query, we have to take at least 6 eggs because there are 5 eggs with only toy inside and, in the worst case, we'll buy all of them.
In the second query, all eggs have both a sticker and a toy inside, that's why it's enough to buy only one egg.
In the third query, we have to buy both eggs: one with a sticker and one with a toy.
Submitted Solution:
```
k = int(input())
for i in range(k):
n,s,t = [int(s) for s in input().split()]
igr = n-s
nakl = (n-t-igr)
print(max(igr,nakl)+1)
``` | instruction | 0 | 81,805 | 9 | 163,610 |
No | output | 1 | 81,805 | 9 | 163,611 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3 | instruction | 0 | 81,854 | 9 | 163,708 |
Tags: implementation
Correct Solution:
```
t=int(input())
for w in range(t):
n=int(input())
arr=list(map(int,input().strip().split()))
sum2=moves=sum1=i=0
j=n-1
a=[]
b=[]
while j>=i:
sum1=0
while sum1<=sum2 and i<=j:
p=arr[i]
sum1+=p
a.append(p)
i+=1
moves+=1
if i>j:
break
sum2=0
while sum2<=sum1 and j>=i:
q=arr[j]
sum2+=q
b.append(q)
j-=1
moves+=1
if i>j:
break
print(moves,sum(a),sum(b))
``` | output | 1 | 81,854 | 9 | 163,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3 | instruction | 0 | 81,855 | 9 | 163,710 |
Tags: implementation
Correct Solution:
```
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# . ' Udit Gupta @luctivud ,
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
## ## ####### # # ######
## ## ## ## ### ##
## ## ## # # # ##
######### ####### # # ##
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
import sys
import math as mt
# sys.setrecursionlimit(10**6)
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def printwsp(*args): return print(*args, end="")
def printsp(*args): return print(*args, end=" ")
def printchk(*args): return print(*args, end="tst, ")
MOD = int(1e9+7); BABYMOD = 998244353;
# ################################ HELPER PROGRAMS USED ###################################
# ################################## MAIN STARTS HERE #####################################
for _testcases_ in range(int(input())):
n = int(input())
li = get_array()
moves = 1; a = li[0]; b = 0;
i = 1; j = n-1
prev = a
while(True) :
this = 0
if i > j:
break
while this <= prev:
this += li[j]
b += li[j]
j -= 1
if i > j:
moves += 1
break
if i > j:
break
moves += 1
prev = this
this = 0
if i > j:
break
while this <= prev:
this += li[i]
a += li[i]
i += 1
if i > j:
moves += 1
break
if i > j:
break
moves += 1
prev = this
# print(moves, a, b)
print(moves, a, b)
# #########################################################################################
'''
THE LOGIC AND APPROACH WAS DEVELOPED BY ME @luctivud.
SOME PARTS OF THE CODE HAS BEEN TAKEN FROM WEBSITES LIKE::
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3
(I Own the code if no link is provided here or I may have missed mentioning it)
PLEASE DO NOT PLAGIARISE.
'''
``` | output | 1 | 81,855 | 9 | 163,711 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3 | instruction | 0 | 81,856 | 9 | 163,712 |
Tags: implementation
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
d=0
c=0
al=0
mi=0
bo=0
k=n-1
m=0
f=0
while(d==0):
su=0
f=1
if(c%2==0):
for i in range(m,k+1):
su=su+arr[i]
if(su>mi):
f=0
mi=su
m=i+1
break
al=al+su
else:
for i in range(k,m-1,-1):
su=su+arr[i]
if(su>mi):
f=0
mi=su
k=i-1
break
bo=bo+su
if(f==1 or m>k):
d=1
c=c+1
print(c,al,bo)
``` | output | 1 | 81,856 | 9 | 163,713 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3 | instruction | 0 | 81,857 | 9 | 163,714 |
Tags: implementation
Correct Solution:
```
times = int(input())
for i in range(times):
length = int(input())
array = input().split()
num = [int(x) for x in array]
alice = 0
bob = 0
moves = 0
a = 0
b = 0
flag = 0
while(len(num)>0):
flag = 0
alice = 0
while(alice<=bob and len(num)>0):
alice = alice+num[0]
num.pop(0)
flag = 1
if flag ==1:
moves+=1
flag = 0
bob = 0
while(bob<=alice and len(num)>0):
bob = bob+num[-1]
num.pop(-1)
flag = 1
if flag ==1:
moves+=1
a += alice
b += bob
print (moves, a, b)
``` | output | 1 | 81,857 | 9 | 163,715 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3 | instruction | 0 | 81,858 | 9 | 163,716 |
Tags: implementation
Correct Solution:
```
from collections import deque
n=int(input())
for i in range(n):
x=int(input())
l=deque(list(map(int,input().split())))
if x==1:
print(1,l[0],0)
elif x==2:
print(2,l[0],l[-1])
else:
c1=0
al=0
bob=0
c=0
m=max(al,bob)
if(len(l)!=0):
while(len(l)!=0):
c1=c1+1
#print(l)
#print(c1,al,bob)
if(al<=bob):
while(c<=m):
if(len(l)==0):
break
c=c+l.popleft()
al=al+c
m=c
c=0
elif(bob<al):
while(c<=m):
if(len(l)==0):
break
c=c+l.pop()
bob=bob+c
m=c
c=0
print(c1,al,bob)
#print("")
``` | output | 1 | 81,858 | 9 | 163,717 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3 | instruction | 0 | 81,859 | 9 | 163,718 |
Tags: implementation
Correct Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
arr=list(map(int,input().split()))
sb=0
count=1
a=arr.pop(0)
sa=a
b=0
while(len(arr)!=0):
if(a>b):
b=0
while(b<a+1):
b+=arr[len(arr)-1]
arr.pop()
if(len(arr)==0):
break
sb+=b
else:
a=0
while(a<b+1):
a+=arr[0]
arr.pop(0)
if(len(arr)==0):
break
sa+=a
count+=1
print(count,sa,sb)
``` | output | 1 | 81,859 | 9 | 163,719 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3 | instruction | 0 | 81,860 | 9 | 163,720 |
Tags: implementation
Correct Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
i = 0
j = n-1
moves = 0
ta = 0
tb = 0
pa = 0
pb = 0
flag = 1
while(i <= j):
first = second = False
while(flag == 1 and pa <= pb and i <= j):
pa += a[i]
i += 1
first = True
if(pa > pb):
flag = 0
if(first):
moves += 1
ta += pa
pb = 0
while(flag == 0 and pb <= pa and j>=i):
pb += a[j]
j -= 1
second = True
if(pb > pa):
flag = 1
if(second):
moves += 1
tb += pb
pa = 0
print(moves,ta,tb)
``` | output | 1 | 81,860 | 9 | 163,721 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3 | instruction | 0 | 81,861 | 9 | 163,722 |
Tags: implementation
Correct Solution:
```
t = int(input())
while t > 0:
n = int(input())
a = [int(x) for x in input().split()]
al = 0
bo = 0
ct = 0
mv = 1
pre = a[0]
al += a[0]
ct += 1
a.pop(0)
while len(a) > 0:
cur = 0
if mv == 1:
while cur <= pre:
poped = a.pop()
cur += poped
if len(a) == 0:
break
bo += cur
else:
while cur <= pre:
poped = a.pop(0)
cur += poped
if len(a) == 0:
break
al += cur
mv = 1 - mv
pre = cur
ct += 1
# print(ct, pre, al, bo, a)
print(ct, al, bo)
t -= 1
``` | output | 1 | 81,861 | 9 | 163,723 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3
Submitted Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
l=list(map(int,input().split()))
c=0
a=l[0]
b=0
x=l[0] # eaten by alice in one chance
y=0 # eaten by bob in one chance
i=1
j=n-1
c=1
while(i<=j):
y=0
while(y<=x and i<=j):
y+=l[j]
b+=l[j]
j-=1
c+=1
if(i>j):
break
x=0
while(x<=y and i<=j):
x+=l[i]
a+=l[i]
i+=1
c+=1
print(c,a,b)
``` | instruction | 0 | 81,862 | 9 | 163,724 |
Yes | output | 1 | 81,862 | 9 | 163,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
s1=l[0]
s2=0
ss1=l[0]
ss2=0
cnt=1
i=1
j=n-1
while i<=j:
if s1>s2:
while s1>=s2 and i<=j:
s2+=l[j]
j-=1
s1=0
else:
while s2>=s1 and i<=j:
s1+=l[i]
ss1+=l[i]
i+=1
s2=0
cnt+=1
# print(i,j)
# s1=sum(l[0:i+1])
# s2=sum(l[j+1:n])
ss2=sum(l)-ss1
print(cnt,ss1,ss2)
``` | instruction | 0 | 81,863 | 9 | 163,726 |
Yes | output | 1 | 81,863 | 9 | 163,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3
Submitted Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
i=0
j=n-1
la=0
lb=0
aa=0
bb=0
turn=1
nb=0
while i<=j:
nb+=1
if turn:
c=0
while i<=j and c<=lb:
c+=a[i]
i+=1
la=c
aa+=c
else:
c=0
while i<=j and c<=la:
c+=a[j]
j-=1
lb=c
bb+=c
turn^=1
print(nb,aa,bb)
``` | instruction | 0 | 81,864 | 9 | 163,728 |
Yes | output | 1 | 81,864 | 9 | 163,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
lst = list(map(int, input().split()))
alice, bob = lst[0], 0
isAliceTurn = False
before = lst[0]
i, j = 1, n - 1
cnt = 1
end = False
while n != 1:
if isAliceTurn:
tmp = 0
while tmp <= before and i <= j:
tmp += lst[i]
i += 1
if i > j or i >= n:
end = True
alice += tmp
else:
tmp = 0
while tmp <= before and i <= j:
tmp += lst[j]
j -= 1
if i > j or j < 0:
end = True
bob += tmp
before = tmp
isAliceTurn = not isAliceTurn
cnt += 1
if end: break
print(cnt, alice, bob)
``` | instruction | 0 | 81,865 | 9 | 163,730 |
Yes | output | 1 | 81,865 | 9 | 163,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3
Submitted Solution:
```
import sys
import collections
t = int(sys.stdin.readline())
for _ in range(t):
n = int(sys.stdin.readline())
arr = collections.deque(map(int, sys.stdin.readline().split()))
move_cnt = 0
al = 0
bob = 0
judge = False
total_al = 0
total_bob = 0
while True:
if judge == True or len(arr) == 0:
print(move_cnt, total_al, total_bob)
break
# alice
for i in range(len(arr)):
al += arr[i]
if i == len(arr) - 1 and al <= bob:
judge = True
total_al += arr[-1]
break
total_al += arr[i]
if al > bob:
for _ in range(i+1):
arr.popleft()
bob = 0
break
move_cnt += 1
if len(arr) == 0:
print(move_cnt, total_al, total_bob)
break
# bob
for j in range(len(arr)-1, -1, -1):
bob += arr[j]
if j == 0 and bob <= al:
judge = True
total_bob += arr[0]
break
total_bob += arr[j]
if bob > al:
for _ in range(len(arr)-j):
arr.pop()
al = 0
break
move_cnt += 1
``` | instruction | 0 | 81,866 | 9 | 163,732 |
No | output | 1 | 81,866 | 9 | 163,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
i=0
j=n-1
if n==1:
print(1,*a,0)
else:
m,p,c,sb=0,0,0,0
while i<j:
if c%2==0:
if i==0:
sa=a[0]
i=i+1
while sa<=p and i<j:
sa=sa+a[i]
i=i+1
m=m+1
p=sa
else:
while sb<=p and i<j:
sb=sb+a[j]
j=j-1
m=m+1
p=sb
c=c+1
if c%2:
for i in range(i,j+1):
sb=sb+a[i]
print(m-1,sa,sb)
``` | instruction | 0 | 81,867 | 9 | 163,734 |
No | output | 1 | 81,867 | 9 | 163,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3
Submitted Solution:
```
from typing import List
def aliceBobAndCandies(candies: int, sizes: List[int]) -> None:
moves = 0
min = sizes[0]
aliceTurn = True
alice_size = 0
bob_size = 0
while(sum(sizes) > min):
bite = 0
i = 0
if (aliceTurn):
while (bite < min):
bite += sizes[i]
del (sizes[i])
alice_size += bite
aliceTurn = False
else:
while (bite < min):
bite += sizes[len(sizes) - 1 - i]
del (sizes[len(sizes) - 1 - i])
bob_size += bite
aliceTurn = True
min = bite + 1
moves += 1
moves += 1
if (aliceTurn):
alice_size += sum(sizes)
else:
bob_size += sum(sizes)
print(moves, end=" ")
print(alice_size, end=" ")
print(bob_size, end=" ")
print()
test_cases = int(input())
for i in range(test_cases):
candies = int(input())
sizes = input().split()
sizes = list(map(int, sizes))
aliceBobAndCandies(candies, sizes)
``` | instruction | 0 | 81,868 | 9 | 163,736 |
No | output | 1 | 81,868 | 9 | 163,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n candies in a row, they are numbered from left to right from 1 to n. The size of the i-th candy is a_i.
Alice and Bob play an interesting and tasty game: they eat candy. Alice will eat candy from left to right, and Bob — from right to left. The game ends if all the candies are eaten.
The process consists of moves. During a move, the player eats one or more sweets from her/his side (Alice eats from the left, Bob — from the right).
Alice makes the first move. During the first move, she will eat 1 candy (its size is a_1). Then, each successive move the players alternate — that is, Bob makes the second move, then Alice, then again Bob and so on.
On each move, a player counts the total size of candies eaten during the current move. Once this number becomes strictly greater than the total size of candies eaten by the other player on their previous move, the current player stops eating and the move ends. In other words, on a move, a player eats the smallest possible number of candies such that the sum of the sizes of candies eaten on this move is strictly greater than the sum of the sizes of candies that the other player ate on the previous move. If there are not enough candies to make a move this way, then the player eats up all the remaining candies and the game ends.
For example, if n=11 and a=[3,1,4,1,5,9,2,6,5,3,5], then:
* move 1: Alice eats one candy of size 3 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3,5].
* move 2: Alice ate 3 on the previous move, which means Bob must eat 4 or more. Bob eats one candy of size 5 and the sequence of candies becomes [1,4,1,5,9,2,6,5,3].
* move 3: Bob ate 5 on the previous move, which means Alice must eat 6 or more. Alice eats three candies with the total size of 1+4+1=6 and the sequence of candies becomes [5,9,2,6,5,3].
* move 4: Alice ate 6 on the previous move, which means Bob must eat 7 or more. Bob eats two candies with the total size of 3+5=8 and the sequence of candies becomes [5,9,2,6].
* move 5: Bob ate 8 on the previous move, which means Alice must eat 9 or more. Alice eats two candies with the total size of 5+9=14 and the sequence of candies becomes [2,6].
* move 6 (the last): Alice ate 14 on the previous move, which means Bob must eat 15 or more. It is impossible, so Bob eats the two remaining candies and the game ends.
Print the number of moves in the game and two numbers:
* a — the total size of all sweets eaten by Alice during the game;
* b — the total size of all sweets eaten by Bob during the game.
Input
The first line contains an integer t (1 ≤ t ≤ 5000) — the number of test cases in the input. The following are descriptions of the t test cases.
Each test case consists of two lines. The first line contains an integer n (1 ≤ n ≤ 1000) — the number of candies. The second line contains a sequence of integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 1000) — the sizes of candies in the order they are arranged from left to right.
It is guaranteed that the sum of the values of n for all sets of input data in a test does not exceed 2⋅10^5.
Output
For each set of input data print three integers — the number of moves in the game and the required values a and b.
Example
Input
7
11
3 1 4 1 5 9 2 6 5 3 5
1
1000
3
1 1 1
13
1 2 3 4 5 6 7 8 9 10 11 12 13
2
2 1
6
1 1 1 1 1 1
7
1 1 1 1 1 1 1
Output
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3
Submitted Solution:
```
from math import *
t=int(input())
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
al=a[0]
bo=0
al1=a[0]
bo1=0
i=1
j=n-1
moves=1
flag=True
while(i<=j):
if(flag):
bo1=0
while(i<=j and al1>=bo1):
bo1+=a[j]
#print("Bob",a[j])
j-=1
if(i==j and bo1>=al1):
bo1+=a[j]
j-=1
break
bo+=bo1
moves+=1
flag=False
else:
al1=0
while(i<=j and bo1>=al1):
al1+=a[i]
#print("Alice",a[i])
i+=1
if(i==j and bo1>=al1):
al1+=a[i]
i+=1
break
al+=al1
moves+=1
flag=True
print(moves,al,bo)
``` | instruction | 0 | 81,869 | 9 | 163,738 |
No | output | 1 | 81,869 | 9 | 163,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular cake, represented as an r × c grid. Each cell either has an evil strawberry, or is empty. For example, a 3 × 4 cake may look as follows:
<image>
The cakeminator is going to eat the cake! Each time he eats, he chooses a row or a column that does not contain any evil strawberries and contains at least one cake cell that has not been eaten before, and eats all the cake cells there. He may decide to eat any number of times.
Please output the maximum number of cake cells that the cakeminator can eat.
Input
The first line contains two integers r and c (2 ≤ r, c ≤ 10), denoting the number of rows and the number of columns of the cake. The next r lines each contains c characters — the j-th character of the i-th line denotes the content of the cell at row i and column j, and is either one of these:
* '.' character denotes a cake cell with no evil strawberry;
* 'S' character denotes a cake cell with an evil strawberry.
Output
Output the maximum number of cake cells that the cakeminator can eat.
Examples
Input
3 4
S...
....
..S.
Output
8
Note
For the first example, one possible way to eat the maximum number of cake cells is as follows (perform 3 eats).
<image> <image> <image> | instruction | 0 | 82,047 | 9 | 164,094 |
Tags: brute force, implementation
Correct Solution:
```
# Cakeminator
def cake(s):
ans = 0
for i, n in enumerate(s):
if 'S' in n:
continue
else:
s[i] = ['E'] * len(n)
ans += len(n)
x = list(zip(*s))
for i, n in enumerate(x):
if 'S' in n:
continue
else:
ans += n.count('.')
return ans
r, c = list(map(int, input().rstrip().split()))
s = []
for i in range(r):
x = list(input())
s.append(x)
print(cake(s))
``` | output | 1 | 82,047 | 9 | 164,095 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular cake, represented as an r × c grid. Each cell either has an evil strawberry, or is empty. For example, a 3 × 4 cake may look as follows:
<image>
The cakeminator is going to eat the cake! Each time he eats, he chooses a row or a column that does not contain any evil strawberries and contains at least one cake cell that has not been eaten before, and eats all the cake cells there. He may decide to eat any number of times.
Please output the maximum number of cake cells that the cakeminator can eat.
Input
The first line contains two integers r and c (2 ≤ r, c ≤ 10), denoting the number of rows and the number of columns of the cake. The next r lines each contains c characters — the j-th character of the i-th line denotes the content of the cell at row i and column j, and is either one of these:
* '.' character denotes a cake cell with no evil strawberry;
* 'S' character denotes a cake cell with an evil strawberry.
Output
Output the maximum number of cake cells that the cakeminator can eat.
Examples
Input
3 4
S...
....
..S.
Output
8
Note
For the first example, one possible way to eat the maximum number of cake cells is as follows (perform 3 eats).
<image> <image> <image> | instruction | 0 | 82,048 | 9 | 164,096 |
Tags: brute force, implementation
Correct Solution:
```
import sys
import math
#to read string
get_string = lambda: sys.stdin.readline().strip()
#to read list of integers
get_int_list = lambda: list( map(int,sys.stdin.readline().strip().split()) )
#to read non spaced string and elements are integers to list of int
get_intList_from_str = lambda: list(map(int,list(sys.stdin.readline().strip())))
#to read non spaced string and elements are character to list of character
get_charList_from_str = lambda: list(sys.stdin.readline().strip())
#get word sepetared list of character
get_char_list = lambda: sys.stdin.readline().strip().split()
#to read integers
get_int = lambda: int(sys.stdin.readline())
#to print faster
pt = lambda x: sys.stdout.write(str(x))
#--------------------------------WhiteHat010--------------------------------------#
r,c = get_int_list()
matrix = [0]*r
for i in range(r):
matrix[i] = get_charList_from_str()
count = 0
for i in range(r):
if 'S' not in matrix[i]:
count += matrix[i].count('.')
matrix[i] = list(''.join(matrix[i]).replace('.','#'))
for j in range(c):
temp = [matrix[i][j] for i in range(r)]
if 'S' not in temp:
count += temp.count('.')
print(count)
``` | output | 1 | 82,048 | 9 | 164,097 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular cake, represented as an r × c grid. Each cell either has an evil strawberry, or is empty. For example, a 3 × 4 cake may look as follows:
<image>
The cakeminator is going to eat the cake! Each time he eats, he chooses a row or a column that does not contain any evil strawberries and contains at least one cake cell that has not been eaten before, and eats all the cake cells there. He may decide to eat any number of times.
Please output the maximum number of cake cells that the cakeminator can eat.
Input
The first line contains two integers r and c (2 ≤ r, c ≤ 10), denoting the number of rows and the number of columns of the cake. The next r lines each contains c characters — the j-th character of the i-th line denotes the content of the cell at row i and column j, and is either one of these:
* '.' character denotes a cake cell with no evil strawberry;
* 'S' character denotes a cake cell with an evil strawberry.
Output
Output the maximum number of cake cells that the cakeminator can eat.
Examples
Input
3 4
S...
....
..S.
Output
8
Note
For the first example, one possible way to eat the maximum number of cake cells is as follows (perform 3 eats).
<image> <image> <image> | instruction | 0 | 82,049 | 9 | 164,098 |
Tags: brute force, implementation
Correct Solution:
```
n,k =map(int,input().split())
a=[]
c=[]
x=0
d=0
for i in range (n):
a.append(input())
for i in range (n-1,-1,-1):
if not "S" in a[i]:
x+=len(a[i])
del a[i]
d+=1
for i in range (k):
b=[]
for j in range (n-d):
b.append(a[j][i])
c.append(b)
c[i]=''.join(c[i])
for i in range (k-1,-1,-1):
if not "S" in c[i]:
x+=len(c[i])
del c[i]
d+=1
print(x)
``` | output | 1 | 82,049 | 9 | 164,099 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular cake, represented as an r × c grid. Each cell either has an evil strawberry, or is empty. For example, a 3 × 4 cake may look as follows:
<image>
The cakeminator is going to eat the cake! Each time he eats, he chooses a row or a column that does not contain any evil strawberries and contains at least one cake cell that has not been eaten before, and eats all the cake cells there. He may decide to eat any number of times.
Please output the maximum number of cake cells that the cakeminator can eat.
Input
The first line contains two integers r and c (2 ≤ r, c ≤ 10), denoting the number of rows and the number of columns of the cake. The next r lines each contains c characters — the j-th character of the i-th line denotes the content of the cell at row i and column j, and is either one of these:
* '.' character denotes a cake cell with no evil strawberry;
* 'S' character denotes a cake cell with an evil strawberry.
Output
Output the maximum number of cake cells that the cakeminator can eat.
Examples
Input
3 4
S...
....
..S.
Output
8
Note
For the first example, one possible way to eat the maximum number of cake cells is as follows (perform 3 eats).
<image> <image> <image> | instruction | 0 | 82,050 | 9 | 164,100 |
Tags: brute force, implementation
Correct Solution:
```
m, n = map(int,input().split(' '))
m_set = set()
n_set = set()
for a in range(m):
s = input()
for b, c in enumerate(s):
if c == 'S':
m_set.add(a)
n_set.add(b)
print(m * n - len(m_set) * len(n_set))
``` | output | 1 | 82,050 | 9 | 164,101 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular cake, represented as an r × c grid. Each cell either has an evil strawberry, or is empty. For example, a 3 × 4 cake may look as follows:
<image>
The cakeminator is going to eat the cake! Each time he eats, he chooses a row or a column that does not contain any evil strawberries and contains at least one cake cell that has not been eaten before, and eats all the cake cells there. He may decide to eat any number of times.
Please output the maximum number of cake cells that the cakeminator can eat.
Input
The first line contains two integers r and c (2 ≤ r, c ≤ 10), denoting the number of rows and the number of columns of the cake. The next r lines each contains c characters — the j-th character of the i-th line denotes the content of the cell at row i and column j, and is either one of these:
* '.' character denotes a cake cell with no evil strawberry;
* 'S' character denotes a cake cell with an evil strawberry.
Output
Output the maximum number of cake cells that the cakeminator can eat.
Examples
Input
3 4
S...
....
..S.
Output
8
Note
For the first example, one possible way to eat the maximum number of cake cells is as follows (perform 3 eats).
<image> <image> <image> | instruction | 0 | 82,051 | 9 | 164,102 |
Tags: brute force, implementation
Correct Solution:
```
r, c = map(int, input().split())
cake = []
eat = r * c
rows = set()
cols = set()
for i in range(r):
cake.append([i for i in input()])
for j, char in enumerate(cake[i]):
if (char == 'S'):
rows.add(i)
cols.add(j)
print (eat - (len(rows) * len(cols)))
``` | output | 1 | 82,051 | 9 | 164,103 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular cake, represented as an r × c grid. Each cell either has an evil strawberry, or is empty. For example, a 3 × 4 cake may look as follows:
<image>
The cakeminator is going to eat the cake! Each time he eats, he chooses a row or a column that does not contain any evil strawberries and contains at least one cake cell that has not been eaten before, and eats all the cake cells there. He may decide to eat any number of times.
Please output the maximum number of cake cells that the cakeminator can eat.
Input
The first line contains two integers r and c (2 ≤ r, c ≤ 10), denoting the number of rows and the number of columns of the cake. The next r lines each contains c characters — the j-th character of the i-th line denotes the content of the cell at row i and column j, and is either one of these:
* '.' character denotes a cake cell with no evil strawberry;
* 'S' character denotes a cake cell with an evil strawberry.
Output
Output the maximum number of cake cells that the cakeminator can eat.
Examples
Input
3 4
S...
....
..S.
Output
8
Note
For the first example, one possible way to eat the maximum number of cake cells is as follows (perform 3 eats).
<image> <image> <image> | instruction | 0 | 82,052 | 9 | 164,104 |
Tags: brute force, implementation
Correct Solution:
```
r, c = [int(i) for i in input().split()]
a = []
ans = 0
h = r
for i in range(r):
cur = list(input().split()[0])
if 'S' not in cur:
ans+=c
h-=1
else:
a.append(cur)
a_t = list(zip(*a))
for elem in a_t:
if 'S' not in elem:
ans+=h
print (ans)
``` | output | 1 | 82,052 | 9 | 164,105 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular cake, represented as an r × c grid. Each cell either has an evil strawberry, or is empty. For example, a 3 × 4 cake may look as follows:
<image>
The cakeminator is going to eat the cake! Each time he eats, he chooses a row or a column that does not contain any evil strawberries and contains at least one cake cell that has not been eaten before, and eats all the cake cells there. He may decide to eat any number of times.
Please output the maximum number of cake cells that the cakeminator can eat.
Input
The first line contains two integers r and c (2 ≤ r, c ≤ 10), denoting the number of rows and the number of columns of the cake. The next r lines each contains c characters — the j-th character of the i-th line denotes the content of the cell at row i and column j, and is either one of these:
* '.' character denotes a cake cell with no evil strawberry;
* 'S' character denotes a cake cell with an evil strawberry.
Output
Output the maximum number of cake cells that the cakeminator can eat.
Examples
Input
3 4
S...
....
..S.
Output
8
Note
For the first example, one possible way to eat the maximum number of cake cells is as follows (perform 3 eats).
<image> <image> <image> | instruction | 0 | 82,053 | 9 | 164,106 |
Tags: brute force, implementation
Correct Solution:
```
class CodeforcesTask330ASolution:
def __init__(self):
self.result = ''
self.r_c = []
self.cake = []
def read_input(self):
self.r_c = [int(x) for x in input().split(" ")]
for r in range(self.r_c[0]):
self.cake.append(list(input()))
def process_task(self):
for r in range(self.r_c[0]):
for c in range(self.r_c[1]):
if self.cake[r][c] == "S":
for x in range(self.r_c[0]):
if self.cake[x][c] == ".":
self.cake[x][c] = "r"
elif self.cake[x][c] == "s":
self.cake[x][c] = "S"
for y in range(self.r_c[1]):
if self.cake[r][y] == ".":
self.cake[r][y] = "s"
elif self.cake[r][y] == "r":
self.cake[r][y] = "S"
self.result = str(self.r_c[0] * self.r_c[1] - ("".join(["".join(x) for x in self.cake])).count("S"))
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask330ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
``` | output | 1 | 82,053 | 9 | 164,107 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given a rectangular cake, represented as an r × c grid. Each cell either has an evil strawberry, or is empty. For example, a 3 × 4 cake may look as follows:
<image>
The cakeminator is going to eat the cake! Each time he eats, he chooses a row or a column that does not contain any evil strawberries and contains at least one cake cell that has not been eaten before, and eats all the cake cells there. He may decide to eat any number of times.
Please output the maximum number of cake cells that the cakeminator can eat.
Input
The first line contains two integers r and c (2 ≤ r, c ≤ 10), denoting the number of rows and the number of columns of the cake. The next r lines each contains c characters — the j-th character of the i-th line denotes the content of the cell at row i and column j, and is either one of these:
* '.' character denotes a cake cell with no evil strawberry;
* 'S' character denotes a cake cell with an evil strawberry.
Output
Output the maximum number of cake cells that the cakeminator can eat.
Examples
Input
3 4
S...
....
..S.
Output
8
Note
For the first example, one possible way to eat the maximum number of cake cells is as follows (perform 3 eats).
<image> <image> <image> | instruction | 0 | 82,054 | 9 | 164,108 |
Tags: brute force, implementation
Correct Solution:
```
r,c=map(int,input().strip().split())
l=[]
R=0
C=0
z=0
C1=set()
for i in range(r):
l.append(input())
if l[i].find('S',0)== -1:
z+=1
else:
R+=1
for i in range(r):
for j in range(c):
if l[i][j]=='S':
C1.add(j)
C=len(C1)
print(r*c-R*C)
``` | output | 1 | 82,054 | 9 | 164,109 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.