message stringlengths 2 67k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 463 109k | cluster float64 19 19 | __index_level_0__ int64 926 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki will play a game. They will repeatedly play it until one of them have N wins in total.
When they play the game once, Takahashi wins with probability A %, Aoki wins with probability B %, and the game ends in a draw (that is, nobody wins) with probability C %. Find the expected number of games that will be played, and print it as follows.
We can represent the expected value as P/Q with coprime integers P and Q. Print the integer R between 0 and 10^9+6 (inclusive) such that R \times Q \equiv P\pmod {10^9+7}. (Such an integer R always uniquely exists under the constraints of this problem.)
Constraints
* 1 \leq N \leq 100000
* 0 \leq A,B,C \leq 100
* 1 \leq A+B
* A+B+C=100
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
Output
Print the expected number of games that will be played, in the manner specified in the statement.
Examples
Input
1 25 25 50
Output
2
Input
4 50 50 0
Output
312500008
Input
1 100 0 0
Output
1
Input
100000 31 41 28
Output
104136146
Submitted Solution:
```
import itertools
import os
import sys
sys.setrecursionlimit(2147483647)
INF = float('inf')
if os.getenv('LOCAL'):
sys.stdin = open('_in.txt')
def mod_inv(a):
"""
a の逆元
:param int a:
:return:
"""
return pow(a, MOD - 2, MOD)
# https://atcoder.jp/contests/abc066/submissions/5721975
def mod_invs(max, mod):
"""
逆元のリスト 0 から max まで
:param max:
:param mod:
:return:
"""
invs = [1] * (max + 1)
for x in range(2, max + 1):
invs[x] = (-(mod // x) * invs[mod % x]) % mod
return invs
def factorials(max, mod=None):
"""
階乗 0!, 1!, 2!, ..., max!
:param int max:
:param int mod:
:return:
"""
ret = [1]
n = 1
if mod:
for i in range(1, max + 1):
n *= i
n %= mod
ret.append(n)
else:
for i in range(1, max + 1):
n *= i
ret.append(n)
return ret
MOD = 10 ** 9 + 7
N, A, B, C = list(map(int, sys.stdin.readline().split()))
# R * Q % MOD == P ってことは
# P * inv(Q) % MOD == R なのでこれを求めればいい
# --- ふつうに期待値求めてみる ---
# # 引き分けなしの値にする
# A /= 100 - C
# B /= 100 - C
# C /= 100
#
# # 引き分けなしで A が勝つときの回数の期待値
# a = 0
# for i in range(N):
# a += A ** N * B ** i * math.factorial(N + i - 1) / math.factorial(N - 1) / math.factorial(i) * (N + i)
# # 引き分けなしで B が勝つときの回数の期待値
# b = 0
# for i in range(N):
# b += B ** N * A ** i * math.factorial(N + i - 1) / math.factorial(N - 1) / math.factorial(i) * (N + i)
#
# # C 以外が起こる期待値なので 1/(1-C) をかける
# ans = (a + b) / (1 - C)
# print(ans)
# --- 愚直解 ---
# ans = 0
# # 引き分けなしで A が勝つときの回数の期待値
# for i in range(N):
# ans += pow(A * mod_inv(100 - C), N, MOD) \
# * pow(B * mod_inv(100 - C), i, MOD) \
# * math.factorial(N + i - 1) \
# * mod_inv(math.factorial(N - 1) * math.factorial(i)) \
# * (N + i)
# ans %= MOD
# # 引き分けなしで B が勝つときの回数の期待値
# for i in range(N):
# ans += pow(B * mod_inv(100 - C), N, MOD) \
# * pow(A * mod_inv(100 - C), i, MOD) \
# * math.factorial(N + i - 1) \
# * mod_inv(math.factorial(N - 1) * math.factorial(i)) \
# * (N + i)
# ans %= MOD
# # 引き分けを考慮
# ans *= 100 * mod_inv(100 - C)
# print(ans % MOD)
# invs = mod_invs(max=max(N, 100), mod=MOD)
# fs = factorials(max=2 * N, mod=MOD)
# ans = 0
# # 引き分けなしで A が勝つときの回数の期待値
# for i in range(N):
# ans += pow(A * invs[100 - C], N, MOD) \
# * pow(B * invs[100 - C], i, MOD) \
# * fs[N + i - 1] \
# * mod_inv(fs[N - 1] * fs[i]) \
# * (N + i)
# ans %= MOD
# # 引き分けなしで B が勝つときの回数の期待値
# for i in range(N):
# ans += pow(B * invs[100 - C], N, MOD) \
# * pow(A * invs[100 - C], i, MOD) \
# * fs[N + i - 1] \
# * mod_inv(fs[N - 1] * fs[i]) \
# * (N + i) % MOD
# ans %= MOD
# # 引き分けを考慮
# ans *= 100 * invs[100 - C]
# print(ans % MOD)
invs = mod_invs(max=max(N, 100), mod=MOD)
fs = factorials(max=2 * N, mod=MOD)
A *= invs[100 - C]
B *= invs[100 - C]
A_powers = list(itertools.accumulate([1] * (N + 1), lambda p, _: p * A % MOD))
B_powers = list(itertools.accumulate([1] * (N + 1), lambda p, _: p * B % MOD))
ans = 0
for i in range(N):
ans += ((A_powers[N] * B_powers[i] + B_powers[N] * A_powers[i])
* fs[N + i - 1] * mod_inv(fs[N - 1] * fs[i])
* (N + i))
ans %= MOD
# 引き分けを考慮
ans *= 100 * invs[100 - C]
print(ans % MOD)
``` | instruction | 0 | 49,458 | 19 | 98,916 |
No | output | 1 | 49,458 | 19 | 98,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki will play a game. They will repeatedly play it until one of them have N wins in total.
When they play the game once, Takahashi wins with probability A %, Aoki wins with probability B %, and the game ends in a draw (that is, nobody wins) with probability C %. Find the expected number of games that will be played, and print it as follows.
We can represent the expected value as P/Q with coprime integers P and Q. Print the integer R between 0 and 10^9+6 (inclusive) such that R \times Q \equiv P\pmod {10^9+7}. (Such an integer R always uniquely exists under the constraints of this problem.)
Constraints
* 1 \leq N \leq 100000
* 0 \leq A,B,C \leq 100
* 1 \leq A+B
* A+B+C=100
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
Output
Print the expected number of games that will be played, in the manner specified in the statement.
Examples
Input
1 25 25 50
Output
2
Input
4 50 50 0
Output
312500008
Input
1 100 0 0
Output
1
Input
100000 31 41 28
Output
104136146
Submitted Solution:
```
n,a,b,c=(int(i)for i in input().split())
if a>b:
d=a
else:
d=b
e=n/(d/100)
for i in range(10**9):
if ((i+1)*d)%(10**9+7)==(100*n)%(10**9+7):
print(i+1)
break
``` | instruction | 0 | 49,459 | 19 | 98,918 |
No | output | 1 | 49,459 | 19 | 98,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi and Aoki will play a game. They will repeatedly play it until one of them have N wins in total.
When they play the game once, Takahashi wins with probability A %, Aoki wins with probability B %, and the game ends in a draw (that is, nobody wins) with probability C %. Find the expected number of games that will be played, and print it as follows.
We can represent the expected value as P/Q with coprime integers P and Q. Print the integer R between 0 and 10^9+6 (inclusive) such that R \times Q \equiv P\pmod {10^9+7}. (Such an integer R always uniquely exists under the constraints of this problem.)
Constraints
* 1 \leq N \leq 100000
* 0 \leq A,B,C \leq 100
* 1 \leq A+B
* A+B+C=100
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N A B C
Output
Print the expected number of games that will be played, in the manner specified in the statement.
Examples
Input
1 25 25 50
Output
2
Input
4 50 50 0
Output
312500008
Input
1 100 0 0
Output
1
Input
100000 31 41 28
Output
104136146
Submitted Solution:
```
from scipy.misc import comb
N, A, B, C = map(int,input().split())
a, b, c = A/100, B/100, C/100
if N == 1:
p = 1
else:
a_, b_, p_ = a/(a+b), b/(a+b), 0
p = float(comb(2*N-3,N-2) * ( a**N * b**(N-2) + a**(N-2) * b**N))
n = (a+b+c)/(1-c)
print(int(round(n*p)))
``` | instruction | 0 | 49,460 | 19 | 98,920 |
No | output | 1 | 49,460 | 19 | 98,921 |
Provide a correct Python 3 solution for this coding contest problem.
As the proverb says,
> "Patience is bitter, but its fruit is sweet."
Writing programs within the limited time may impose some patience on you, but you enjoy it and win the contest, we hope.
The word "patience" has the meaning of perseverance, but it has another meaning in card games. Card games for one player are called "patience" in the UK and "solitaire" in the US.
Let's play a patience in this problem.
In this card game, you use only twenty cards whose face values are positive and less than or equal to 5 (Ace's value is 1 as usual). Just four cards are available for each face value.
At the beginning, the twenty cards are laid in five rows by four columns (See Figure 1). All the cards are dealt face up.
An example of the initial layout is shown in Figure 2.
<image> | <image>
---|---
Figure 1: Initial layout | Figure 2: Example of the initial layout
The purpose of the game is to remove as many cards as possible by repeatedly removing a pair of neighboring cards of the same face value. Let us call such a pair a matching pair.
The phrase "a pair of neighboring cards" means a pair of cards which are adjacent to each other. For example, in Figure 1, C6 is adjacent to any of the following eight cards:
C1, C2, C3, C5, C7, C9, C10 and C11. In contrast, C3 is adjacent to only the following three cards: C2, C6 and C7.
Every time you remove a pair, you must rearrange the remaining cards as compact as possible.
To put it concretely, each remaining card Ci must be examined in turn in its subscript order to be shifted to the uppermost-leftmost space.
How to play:
1. Search a matching pair.
2. When you find more than one pair, choose one.
In Figure 3, you decided to remove the pair of C6 and C9.
3. Remove the pair. (See Figure 4)
4. Shift the remaining cards to the uppermost-leftmost space (See Figure 5, 6).
5. Repeat the above procedure until you cannot remove any pair.
<image> | <image>
---|---
Figure 3: A matching pair found | Figure 4: Remove the matching pair
<image> | <image>
---|---
Figure 5: Shift the remaining cards | Figure 6: Rearranged layout
If you can remove all the twenty cards, you win the game and your penalty is 0. If you leave some cards, you lose the game and your penalty is the number of the remaining cards.
Whenever you find multiple matching pairs, you must choose one pair out of them as in the step 2 of the above procedure. The result of the game depends on these choices.
Your job is to write a program which answers the minimal penalty for each initial layout.
Input
The input consists of multiple card layouts. The input is given in the following format.
N
Layout0
Layout1
...
LayoutN-1
N is the number of card layouts. Each card layout gives the initial state of a game. A card layout is given in the following format.
C0 C1 C2 C3
C4 C5 C6 C7
C8 C9 C10 C11
C12 C13 C14 C15
C16 C17 C18 C19
Ci (0 <= i <= 19) is an integer from 1 to 5 which represents the face value of the card.
Output
For every initial card layout, the minimal penalty should be output, each in a separate line.
Example
Input
4
1 4 5 2
3 1 4 3
5 4 2 2
4 5 2 3
1 1 3 5
5 1 5 1
4 5 3 2
3 2 1 4
1 4 5 3
2 3 4 2
1 2 1 2
5 4 5 4
2 1 2 1
3 5 3 4
3 3 5 4
4 2 3 1
2 5 3 1
3 5 4 2
1 5 4 1
4 5 3 2
Output
0
4
12
0 | instruction | 0 | 49,562 | 19 | 99,124 |
"Correct Solution:
```
# AOJ 1110: Patience
# Python3 2018.7.8 bal4u
pair = [[1,4,5], [2,4,5,6], [3,5,6,7], [6,7], [5,8,9],
[6,8,9,10], [7,9,10,11], [10,11], [9,12,13], [10,12,13,14],
[11,13,14,15], [14,15], [13,16,17], [14,16,17,18], [15,17,18,19],
[18,19], [17], [18], [19]]
def combi(cd, n):
global ans
ans = min(ans, n)
if n == 0: return True
for p in range(n-1):
a = (cd >> (p*3)) & 7
for q in pair[p]:
b = (cd >> (q*3)) & 7
if a != b: continue
b1 = cd & ((1<<(p*3))-1)
b2 = (cd >> (p+1)*3) & ((1<<(q-p-1)*3)-1)
b3 = (cd >> (q+1)*3) & ((1<<(n-q-1)*3)-1)
nc = b1 | (b2<<(p*3)) | (b3<<(q-1)*3)
if combi(nc, n-2): return True
return False
for _ in range(int(input())):
k = []
for i in range(5):
k.extend(list(map(int, input().split())))
card = 0
for i in range(19, -1, -1): card = (card<<3)|k[i]
ans = 20
combi(card, 20)
print(ans)
``` | output | 1 | 49,562 | 19 | 99,125 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The King of Flatland will organize a knights' tournament! The winner will get half the kingdom and the favor of the princess of legendary beauty and wisdom. The final test of the applicants' courage and strength will be a fencing tournament. The tournament is held by the following rules: the participants fight one on one, the winner (or rather, the survivor) transfers to the next round.
Before the battle both participants stand at the specified points on the Ox axis with integer coordinates. Then they make moves in turn. The first participant moves first, naturally. During a move, the first participant can transfer from the point x to any integer point of the interval [x + a; x + b]. The second participant can transfer during a move to any integer point of the interval [x - b; x - a]. That is, the options for the players' moves are symmetric (note that the numbers a and b are not required to be positive, and if a ≤ 0 ≤ b, then staying in one place is a correct move). At any time the participants can be located arbitrarily relative to each other, that is, it is allowed to "jump" over the enemy in any direction. A participant wins if he uses his move to transfer to the point where his opponent is.
Of course, the princess has already chosen a husband and now she wants to make her sweetheart win the tournament. He has already reached the tournament finals and he is facing the last battle. The princess asks the tournament manager to arrange the tournament finalists in such a way that her sweetheart wins the tournament, considering that both players play optimally. However, the initial location of the participants has already been announced, and we can only pull some strings and determine which participant will be first and which one will be second. But how do we know which participant can secure the victory? Alas, the princess is not learned in the military affairs... Therefore, she asks you to determine how the battle will end considering that both opponents play optimally. Also, if the first player wins, your task is to determine his winning move.
Input
The first line contains four space-separated integers — x1, x2, a and b (x1 ≠ x2, a ≤ b, - 109 ≤ x1, x2, a, b ≤ 109) — coordinates of the points where the first and the second participant start, and the numbers that determine the players' moves, correspondingly.
Output
On the first line print the outcome of the battle as "FIRST" (without the quotes), if both players play optimally and the first player wins. Print "SECOND" (without the quotes) if the second player wins and print "DRAW" (without the quotes), if nobody is able to secure the victory.
If the first player wins, print on the next line the single integer x — the coordinate of the point where the first player should transfer to win. The indicated move should be valid, that is, it should meet the following condition: x1 + a ≤ x ≤ x1 + b. If there are several winning moves, print any of them. If the first participant can't secure the victory, then you do not have to print anything.
Examples
Input
0 2 0 4
Output
FIRST
2
Input
0 2 1 1
Output
SECOND
Input
0 2 0 1
Output
DRAW
Note
In the first sample the first player can win in one move.
In the second sample the first participant must go to point 1, where the second participant immediately goes and wins.
In the third sample changing the position isn't profitable to either participant, so nobody wins. | instruction | 0 | 49,924 | 19 | 99,848 |
Tags: games, math
Correct Solution:
```
x1, x2, a, b = map(int, input().split())
if a <= 0 <= b:
if x1 < x2:
if x2 - x1 <= b:
print("FIRST")
print(x2)
else:
print("DRAW")
else:
if x1 - x2 <= -a:
print("FIRST")
print(x2)
else:
print("DRAW")
else:
reverse = False
if a < 0:
x1, x2, a, b = -x1, -x2, -b, -a
reverse = True
if x1 > x2:
print("DRAW")
else:
if (x2 - x1) % (a + b) == 0:
print("SECOND")
elif a <= (x2 - x1) % (a + b) <= b:
print("FIRST")
print((x1 + (x2 - x1) % (a + b))
if not reverse else -(x1 + (x2 - x1) % (a + b)))
else:
print("DRAW")
``` | output | 1 | 49,924 | 19 | 99,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The King of Flatland will organize a knights' tournament! The winner will get half the kingdom and the favor of the princess of legendary beauty and wisdom. The final test of the applicants' courage and strength will be a fencing tournament. The tournament is held by the following rules: the participants fight one on one, the winner (or rather, the survivor) transfers to the next round.
Before the battle both participants stand at the specified points on the Ox axis with integer coordinates. Then they make moves in turn. The first participant moves first, naturally. During a move, the first participant can transfer from the point x to any integer point of the interval [x + a; x + b]. The second participant can transfer during a move to any integer point of the interval [x - b; x - a]. That is, the options for the players' moves are symmetric (note that the numbers a and b are not required to be positive, and if a ≤ 0 ≤ b, then staying in one place is a correct move). At any time the participants can be located arbitrarily relative to each other, that is, it is allowed to "jump" over the enemy in any direction. A participant wins if he uses his move to transfer to the point where his opponent is.
Of course, the princess has already chosen a husband and now she wants to make her sweetheart win the tournament. He has already reached the tournament finals and he is facing the last battle. The princess asks the tournament manager to arrange the tournament finalists in such a way that her sweetheart wins the tournament, considering that both players play optimally. However, the initial location of the participants has already been announced, and we can only pull some strings and determine which participant will be first and which one will be second. But how do we know which participant can secure the victory? Alas, the princess is not learned in the military affairs... Therefore, she asks you to determine how the battle will end considering that both opponents play optimally. Also, if the first player wins, your task is to determine his winning move.
Input
The first line contains four space-separated integers — x1, x2, a and b (x1 ≠ x2, a ≤ b, - 109 ≤ x1, x2, a, b ≤ 109) — coordinates of the points where the first and the second participant start, and the numbers that determine the players' moves, correspondingly.
Output
On the first line print the outcome of the battle as "FIRST" (without the quotes), if both players play optimally and the first player wins. Print "SECOND" (without the quotes) if the second player wins and print "DRAW" (without the quotes), if nobody is able to secure the victory.
If the first player wins, print on the next line the single integer x — the coordinate of the point where the first player should transfer to win. The indicated move should be valid, that is, it should meet the following condition: x1 + a ≤ x ≤ x1 + b. If there are several winning moves, print any of them. If the first participant can't secure the victory, then you do not have to print anything.
Examples
Input
0 2 0 4
Output
FIRST
2
Input
0 2 1 1
Output
SECOND
Input
0 2 0 1
Output
DRAW
Note
In the first sample the first player can win in one move.
In the second sample the first participant must go to point 1, where the second participant immediately goes and wins.
In the third sample changing the position isn't profitable to either participant, so nobody wins.
Submitted Solution:
```
x1, x2, a, b = map(int, input().split())
if a <= 0 <= b:
if x1 < x2:
if x2 - x1 <= b:
print("FIRST")
print(x2 - x1)
else:
print("DRAW")
else:
if x1 - x2 <= -a:
print("FIRST")
print(x2 - x1)
else:
print("DRAW")
else:
if a < 0:
x1, x2, a, b = -x1, -x2, -a, -b
if x1 > x2:
print("DRAW")
else:
if (x2 - x1) % (a + b) == 0:
print("SECOND")
elif a <= (x2 - x1) % (a + b) <= b:
print("FIRST")
print((x2 - x1) % (a + b))
else:
print("DRAW")
``` | instruction | 0 | 49,925 | 19 | 99,850 |
No | output | 1 | 49,925 | 19 | 99,851 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The King of Flatland will organize a knights' tournament! The winner will get half the kingdom and the favor of the princess of legendary beauty and wisdom. The final test of the applicants' courage and strength will be a fencing tournament. The tournament is held by the following rules: the participants fight one on one, the winner (or rather, the survivor) transfers to the next round.
Before the battle both participants stand at the specified points on the Ox axis with integer coordinates. Then they make moves in turn. The first participant moves first, naturally. During a move, the first participant can transfer from the point x to any integer point of the interval [x + a; x + b]. The second participant can transfer during a move to any integer point of the interval [x - b; x - a]. That is, the options for the players' moves are symmetric (note that the numbers a and b are not required to be positive, and if a ≤ 0 ≤ b, then staying in one place is a correct move). At any time the participants can be located arbitrarily relative to each other, that is, it is allowed to "jump" over the enemy in any direction. A participant wins if he uses his move to transfer to the point where his opponent is.
Of course, the princess has already chosen a husband and now she wants to make her sweetheart win the tournament. He has already reached the tournament finals and he is facing the last battle. The princess asks the tournament manager to arrange the tournament finalists in such a way that her sweetheart wins the tournament, considering that both players play optimally. However, the initial location of the participants has already been announced, and we can only pull some strings and determine which participant will be first and which one will be second. But how do we know which participant can secure the victory? Alas, the princess is not learned in the military affairs... Therefore, she asks you to determine how the battle will end considering that both opponents play optimally. Also, if the first player wins, your task is to determine his winning move.
Input
The first line contains four space-separated integers — x1, x2, a and b (x1 ≠ x2, a ≤ b, - 109 ≤ x1, x2, a, b ≤ 109) — coordinates of the points where the first and the second participant start, and the numbers that determine the players' moves, correspondingly.
Output
On the first line print the outcome of the battle as "FIRST" (without the quotes), if both players play optimally and the first player wins. Print "SECOND" (without the quotes) if the second player wins and print "DRAW" (without the quotes), if nobody is able to secure the victory.
If the first player wins, print on the next line the single integer x — the coordinate of the point where the first player should transfer to win. The indicated move should be valid, that is, it should meet the following condition: x1 + a ≤ x ≤ x1 + b. If there are several winning moves, print any of them. If the first participant can't secure the victory, then you do not have to print anything.
Examples
Input
0 2 0 4
Output
FIRST
2
Input
0 2 1 1
Output
SECOND
Input
0 2 0 1
Output
DRAW
Note
In the first sample the first player can win in one move.
In the second sample the first participant must go to point 1, where the second participant immediately goes and wins.
In the third sample changing the position isn't profitable to either participant, so nobody wins.
Submitted Solution:
```
x1, x2, a, b = map(int, input().split())
if a <= 0 <= b:
if x1 < x2:
if x2 - x1 <= b:
print("FIRST")
print(x2)
else:
print("DRAW")
else:
if x1 - x2 <= -a:
print("FIRST")
print(x2)
else:
print("DRAW")
else:
if a < 0:
x1, x2, a, b = -x1, -x2, -a, -b
if x1 > x2:
print("DRAW")
else:
if (x2 - x1) % (a + b) == 0:
print("SECOND")
elif a <= (x2 - x1) % (a + b) <= b:
print("FIRST")
print(x1 + (x2 - x1) % (a + b))
else:
print("DRAW")
``` | instruction | 0 | 49,926 | 19 | 99,852 |
No | output | 1 | 49,926 | 19 | 99,853 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand. | instruction | 0 | 50,217 | 19 | 100,434 |
Tags: implementation, math
Correct Solution:
```
l,r,a=map(int,input().split())
large=max(l,r)
small=min(l,r)
x=large-small
print((small+a)*2 if x>=a else 2*(large+int((a-x)/2)))
``` | output | 1 | 50,217 | 19 | 100,435 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand. | instruction | 0 | 50,218 | 19 | 100,436 |
Tags: implementation, math
Correct Solution:
```
l,r,a=[int(x) for x in input().split()]
if l>r:
t=2*r
x=l-r
else:
t=2*l
x=r-l
if a>x:
t=t+(2*x)
z=a-x
y=(z//2)*2
t=t+y
else:
t=t+(2*a)
print(t)
``` | output | 1 | 50,218 | 19 | 100,437 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand. | instruction | 0 | 50,219 | 19 | 100,438 |
Tags: implementation, math
Correct Solution:
```
l, r, a = map(int, input().split())
ans = min(l, r) * 2
l -= ans // 2
r -= ans // 2
if a != 0:
if a >= max(l ,r):
ans += 2 * max(l, r)
a -= max(l, r)
if a >= 2:
ans += (a - a % 2)
else:
ans += 2 * a
print(ans)
``` | output | 1 | 50,219 | 19 | 100,439 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand. | instruction | 0 | 50,220 | 19 | 100,440 |
Tags: implementation, math
Correct Solution:
```
l,r,a=list(map(int,input().split()))
while a>0:
if l>r:
r+=1
else:
l+=1
a-=1
print(min(l,r)*2)
``` | output | 1 | 50,220 | 19 | 100,441 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand. | instruction | 0 | 50,221 | 19 | 100,442 |
Tags: implementation, math
Correct Solution:
```
import sys
l,p,a = input().split()
l= int(l)
p= int(p)
a= int(a)
y = 0
r = 0
if l<=p:
l = l+a
if l == p:
print(l*2)
elif l<p:
print(l*2)
elif l>p:
if (l-p)%2 == 0:
p+=(l-p)/2
p = int(p)
print(p*2)
else:
r = l - p
l = l - r
y = r/2
y = int(y)
l+=y
p+=y
print(l*2)
sys.exit()
if p<l:
p = p+a
if l == p:
print(l*2)
elif p<l:
print(p*2)
elif p>l:
if (p-l)%2 == 0:
l+=(p-l)/2
l = int(l)
print(l*2)
else:
r = p - l
p = p - r
y = r/2
y = int(y)
l+=y
p+=y
print(l*2)
``` | output | 1 | 50,221 | 19 | 100,443 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand. | instruction | 0 | 50,222 | 19 | 100,444 |
Tags: implementation, math
Correct Solution:
```
l,r,a=map(int, input().split())
while (a!=0):
if(r>l):
l=l+1
a=a-1
elif(l>r):
r=r+1
a=a-1
else:
a=a-1
l=l+1
l=min(l,r)
r=l
print (l+r)
``` | output | 1 | 50,222 | 19 | 100,445 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand. | instruction | 0 | 50,223 | 19 | 100,446 |
Tags: implementation, math
Correct Solution:
```
l, r, a = map(int, input().split())
if l < r:
l, r = r, l
if a >= l - r:
print(2 * l + (a - l + r) - (a - l + r) % 2)
else:
print(2 * (r + a))
``` | output | 1 | 50,223 | 19 | 100,447 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand. | instruction | 0 | 50,224 | 19 | 100,448 |
Tags: implementation, math
Correct Solution:
```
import math
in_put = input('')
in_put = in_put.split(' ')
l = int(in_put[0])
r = int(in_put[1])
a = int(in_put[2])
c = 0
if (l > r):
c = r
if (a > (l - r)):
c = c + (l - r)
a = a - (l-r)
c = c + math.floor(a / 2)
elif (a <= (l - r)):
c = c + a
elif (l < r):
c = l
if (a < r - l):
c = c + a
elif (a >= r - l):
c = c + r - l
a = a - (r - l)
c = c + math.floor(a / 2)
elif (l == r):
c = l
c = c + math.floor(a / 2)
print(c*2, end='')
``` | output | 1 | 50,224 | 19 | 100,449 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand.
Submitted Solution:
```
arri = lambda: [int(s) for s in input().split()]
l, r, a = arri()
x, y = min(l, r), max(l, r)
s = 0
if x + a < y:
s = x + a
else:
s = y + (a - (y - x)) // 2
print(s*2)
``` | instruction | 0 | 50,225 | 19 | 100,450 |
Yes | output | 1 | 50,225 | 19 | 100,451 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand.
Submitted Solution:
```
import sys
def main(args):
l, r, a = map(int, input().split())
m, x = max(l, r), min(a, abs(l - r))
a, l, r = a - x, min(m, l + x), min(m, r + x)
l, r = l + (a // 2), r + (a // 2)
print(min(l, r) * 2)
if __name__ == '__main__':
sys.exit(main(sys.argv))
``` | instruction | 0 | 50,226 | 19 | 100,452 |
Yes | output | 1 | 50,226 | 19 | 100,453 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand.
Submitted Solution:
```
l,r,a = input().strip().split(' ')
l,r,a = [int(l), int(r), int(a)]
s=abs(l-r)
if s>a:
t=min(l,r)
y=t+a
print(2*y)
elif s==0:
o=int(a/2)
l=l+o
print(2*l)
else:
f=min(l,r)
f=f+s
a=a-s
r=int(a/2)
u=f+r
print(2*u)
``` | instruction | 0 | 50,227 | 19 | 100,454 |
Yes | output | 1 | 50,227 | 19 | 100,455 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand.
Submitted Solution:
```
l,r,a = map(int,input().split())
if(l==r):
print(2*(l+a//2))
elif(l>r):
add = l-r
if(a>add):
a-=add
print(2*(l+a//2))
else:
print(2*(r+a))
elif(r>l):
add = r-l
if(a>add):
a-=add
print(2*(r+a//2))
else:
print(2*(l+a))
``` | instruction | 0 | 50,228 | 19 | 100,456 |
Yes | output | 1 | 50,228 | 19 | 100,457 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand.
Submitted Solution:
```
l, r, a = [int(i) for i in input().split()]
if (l == 0 and a == 0) or (r == 0 and a == 0):
print(0)
else:
sumN = l + r + a
if sumN % 2 == 0:
print(sumN)
else:
print(sumN - 1)
``` | instruction | 0 | 50,229 | 19 | 100,458 |
No | output | 1 | 50,229 | 19 | 100,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand.
Submitted Solution:
```
l, r, a = map(int, input().split())
c = 0
if(l == r):
c = l+r
x = a // 2
c += x*2
print(c)
elif(l < r):
left = l
l += a
if(l > r):
m = l - r
r = r - m
print(l+r)
else:
right = r
n = r - l
r = r-n
print(r + l)
else:
right = r
r = r+a
if(r > l):
m = r - l
r = r - m
print(l+r)
else:
n = l - r
l = l - n
print(r + l)
``` | instruction | 0 | 50,230 | 19 | 100,460 |
No | output | 1 | 50,230 | 19 | 100,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand.
Submitted Solution:
```
a,b,c=input().split(" ")
a=int(a)
b=int(b)
c=int(c)
if a>b:
y=b+c
if y>a:
if (c-a+b)%2==0:
print(a*2+(c-a+b))
else:
print(a*2+(c-a+b))
else:
print(y*2)
elif b>a:
y=a+c
if y>b:
if(c-b+a)%2==0:
print(b*2+(c-b+a))
else:
print(y*2)
if a==b:
j=a+b+c
if j%2==0:
print(j)
else:
print(j-1)
``` | instruction | 0 | 50,231 | 19 | 100,462 |
No | output | 1 | 50,231 | 19 | 100,463 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are at a water bowling training. There are l people who play with their left hand, r people, who play with their right hand, and a ambidexters, who can play with left or right hand.
The coach decided to form a team of even number of players, exactly half of the players should play with their right hand, and exactly half of the players should play with their left hand. One player should use only on of his hands.
Ambidexters play as well with their right hand as with their left hand. In the team, an ambidexter can play with their left hand, or with their right hand.
Please find the maximum possible size of the team, where equal number of players use their left and right hands, respectively.
Input
The only line contains three integers l, r and a (0 ≤ l, r, a ≤ 100) — the number of left-handers, the number of right-handers and the number of ambidexters at the training.
Output
Print a single even integer — the maximum number of players in the team. It is possible that the team can only have zero number of players.
Examples
Input
1 4 2
Output
6
Input
5 5 5
Output
14
Input
0 2 0
Output
0
Note
In the first example you can form a team of 6 players. You should take the only left-hander and two ambidexters to play with left hand, and three right-handers to play with right hand. The only person left can't be taken into the team.
In the second example you can form a team of 14 people. You have to take all five left-handers, all five right-handers, two ambidexters to play with left hand and two ambidexters to play with right hand.
Submitted Solution:
```
l,r,a=[int(l) for l in input().split()]
if r>l and l>0:
b=r-l
if b>a:
c=b-a
n=l+a+(r-c)
if b<a:
c=a-b
if c%2==0:
n=l+r+c+b
else:
n=l+r+b
elif l>r and r>0:
b=l-r
if b>a:
c=b-a
n=r+a+(l-c)
if b<a:
c=a-b
if c%2==0:
n=l+r+c+b
else:
n=l+r+b
elif l==r:
if a%2==0:
n=l+r+a
else :
n=l+r+a-1
else:
n=0
print(n)
``` | instruction | 0 | 50,232 | 19 | 100,464 |
No | output | 1 | 50,232 | 19 | 100,465 |
Provide a correct Python 3 solution for this coding contest problem.
N players will participate in a tennis tournament. We will call them Player 1, Player 2, \ldots, Player N.
The tournament is round-robin format, and there will be N(N-1)/2 matches in total. Is it possible to schedule these matches so that all of the following conditions are satisfied? If the answer is yes, also find the minimum number of days required.
* Each player plays at most one matches in a day.
* Each player i (1 \leq i \leq N) plays one match against Player A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} in this order.
Constraints
* 3 \leq N \leq 1000
* 1 \leq A_{i, j} \leq N
* A_{i, j} \neq i
* A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} are all different.
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} \ldots A_{1, N-1}
A_{2, 1} A_{2, 2} \ldots A_{2, N-1}
:
A_{N, 1} A_{N, 2} \ldots A_{N, N-1}
Output
If it is possible to schedule all the matches so that all of the conditions are satisfied, print the minimum number of days required; if it is impossible, print `-1`.
Examples
Input
3
2 3
1 3
1 2
Output
3
Input
4
2 3 4
1 3 4
4 1 2
3 1 2
Output
4
Input
3
2 3
3 1
1 2
Output
-1 | instruction | 0 | 50,297 | 19 | 100,594 |
"Correct Solution:
```
from collections import deque
import time
start = time.time() # なにこれ
n = int(input())
target_num = n*(n-1)//2
all_set = set()
a = [deque(list(map(int, input().split()))) for i in range(n)]
ans = 0
while True:
cur_set = set()
flag = False
for i in range(n):
if len(a[i]):
tup = (min(i+1, a[i][0]), max(i+1, a[i][0]))
else:
continue
if tup not in cur_set:
cur_set.add(tup)
elif tup in cur_set:
all_set.add(tup)
t1, t2 = tup
a[t1-1].popleft()
a[t2-1].popleft()
flag = True
ans += 1
if len(all_set)==target_num:
break
if time.time()-start>1.8:
print(1000*999//2)
exit()
if not flag:
print(-1)
exit()
print(ans)
``` | output | 1 | 50,297 | 19 | 100,595 |
Provide a correct Python 3 solution for this coding contest problem.
N players will participate in a tennis tournament. We will call them Player 1, Player 2, \ldots, Player N.
The tournament is round-robin format, and there will be N(N-1)/2 matches in total. Is it possible to schedule these matches so that all of the following conditions are satisfied? If the answer is yes, also find the minimum number of days required.
* Each player plays at most one matches in a day.
* Each player i (1 \leq i \leq N) plays one match against Player A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} in this order.
Constraints
* 3 \leq N \leq 1000
* 1 \leq A_{i, j} \leq N
* A_{i, j} \neq i
* A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} are all different.
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} \ldots A_{1, N-1}
A_{2, 1} A_{2, 2} \ldots A_{2, N-1}
:
A_{N, 1} A_{N, 2} \ldots A_{N, N-1}
Output
If it is possible to schedule all the matches so that all of the conditions are satisfied, print the minimum number of days required; if it is impossible, print `-1`.
Examples
Input
3
2 3
1 3
1 2
Output
3
Input
4
2 3 4
1 3 4
4 1 2
3 1 2
Output
4
Input
3
2 3
3 1
1 2
Output
-1 | instruction | 0 | 50,298 | 19 | 100,596 |
"Correct Solution:
```
N = int(input())
A = [[x - 1 for x in list(map(int, input().split()))] for i in range(N)]
def can_match(i, A, next_set):
if not A[i]:
return
j = A[i][-1]
if A[j][-1] == i:
if i < j:
next_set.add((i, j))
else:
next_set.add((j, i))
next_set = set()
for i in range(N):
can_match(i, A, next_set)
day = 0
battle = 0
while next_set:
day += 1
current_set = next_set.copy()
next_set = set()
for match in current_set:
battle += 1
del A[match[0]][-1]
can_match(match[0], A, next_set)
del A[match[1]][-1]
can_match(match[1], A, next_set)
if battle == N*(N-1) // 2:
print(day)
else:
print(-1)
``` | output | 1 | 50,298 | 19 | 100,597 |
Provide a correct Python 3 solution for this coding contest problem.
N players will participate in a tennis tournament. We will call them Player 1, Player 2, \ldots, Player N.
The tournament is round-robin format, and there will be N(N-1)/2 matches in total. Is it possible to schedule these matches so that all of the following conditions are satisfied? If the answer is yes, also find the minimum number of days required.
* Each player plays at most one matches in a day.
* Each player i (1 \leq i \leq N) plays one match against Player A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} in this order.
Constraints
* 3 \leq N \leq 1000
* 1 \leq A_{i, j} \leq N
* A_{i, j} \neq i
* A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} are all different.
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} \ldots A_{1, N-1}
A_{2, 1} A_{2, 2} \ldots A_{2, N-1}
:
A_{N, 1} A_{N, 2} \ldots A_{N, N-1}
Output
If it is possible to schedule all the matches so that all of the conditions are satisfied, print the minimum number of days required; if it is impossible, print `-1`.
Examples
Input
3
2 3
1 3
1 2
Output
3
Input
4
2 3 4
1 3 4
4 1 2
3 1 2
Output
4
Input
3
2 3
3 1
1 2
Output
-1 | instruction | 0 | 50,299 | 19 | 100,598 |
"Correct Solution:
```
from collections import deque, defaultdict
from time import time
S = time()
N = int(input())
A = [deque(map(lambda a: int(a) - 1, input().split())) for _ in range(N)]
canBattle = defaultdict(lambda: False)
D = [0] * N
while True:
isChanged = False
for i, a in enumerate(A):
if not a:
continue
j = a[0]
canBattle[(i, j)] = True
if canBattle[(j, i)]:
isChanged = True
A[i].popleft()
A[j].popleft()
d = max(D[i], D[j])
D[i], D[j] = d + 1, d + 1
if all(len(a) == 0 for a in A):
print(max(D))
exit()
if time() - S >= 1.700:
print(N * (N - 1) // 2)
exit()
if not isChanged:
break
print(-1)
``` | output | 1 | 50,299 | 19 | 100,599 |
Provide a correct Python 3 solution for this coding contest problem.
N players will participate in a tennis tournament. We will call them Player 1, Player 2, \ldots, Player N.
The tournament is round-robin format, and there will be N(N-1)/2 matches in total. Is it possible to schedule these matches so that all of the following conditions are satisfied? If the answer is yes, also find the minimum number of days required.
* Each player plays at most one matches in a day.
* Each player i (1 \leq i \leq N) plays one match against Player A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} in this order.
Constraints
* 3 \leq N \leq 1000
* 1 \leq A_{i, j} \leq N
* A_{i, j} \neq i
* A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} are all different.
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} \ldots A_{1, N-1}
A_{2, 1} A_{2, 2} \ldots A_{2, N-1}
:
A_{N, 1} A_{N, 2} \ldots A_{N, N-1}
Output
If it is possible to schedule all the matches so that all of the conditions are satisfied, print the minimum number of days required; if it is impossible, print `-1`.
Examples
Input
3
2 3
1 3
1 2
Output
3
Input
4
2 3 4
1 3 4
4 1 2
3 1 2
Output
4
Input
3
2 3
3 1
1 2
Output
-1 | instruction | 0 | 50,302 | 19 | 100,604 |
"Correct Solution:
```
from collections import deque
n = int(input())
orders = [deque([x - 1 for x in list(map(int, input().split()))] + [-1]) for _ in range(n)]
nxt = [orders[i].popleft() for i in range(n)]
days = [0 for _ in range(n)]
q = deque([i for i in range(n)])
while q:
a = q.popleft()
b = nxt[a]
if nxt[nxt[a]] == a:
days[a], days[b] = [max(days[a], days[b]) + 1 for _ in range(2)]
nxt[a] = orders[a].popleft()
nxt[b] = orders[b].popleft()
q.append(a)
q.append(b)
if sum(nxt) == -n:
print(max(days))
else:
print(-1)
``` | output | 1 | 50,302 | 19 | 100,605 |
Provide a correct Python 3 solution for this coding contest problem.
N players will participate in a tennis tournament. We will call them Player 1, Player 2, \ldots, Player N.
The tournament is round-robin format, and there will be N(N-1)/2 matches in total. Is it possible to schedule these matches so that all of the following conditions are satisfied? If the answer is yes, also find the minimum number of days required.
* Each player plays at most one matches in a day.
* Each player i (1 \leq i \leq N) plays one match against Player A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} in this order.
Constraints
* 3 \leq N \leq 1000
* 1 \leq A_{i, j} \leq N
* A_{i, j} \neq i
* A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} are all different.
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} \ldots A_{1, N-1}
A_{2, 1} A_{2, 2} \ldots A_{2, N-1}
:
A_{N, 1} A_{N, 2} \ldots A_{N, N-1}
Output
If it is possible to schedule all the matches so that all of the conditions are satisfied, print the minimum number of days required; if it is impossible, print `-1`.
Examples
Input
3
2 3
1 3
1 2
Output
3
Input
4
2 3 4
1 3 4
4 1 2
3 1 2
Output
4
Input
3
2 3
3 1
1 2
Output
-1 | instruction | 0 | 50,303 | 19 | 100,606 |
"Correct Solution:
```
from copy import deepcopy
from heapq import heappop, heappush
n = int(input())
a = [list(map(lambda x:int(x) - 1, input().split())) for _ in range(n)]
d = [0] * n
ans = 0
temp = []
for x in range(n):
heappush(temp, x)
while 1:
next_temp = []
while len(temp) > 0:
x = heappop(temp)
if d[x] >= n-1:
continue
y = a[x][d[x]]
#print(x, y)
if y not in next_temp:
if a[y][d[y]] == x:
heappush(next_temp, x)
heappush(next_temp, y)
#print(next_temp)
for t in next_temp:
d[t] += 1
if len(next_temp) == 0:
break
temp = [] + next_temp
ans += 1
#print(d)
if d.count(n-1) == n:
print(ans)
else:
print(-1)
``` | output | 1 | 50,303 | 19 | 100,607 |
Provide a correct Python 3 solution for this coding contest problem.
N players will participate in a tennis tournament. We will call them Player 1, Player 2, \ldots, Player N.
The tournament is round-robin format, and there will be N(N-1)/2 matches in total. Is it possible to schedule these matches so that all of the following conditions are satisfied? If the answer is yes, also find the minimum number of days required.
* Each player plays at most one matches in a day.
* Each player i (1 \leq i \leq N) plays one match against Player A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} in this order.
Constraints
* 3 \leq N \leq 1000
* 1 \leq A_{i, j} \leq N
* A_{i, j} \neq i
* A_{i, 1}, A_{i, 2}, \ldots, A_{i, N-1} are all different.
Input
Input is given from Standard Input in the following format:
N
A_{1, 1} A_{1, 2} \ldots A_{1, N-1}
A_{2, 1} A_{2, 2} \ldots A_{2, N-1}
:
A_{N, 1} A_{N, 2} \ldots A_{N, N-1}
Output
If it is possible to schedule all the matches so that all of the conditions are satisfied, print the minimum number of days required; if it is impossible, print `-1`.
Examples
Input
3
2 3
1 3
1 2
Output
3
Input
4
2 3 4
1 3 4
4 1 2
3 1 2
Output
4
Input
3
2 3
3 1
1 2
Output
-1 | instruction | 0 | 50,304 | 19 | 100,608 |
"Correct Solution:
```
from collections import deque
n = int(input())
a = [list(map(int, input().split())) + [0] for i in range(n)]
for i in range(n):
for j in range(n):
a[i][j] -= 1
l = [0] * n
d = [0] * n
Q = deque(range(n))
while Q:
p = Q.popleft()
q = a[p][l[p]]
if a[q][l[q]] == p:
m = max(d[p], d[q]) + 1
d[p] = m
d[q] = m
l[p] += 1
l[q] += 1
Q.append(p)
Q.append(q)
for i in l:
if i != n - 1:
exit(print(-1))
print(max(d))
``` | output | 1 | 50,304 | 19 | 100,609 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2 | instruction | 0 | 51,192 | 19 | 102,384 |
"Correct Solution:
```
s = input()
pa = 0
gu = 0
for i in range(len(s)):
if s[i] == 'p':
pa += 1
else:
gu += 1
print((gu-pa)//2)
``` | output | 1 | 51,192 | 19 | 102,385 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2 | instruction | 0 | 51,193 | 19 | 102,386 |
"Correct Solution:
```
s = input()
N = len(s)
ans = N//2
for i in range(N):
if(s[i] == 'p'):
ans -= 1
print(ans)
``` | output | 1 | 51,193 | 19 | 102,387 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2 | instruction | 0 | 51,194 | 19 | 102,388 |
"Correct Solution:
```
import math
s = input()
np = 0
for i in range(len(s)):
if s[i] == 'p':
np += 1
print(math.floor(len(s) / 2) - np)
``` | output | 1 | 51,194 | 19 | 102,389 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2 | instruction | 0 | 51,195 | 19 | 102,390 |
"Correct Solution:
```
s=input()
n=len(s)
ans=n//2-s.count("p")
print(ans)
``` | output | 1 | 51,195 | 19 | 102,391 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2 | instruction | 0 | 51,196 | 19 | 102,392 |
"Correct Solution:
```
s = list(input())
if len(s) % 2 == 1:
ans = (s.count("g") - (s.count("p")+1)) // 2
else:
ans = (s.count("g") - s.count("p")) // 2
print(ans)
``` | output | 1 | 51,196 | 19 | 102,393 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2 | instruction | 0 | 51,197 | 19 | 102,394 |
"Correct Solution:
```
s = input()
print(len(s)//2 - s.count("p"))
``` | output | 1 | 51,197 | 19 | 102,395 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2 | instruction | 0 | 51,198 | 19 | 102,396 |
"Correct Solution:
```
s=input()
c=s.count('p')
l=len(s)
ans=l//2-c
print(ans)
``` | output | 1 | 51,198 | 19 | 102,397 |
Provide a correct Python 3 solution for this coding contest problem.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2 | instruction | 0 | 51,199 | 19 | 102,398 |
"Correct Solution:
```
def main():
s = input()
n = len(s)
g = s.count('g')
p = n - g
ans = n // 2 - p
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 51,199 | 19 | 102,399 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2
Submitted Solution:
```
s=input()
ans=-s.count("p")+len(s)//2
print(ans)
``` | instruction | 0 | 51,200 | 19 | 102,400 |
Yes | output | 1 | 51,200 | 19 | 102,401 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2
Submitted Solution:
```
s = input()
n = len(s)
gnum = s[1:].count("g")
pnum = n - gnum - 1
# print(gnum)
# print(pnum)
print((gnum - pnum + 1) // 2)
``` | instruction | 0 | 51,201 | 19 | 102,402 |
Yes | output | 1 | 51,201 | 19 | 102,403 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2
Submitted Solution:
```
s = input()
score = 0
for i in range(len(s)):
if i % 2 == 0:
if s[i] == 'p': score -= 1
else:
if s[i] == 'g': score += 1
print(score)
``` | instruction | 0 | 51,202 | 19 | 102,404 |
Yes | output | 1 | 51,202 | 19 | 102,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2
Submitted Solution:
```
#D-atcoderくんと変なジャンケン
s=input()+"g"+"p"
import collections
S=dict(collections.Counter(s))
a=S["p"]-1
b=S["g"]-1
x=((a+b)//2)
print(x-a)
``` | instruction | 0 | 51,203 | 19 | 102,406 |
Yes | output | 1 | 51,203 | 19 | 102,407 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2
Submitted Solution:
```
#coding:utf-8
def win(p,e):
if p=="g" and e=="p":
return -1
elif p=="p" and e=="g":
return 1
else:
return 0
def f(memo,e_str,pt,gt,i):
if len(e_str)<=i:
return 0
if memo[pt][gt]!=-0xffff:
return memo[pt][gt]
else:
point_p=-0xffff
if pt+1<=gt:
point_p=f(memo,e_str,pt+1,gt,i+1)+win("p",e_str[i])
point_g=f(memo,e_str,pt,gt+1,i+1)+win("g",e_str[i])
memo[pt][gt]=max(point_p,point_g)
return memo[pt][gt]
if __name__ == "__main__":
e_str=list(input())
memo=[[-0xffff for i in range(len(e_str))] for j in range(len(e_str))]
print(f(memo,e_str,0,0,0))
``` | instruction | 0 | 51,204 | 19 | 102,408 |
No | output | 1 | 51,204 | 19 | 102,409 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2
Submitted Solution:
```
s = input()
print((s.count('p') - s.count('g')) // 2)
``` | instruction | 0 | 51,205 | 19 | 102,410 |
No | output | 1 | 51,205 | 19 | 102,411 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2
Submitted Solution:
```
s = input()
ans = 0
r = 0
p = 0
for j in s:
if j == 'g':
r += 1
if p > 1:
ans -= p//2
p = 0
else:
p += 1
if r > 1:
ans += r//2
r = 0
if p > 1:
ans -= p//2
if r > 1:
ans += r//2
print (ans)
``` | instruction | 0 | 51,206 | 19 | 102,412 |
No | output | 1 | 51,206 | 19 | 102,413 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
AtCoDeer the deer and his friend TopCoDeer is playing a game. The game consists of N turns. In each turn, each player plays one of the two gestures, Rock and Paper, as in Rock-paper-scissors, under the following condition:
(※) After each turn, (the number of times the player has played Paper)≦(the number of times the player has played Rock).
Each player's score is calculated by (the number of turns where the player wins) - (the number of turns where the player loses), where the outcome of each turn is determined by the rules of Rock-paper-scissors.
(For those who are not familiar with Rock-paper-scissors: If one player plays Rock and the other plays Paper, the latter player will win and the former player will lose. If both players play the same gesture, the round is a tie and neither player will win nor lose.)
With his supernatural power, AtCoDeer was able to foresee the gesture that TopCoDeer will play in each of the N turns, before the game starts. Plan AtCoDeer's gesture in each turn to maximize AtCoDeer's score.
The gesture that TopCoDeer will play in each turn is given by a string s. If the i-th (1≦i≦N) character in s is `g`, TopCoDeer will play Rock in the i-th turn. Similarly, if the i-th (1≦i≦N) character of s in `p`, TopCoDeer will play Paper in the i-th turn.
Constraints
* 1≦N≦10^5
* N=|s|
* Each character in s is `g` or `p`.
* The gestures represented by s satisfy the condition (※).
Input
The input is given from Standard Input in the following format:
s
Output
Print the AtCoDeer's maximum possible score.
Examples
Input
gpg
Output
0
Input
ggppgggpgg
Output
2
Submitted Solution:
```
s = input()
p_count = 0
g_count = 0
win = 0
for i in list(s):
if i == "g" and p_count <= g_count - 1:
p_count += 1
win += 1
elif i == "g":
g_count += 1
else:
p_count += 1
print(win)
``` | instruction | 0 | 51,207 | 19 | 102,414 |
No | output | 1 | 51,207 | 19 | 102,415 |
Provide a correct Python 3 solution for this coding contest problem.
A: Isono, let's do that! --Sendame -
story
Nakajima "Isono ~, let's do that!"
Isono "What is that, Nakajima"
Nakajima "Look, that's that. It's hard to explain because I have to express it in letters for some reason."
Isono "No, it seems that you can put in figures and photos, right?"
<image>
Nakajima "It's true!"
Isono "So what are you going to do?"
Nakajima "Look, the guy who rhythmically clapping his hands twice and then poses for defense, accumulation, and attack."
Isono "Hmm, I don't know ..."
Nakajima "After clapping hands twice, for example, if it was defense"
<image>
Nakajima "And if it was a reservoir"
<image>
Nakajima "If it was an attack"
<image>
Nakajima "Do you know who you are?"
Isono "Oh! It's dramatically easier to understand when a photo is included!"
Nakajima "This is the progress of civilization!"
(It's been a long time since then)
Hanazawa "Iso's" "I'm" "I'm"
Two people "(cracking ... crackling ... crackling ...)"
Hanazawa "You guys are doing that while sleeping ...!?"
Hanazawa: "You've won the game right now ... Isono-kun, have you won now?"
Isono "... Mr. Hanazawa was here ... Nakajima I'll do it again ... zzz"
Nakajima "(Kokuri)"
Two people "(cracking ... crackling ...)"
Hanazawa "Already ... I'll leave that winning / losing judgment robot here ..."
Then Mr. Hanazawa left.
Please write that winning / losing judgment program.
problem
"That" is a game played by two people. According to the rhythm, the two people repeat the pose of defense, accumulation, or attack at the same time. Here, the timing at which two people pose is referred to as "times". In this game, when there is a victory or defeat in a certain time and there is no victory or defeat in the previous times, the victory or defeat is the victory or defeat of the game.
Each of the two has a parameter called "attack power", and the attack power is 0 at the start of the game.
When the attack pose is taken, it becomes as follows according to the attack power at that time.
* If you pose for an attack when the attack power is 0, you will lose the foul. However, if the opponent also poses for an attack with an attack power of 0, he cannot win or lose at that time.
* If you pose for an attack when your attack power is 1 or more, you will attack your opponent. Also, if the opponent also poses for an attack at that time, the player with the higher attack power wins. However, if both players pose for an attack with the same attack power, they cannot win or lose at that time.
Also, at the end of the attack pose, your attack power becomes 0.
Taking a puddle pose increases the player's attack power by 1. However, if the attack power is 5, the attack power remains at 5 even if the player poses in the pool. If the opponent attacks in the time when you take the pose of the pool, the opponent wins. In addition, if the opponent takes a pose other than the attack in the time when the pose of the pool is taken, the victory or defeat cannot be determined.
If the opponent makes an attack with an attack power of 5 each time he takes a defensive pose, the opponent wins. On the other hand, if the opponent makes an attack with an attack power of 4 or less in the defense pose, or if the opponent poses for accumulation or defense, the victory or defeat cannot be achieved at that time. Even if you take a defensive pose, the attack power of that player does not change.
Since the poses of both players are given in order, output the victory or defeat. Both players may continue to pose after the victory or defeat is decided, but the pose after the victory or defeat is decided is ignored.
Input format
The input is given in the following format.
K
I_1_1
...
I_K
N_1_1
...
N_K
The first line of input is given an integer K (1 ≤ K ≤ 100). The pose I_i (1 ≤ i ≤ K) taken by Isono is given to the K lines from the second line in order. Immediately after that, the pose N_i (1 ≤ i ≤ K) taken by Nakajima is given to the K line in order. I_i and N_i are one of “mamoru”, “tameru”, and “kougekida”. These strings, in order, represent defense, pool, and attack poses.
Output format
Output “Isono-kun” if Isono wins, “Nakajima-kun” if Nakajima wins, and “Hikiwake-kun” if you cannot win or lose in K times.
Input example 1
3
tameru
tameru
tameru
tameru
kougekida
tameru
Output example 1
Nakajima-kun
In the second time, Isono is in the pose of the pool, while Nakajima is attacking with an attack power of 1, so Nakajima wins.
Input example 2
3
mamoru
mamoru
mamoru
tameru
tameru
tameru
Output example 2
Hikiwake-kun
Neither attacked, so I couldn't win or lose.
Input example 3
Five
tameru
tameru
mamoru
mamoru
kougekida
tameru
tameru
kougekida
tameru
kougekida
Output example 3
Isono-kun
There is no victory or defeat from the 1st to the 4th. In the 5th time, both players are posing for attack, but Isono's attack power is 2, while Nakajima's attack power is 1, so Isono wins.
Input example 4
3
kougekida
kougekida
tameru
kougekida
mamoru
kougekida
Output example 4
Nakajima-kun
In the first time, both players are posing for attack with 0 attack power, so there is no victory or defeat. In the second time, only Isono poses for an attack with an attack power of 0, so Nakajima wins.
Input example 5
8
tameru
mamoru
tameru
tameru
tameru
tameru
tameru
kougekida
tameru
kougekida
mamoru
mamoru
mamoru
mamoru
mamoru
mamoru
Output example 5
Isono-kun
In the second time, Nakajima poses for attack with an attack power of 1, but Isono poses for defense, so there is no victory or defeat. In the 7th time, Isono poses with an attack power of 5, so Isono's attack power remains at 5. In the 8th time, Isono poses for attack with an attack power of 5, and Nakajima poses for defense, so Isono wins.
Example
Input
3
tameru
tameru
tameru
tameru
kougekida
tameru
Output
Nakajima-kun | instruction | 0 | 51,272 | 19 | 102,544 |
"Correct Solution:
```
k = int(input())
isono = [input() for _ in range(k)]
nakajima = [input() for _ in range(k)]
isono_power = 0
nakajima_power = 0
for isono_hand, nakajima_hand in zip(isono, nakajima):
if isono_hand == "mamoru":
if nakajima_hand == "mamoru":pass
elif nakajima_hand == "tameru":nakajima_power = min(nakajima_power + 1, 5)
elif nakajima_hand == "kougekida":
if nakajima_power <= 0:print("Isono-kun");break
elif nakajima_power > 5 :print("Nakajima-kun");break
elif nakajima_power <= 4:nakajima_power = 0
elif isono_hand == "tameru":
isono_power = min(5, isono_power + 1)
if nakajima_hand == "mamoru":pass
elif nakajima_hand == "tameru":nakajima_power = min(nakajima_power + 1, 5)
elif nakajima_hand == "kougekida":
if nakajima_power <= 0:print("Isono-kun");break
else:print("Nakajima-kun");break
if isono_hand == "kougekida":
if nakajima_hand == "mamoru":
if isono_power <= 0:print("Nakajima-kun");break
elif isono_power >= 5:print("Isono-kun");break
else:isono_power = 0
elif nakajima_hand == "tameru":
if isono_power <= 0:print("Nakajima-kun");break
else:print("Isono-kun");break
elif nakajima_hand == "kougekida":
if isono_power == nakajima_power:isono_power = nakajima_power = 0
elif isono_power < nakajima_power:print("Nakajima-kun");break
elif isono_power > nakajima_power:print("Isono-kun");break
else:
print("Hikiwake-kun")
``` | output | 1 | 51,272 | 19 | 102,545 |
Provide a correct Python 3 solution for this coding contest problem.
A: Isono, let's do that! --Sendame -
story
Nakajima "Isono ~, let's do that!"
Isono "What is that, Nakajima"
Nakajima "Look, that's that. It's hard to explain because I have to express it in letters for some reason."
Isono "No, it seems that you can put in figures and photos, right?"
<image>
Nakajima "It's true!"
Isono "So what are you going to do?"
Nakajima "Look, the guy who rhythmically clapping his hands twice and then poses for defense, accumulation, and attack."
Isono "Hmm, I don't know ..."
Nakajima "After clapping hands twice, for example, if it was defense"
<image>
Nakajima "And if it was a reservoir"
<image>
Nakajima "If it was an attack"
<image>
Nakajima "Do you know who you are?"
Isono "Oh! It's dramatically easier to understand when a photo is included!"
Nakajima "This is the progress of civilization!"
(It's been a long time since then)
Hanazawa "Iso's" "I'm" "I'm"
Two people "(cracking ... crackling ... crackling ...)"
Hanazawa "You guys are doing that while sleeping ...!?"
Hanazawa: "You've won the game right now ... Isono-kun, have you won now?"
Isono "... Mr. Hanazawa was here ... Nakajima I'll do it again ... zzz"
Nakajima "(Kokuri)"
Two people "(cracking ... crackling ...)"
Hanazawa "Already ... I'll leave that winning / losing judgment robot here ..."
Then Mr. Hanazawa left.
Please write that winning / losing judgment program.
problem
"That" is a game played by two people. According to the rhythm, the two people repeat the pose of defense, accumulation, or attack at the same time. Here, the timing at which two people pose is referred to as "times". In this game, when there is a victory or defeat in a certain time and there is no victory or defeat in the previous times, the victory or defeat is the victory or defeat of the game.
Each of the two has a parameter called "attack power", and the attack power is 0 at the start of the game.
When the attack pose is taken, it becomes as follows according to the attack power at that time.
* If you pose for an attack when the attack power is 0, you will lose the foul. However, if the opponent also poses for an attack with an attack power of 0, he cannot win or lose at that time.
* If you pose for an attack when your attack power is 1 or more, you will attack your opponent. Also, if the opponent also poses for an attack at that time, the player with the higher attack power wins. However, if both players pose for an attack with the same attack power, they cannot win or lose at that time.
Also, at the end of the attack pose, your attack power becomes 0.
Taking a puddle pose increases the player's attack power by 1. However, if the attack power is 5, the attack power remains at 5 even if the player poses in the pool. If the opponent attacks in the time when you take the pose of the pool, the opponent wins. In addition, if the opponent takes a pose other than the attack in the time when the pose of the pool is taken, the victory or defeat cannot be determined.
If the opponent makes an attack with an attack power of 5 each time he takes a defensive pose, the opponent wins. On the other hand, if the opponent makes an attack with an attack power of 4 or less in the defense pose, or if the opponent poses for accumulation or defense, the victory or defeat cannot be achieved at that time. Even if you take a defensive pose, the attack power of that player does not change.
Since the poses of both players are given in order, output the victory or defeat. Both players may continue to pose after the victory or defeat is decided, but the pose after the victory or defeat is decided is ignored.
Input format
The input is given in the following format.
K
I_1_1
...
I_K
N_1_1
...
N_K
The first line of input is given an integer K (1 ≤ K ≤ 100). The pose I_i (1 ≤ i ≤ K) taken by Isono is given to the K lines from the second line in order. Immediately after that, the pose N_i (1 ≤ i ≤ K) taken by Nakajima is given to the K line in order. I_i and N_i are one of “mamoru”, “tameru”, and “kougekida”. These strings, in order, represent defense, pool, and attack poses.
Output format
Output “Isono-kun” if Isono wins, “Nakajima-kun” if Nakajima wins, and “Hikiwake-kun” if you cannot win or lose in K times.
Input example 1
3
tameru
tameru
tameru
tameru
kougekida
tameru
Output example 1
Nakajima-kun
In the second time, Isono is in the pose of the pool, while Nakajima is attacking with an attack power of 1, so Nakajima wins.
Input example 2
3
mamoru
mamoru
mamoru
tameru
tameru
tameru
Output example 2
Hikiwake-kun
Neither attacked, so I couldn't win or lose.
Input example 3
Five
tameru
tameru
mamoru
mamoru
kougekida
tameru
tameru
kougekida
tameru
kougekida
Output example 3
Isono-kun
There is no victory or defeat from the 1st to the 4th. In the 5th time, both players are posing for attack, but Isono's attack power is 2, while Nakajima's attack power is 1, so Isono wins.
Input example 4
3
kougekida
kougekida
tameru
kougekida
mamoru
kougekida
Output example 4
Nakajima-kun
In the first time, both players are posing for attack with 0 attack power, so there is no victory or defeat. In the second time, only Isono poses for an attack with an attack power of 0, so Nakajima wins.
Input example 5
8
tameru
mamoru
tameru
tameru
tameru
tameru
tameru
kougekida
tameru
kougekida
mamoru
mamoru
mamoru
mamoru
mamoru
mamoru
Output example 5
Isono-kun
In the second time, Nakajima poses for attack with an attack power of 1, but Isono poses for defense, so there is no victory or defeat. In the 7th time, Isono poses with an attack power of 5, so Isono's attack power remains at 5. In the 8th time, Isono poses for attack with an attack power of 5, and Nakajima poses for defense, so Isono wins.
Example
Input
3
tameru
tameru
tameru
tameru
kougekida
tameru
Output
Nakajima-kun | instruction | 0 | 51,273 | 19 | 102,546 |
"Correct Solution:
```
K = int(input())
Is = [input() for i in range(K)]
Ns = [input() for i in range(K)]
atk_I = 0
atk_N = 0
#"mamoru", "tameru", "kougekida"
#"Isono-kun", "Nakajima-kun", "Hikiwake-kun"
for i, n in zip(Is, Ns):
i_n = [i, n]
if (i_n.count("mamoru") == 2):
pass
elif (i_n.count("mamoru") == 1):
if (i_n.count("tameru") == 1):
exec("atk_{} += 1".format('I' if i[0] == "t" else 'N'))
if (atk_I > 5):
atk_I = 5
elif (atk_N > 5):
atk_N = 5
else:
if (i[0] == "k"):
if (atk_I == 5):
print("Isono-kun")
exit()
elif (atk_I == 0):
print("Nakajima-kun")
exit()
else:
atk_I = 0
elif (n[0] == "k"):
if (atk_N == 5):
print("Nakajima-kun")
exit()
elif (atk_N == 0):
print("Isono-kun")
exit()
else:
atk_N = 0
else:
if (i_n.count("kougekida") == 2):
if (atk_I > atk_N):
print("Isono-kun")
exit()
elif (atk_I == atk_N):
atk_I = 0
atk_N = 0
else:
print("Nakajima-kun")
exit()
elif (i_n.count("kougekida") == 1):
if (i[0] == "k"):
if (atk_I == 0):
print("Nakajima-kun")
exit()
else:
print("Isono-kun")
exit()
else:
if (atk_N == 0):
print("Isono-kun")
exit()
else:
print("Nakajima-kun")
exit()
else:
atk_I += 1 if atk_I != 5 else 0
atk_N += 1 if atk_N != 5 else 0
else:
print("Hikiwake-kun")
``` | output | 1 | 51,273 | 19 | 102,547 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Shikamaru and Asuma like to play different games, and sometimes they play the following: given an increasing list of numbers, they take turns to move. Each move consists of picking a number from the list.
Assume the picked numbers are v_{i_1}, v_{i_2}, …, v_{i_k}. The following conditions must hold:
* i_{j} < i_{j+1} for all 1 ≤ j ≤ k-1;
* v_{i_{j+1}} - v_{i_j} < v_{i_{j+2}} - v_{i_{j+1}} for all 1 ≤ j ≤ k-2.
However, it's easy to play only one instance of game, so today Shikamaru and Asuma decided to play n simultaneous games. They agreed on taking turns as for just one game, Shikamaru goes first. At each turn, the player performs a valid move in any single game. The player who cannot move loses. Find out who wins, provided that both play optimally.
Input
The first line contains the only integer n (1 ≤ n ≤ 1000) standing for the number of games Shikamaru and Asuma play at once. Next lines describe the games.
Each description starts from a line with the only number m (m≥ 1) denoting the length of the number list. The second line contains the increasing space-separated sequence v_1, v_2, ..., v_m from the game (1 ≤ v_{1} < v_{2} < ... < v_{m} ≤ 10^{5}).
The total length of all sequences doesn't exceed 10^5.
Output
Print "YES" if Shikamaru can secure the victory, and "NO" otherwise.
Examples
Input
1
10
1 2 3 4 5 6 7 8 9 10
Output
YES
Input
2
10
1 2 3 4 5 6 7 8 9 10
10
1 2 3 4 5 6 7 8 9 10
Output
NO
Input
4
7
14404 32906 41661 47694 51605 75933 80826
5
25374 42550 60164 62649 86273
2
7002 36731
8
23305 45601 46404 47346 47675 58125 74092 87225
Output
NO
Note
In the first example Shikamaru can pick the last number, and Asuma cannot do anything because of the first constraint.
In the second sample test Asuma can follow the symmetric strategy, repeating Shikamaru's moves in the other instance each time, and therefore win.
Submitted Solution:
```
n=int(input())
if(n%2==0):
print("NO")
else:
print("YES");
``` | instruction | 0 | 51,552 | 19 | 103,104 |
No | output | 1 | 51,552 | 19 | 103,105 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After you had helped George and Alex to move in the dorm, they went to help their friend Fedor play a new computer game «Call of Soldiers 3».
The game has (m + 1) players and n types of soldiers in total. Players «Call of Soldiers 3» are numbered form 1 to (m + 1). Types of soldiers are numbered from 0 to n - 1. Each player has an army. Army of the i-th player can be described by non-negative integer xi. Consider binary representation of xi: if the j-th bit of number xi equal to one, then the army of the i-th player has soldiers of the j-th type.
Fedor is the (m + 1)-th player of the game. He assume that two players can become friends if their armies differ in at most k types of soldiers (in other words, binary representations of the corresponding numbers differ in at most k bits). Help Fedor and count how many players can become his friends.
Input
The first line contains three integers n, m, k (1 ≤ k ≤ n ≤ 20; 1 ≤ m ≤ 1000).
The i-th of the next (m + 1) lines contains a single integer xi (1 ≤ xi ≤ 2n - 1), that describes the i-th player's army. We remind you that Fedor is the (m + 1)-th player.
Output
Print a single integer — the number of Fedor's potential friends.
Examples
Input
7 3 1
8
5
111
17
Output
0
Input
3 3 3
1
2
3
4
Output
3
Submitted Solution:
```
def DecToBin(num):
if num==0:
return '0'
if num==1:
return '1'
if num%2==0:
return DecToBin(num//2)+'0'
else:
return DecToBin(num//2)+'1'
n,m,k=list(map(int,input().split()))
B = []
for i in range(0,m+1):
temp = int(input())
stemp = DecToBin(temp)
if len(stemp) != n:
size = len(stemp)
for j in range(0,n-size):
stemp = "0" + stemp
B.append(stemp)
counter = 0
for i in range(m):
tcounter = 0
for j in range(n):
if (B[m][j] != B[i][j]):
tcounter += 1
if (tcounter <= k):
counter += 1
print(counter)
``` | instruction | 0 | 51,700 | 19 | 103,400 |
Yes | output | 1 | 51,700 | 19 | 103,401 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
After you had helped George and Alex to move in the dorm, they went to help their friend Fedor play a new computer game «Call of Soldiers 3».
The game has (m + 1) players and n types of soldiers in total. Players «Call of Soldiers 3» are numbered form 1 to (m + 1). Types of soldiers are numbered from 0 to n - 1. Each player has an army. Army of the i-th player can be described by non-negative integer xi. Consider binary representation of xi: if the j-th bit of number xi equal to one, then the army of the i-th player has soldiers of the j-th type.
Fedor is the (m + 1)-th player of the game. He assume that two players can become friends if their armies differ in at most k types of soldiers (in other words, binary representations of the corresponding numbers differ in at most k bits). Help Fedor and count how many players can become his friends.
Input
The first line contains three integers n, m, k (1 ≤ k ≤ n ≤ 20; 1 ≤ m ≤ 1000).
The i-th of the next (m + 1) lines contains a single integer xi (1 ≤ xi ≤ 2n - 1), that describes the i-th player's army. We remind you that Fedor is the (m + 1)-th player.
Output
Print a single integer — the number of Fedor's potential friends.
Examples
Input
7 3 1
8
5
111
17
Output
0
Input
3 3 3
1
2
3
4
Output
3
Submitted Solution:
```
def count_set_bits(n):
count = 0
while (n):
count += n & 1
n >>= 1
return count
n,m,k = [int(i) for i in input().split()]
p = []
res = 0
for i in range(m+1):
p.append(int(input()))
for i in range(m):
n = p[i] ^ p[m]
if count_set_bits(n) <= k:
res += 1
print(res)
``` | instruction | 0 | 51,701 | 19 | 103,402 |
Yes | output | 1 | 51,701 | 19 | 103,403 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.