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.
A MIPT student named Misha has a birthday today, and he decided to celebrate it in his country house in suburban Moscow. n friends came by, and after a typical party they decided to play blind man's buff.
The birthday boy gets blindfolded and the other players scatter around the house. The game is played in several rounds. In each round, Misha catches exactly one of his friends and has to guess who it is. The probability of catching the i-th friend does not change between rounds and is equal to pi percent (as we know, it is directly proportional to the amount of alcohol consumed by the i-th friend) and p1 + p2 + ... + pn = 100 holds. Misha has no information about who he caught. After Misha makes an attempt to guess the caught person, the round ends. Even then, Misha isn't told whether he guessed correctly, and a new round begins.
The game ends when Misha guesses every friend at least once, that is, there exists such set of rounds k1, k2, ..., kn, that during round number ki Misha caught the i-th friend and guessed him. Misha wants to minimize the expectation of the number of rounds of the game. Despite the fact that at any point in the game Misha has no information about who he has already guessed, his friends are honest, and if they see that the condition for the end of the game is fulfilled, the game ends immediately. Find the expectation of the number of rounds in the game if Misha plays optimally.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the number of Misha's friends.
The second line contains n integers pi (<image>), giving the probability to catch the i-th friend in one particular round in percent.
Output
Print a single real value — the expectation of the number of rounds provided that Misha plays optimally. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2
50 50
Output
5.0000000000
Input
4
50 20 20 10
Output
39.2846263444
Note
The optimal strategy in the first sample is to guess friends alternately.
Submitted Solution:
```
import random
N = int(input())
prob = [float(x)/100 for x in input().strip().split()]
prob_sum = []
cur = 0
for i in range(N):
cur += prob[i]
prob_sum.append(cur)
def experiment():
cur_prob = [1.] * N
cur_exp = 0
for i in range(10000):
bp = [prob[i] * cur_prob[i] / (1-cur_prob[i]+1E-100) for i in range(N)]
mn = max(bp)
for j in range(N):
if bp[j] == mn:
choice = j
cur_prob[choice] *= 1-prob[choice]
tp = 1
for j in range(N):
tp *= (1-cur_prob[j])
tp = 1 - tp
cur_exp += tp
return cur_exp + 1
ans = experiment()
print(ans)
``` | instruction | 0 | 30,510 | 19 | 61,020 |
No | output | 1 | 30,510 | 19 | 61,021 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A MIPT student named Misha has a birthday today, and he decided to celebrate it in his country house in suburban Moscow. n friends came by, and after a typical party they decided to play blind man's buff.
The birthday boy gets blindfolded and the other players scatter around the house. The game is played in several rounds. In each round, Misha catches exactly one of his friends and has to guess who it is. The probability of catching the i-th friend does not change between rounds and is equal to pi percent (as we know, it is directly proportional to the amount of alcohol consumed by the i-th friend) and p1 + p2 + ... + pn = 100 holds. Misha has no information about who he caught. After Misha makes an attempt to guess the caught person, the round ends. Even then, Misha isn't told whether he guessed correctly, and a new round begins.
The game ends when Misha guesses every friend at least once, that is, there exists such set of rounds k1, k2, ..., kn, that during round number ki Misha caught the i-th friend and guessed him. Misha wants to minimize the expectation of the number of rounds of the game. Despite the fact that at any point in the game Misha has no information about who he has already guessed, his friends are honest, and if they see that the condition for the end of the game is fulfilled, the game ends immediately. Find the expectation of the number of rounds in the game if Misha plays optimally.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the number of Misha's friends.
The second line contains n integers pi (<image>), giving the probability to catch the i-th friend in one particular round in percent.
Output
Print a single real value — the expectation of the number of rounds provided that Misha plays optimally. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2
50 50
Output
5.0000000000
Input
4
50 20 20 10
Output
39.2846263444
Note
The optimal strategy in the first sample is to guess friends alternately.
Submitted Solution:
```
import random
N = int(input())
prob = [float(x)/100 for x in input().strip().split()]
prob_sum = []
cur = 0
for i in range(N):
cur += prob[i]
prob_sum.append(cur)
def experiment():
cur_prob = [1.] * N
cur_exp = 0
for i in range(100000):
bp = [prob[i] * cur_prob[i] / (1-cur_prob[i]+1E-100) for i in range(N)]
mn = max(bp)
for j in range(N):
if bp[j] == mn:
choice = j
cur_prob[choice] *= 1-prob[choice]
tp = 1
for j in range(N):
tp *= (1-cur_prob[j])
tp = 1 - tp
cur_exp += tp
return cur_exp + 1
ans = experiment()
print(ans)
``` | instruction | 0 | 30,511 | 19 | 61,022 |
No | output | 1 | 30,511 | 19 | 61,023 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A MIPT student named Misha has a birthday today, and he decided to celebrate it in his country house in suburban Moscow. n friends came by, and after a typical party they decided to play blind man's buff.
The birthday boy gets blindfolded and the other players scatter around the house. The game is played in several rounds. In each round, Misha catches exactly one of his friends and has to guess who it is. The probability of catching the i-th friend does not change between rounds and is equal to pi percent (as we know, it is directly proportional to the amount of alcohol consumed by the i-th friend) and p1 + p2 + ... + pn = 100 holds. Misha has no information about who he caught. After Misha makes an attempt to guess the caught person, the round ends. Even then, Misha isn't told whether he guessed correctly, and a new round begins.
The game ends when Misha guesses every friend at least once, that is, there exists such set of rounds k1, k2, ..., kn, that during round number ki Misha caught the i-th friend and guessed him. Misha wants to minimize the expectation of the number of rounds of the game. Despite the fact that at any point in the game Misha has no information about who he has already guessed, his friends are honest, and if they see that the condition for the end of the game is fulfilled, the game ends immediately. Find the expectation of the number of rounds in the game if Misha plays optimally.
Input
The first line of the input contains a single integer n (1 ≤ n ≤ 100) — the number of Misha's friends.
The second line contains n integers pi (<image>), giving the probability to catch the i-th friend in one particular round in percent.
Output
Print a single real value — the expectation of the number of rounds provided that Misha plays optimally. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6.
Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.
Examples
Input
2
50 50
Output
5.0000000000
Input
4
50 20 20 10
Output
39.2846263444
Note
The optimal strategy in the first sample is to guess friends alternately.
Submitted Solution:
```
n = int(input())
tt = n
p = list(map(lambda x: int(x)/100, input().split(' ')))
k = [1 for i in range(n)]
def prod():
t=1
for i in range(len(p)):
t*=(1-(1-p[i])**k[i])
return t
ex = n
for i in p:
ex*=i
last = 1
while last*n > 1e-30:
print(ex)
mi = -1
mv = 0
for j in range(tt):
tmp = (1-p[j])**k[j]*p[j]/(1-(1-p[j])**k[j])
if tmp>mv:
mv = tmp
mi = j
last = prod()*mv
k[mi] += 1
n += 1
ex += n*last
print(ex)
``` | instruction | 0 | 30,512 | 19 | 61,024 |
No | output | 1 | 30,512 | 19 | 61,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Rick and Morty are playing their own version of Berzerk (which has nothing in common with the famous Berzerk game). This game needs a huge space, so they play it with a computer.
In this game there are n objects numbered from 1 to n arranged in a circle (in clockwise order). Object number 1 is a black hole and the others are planets. There's a monster in one of the planet. Rick and Morty don't know on which one yet, only that he's not initially in the black hole, but Unity will inform them before the game starts. But for now, they want to be prepared for every possible scenario.
<image>
Each one of them has a set of numbers between 1 and n - 1 (inclusive). Rick's set is s1 with k1 elements and Morty's is s2 with k2 elements. One of them goes first and the player changes alternatively. In each player's turn, he should choose an arbitrary number like x from his set and the monster will move to his x-th next object from its current position (clockwise). If after his move the monster gets to the black hole he wins.
Your task is that for each of monster's initial positions and who plays first determine if the starter wins, loses, or the game will stuck in an infinite loop. In case when player can lose or make game infinity, it more profitable to choose infinity game.
Input
The first line of input contains a single integer n (2 ≤ n ≤ 7000) — number of objects in game.
The second line contains integer k1 followed by k1 distinct integers s1, 1, s1, 2, ..., s1, k1 — Rick's set.
The third line contains integer k2 followed by k2 distinct integers s2, 1, s2, 2, ..., s2, k2 — Morty's set
1 ≤ ki ≤ n - 1 and 1 ≤ si, 1, si, 2, ..., si, ki ≤ n - 1 for 1 ≤ i ≤ 2.
Output
In the first line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Rick plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Similarly, in the second line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Morty plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Examples
Input
5
2 3 2
3 1 2 3
Output
Lose Win Win Loop
Loop Win Win Win
Input
8
4 6 2 3 4
2 3 6
Output
Win Win Win Win Win Win Win
Lose Win Lose Lose Win Lose Lose | instruction | 0 | 30,591 | 19 | 61,182 |
Tags: dfs and similar, dp, games
Correct Solution:
```
f = lambda: list(map(int, input().split()))[1:]
n = int(input())
s, p, q = [], [], []
for x in [0, 1]:
r = f()
s.append(r)
t = [len(r)] * n
t[0] = 0
p.append(t)
q.append((x, 0))
while q:
x, i = q.pop()
y = 1 - x
for d in s[y]:
j = (i - d) % n
if p[y][j] < 1: continue
p[y][j] = -1
for d in s[x]:
k = (j - d) % n
if p[x][k] < 1: continue
p[x][k] -= 1
if p[x][k] == 0: q.append((x, k))
for x in [0, 1]:
print(*[['Lose', 'Loop', 'Win'][min(q, 1)] for q in p[x][1:]])
``` | output | 1 | 30,591 | 19 | 61,183 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Rick and Morty are playing their own version of Berzerk (which has nothing in common with the famous Berzerk game). This game needs a huge space, so they play it with a computer.
In this game there are n objects numbered from 1 to n arranged in a circle (in clockwise order). Object number 1 is a black hole and the others are planets. There's a monster in one of the planet. Rick and Morty don't know on which one yet, only that he's not initially in the black hole, but Unity will inform them before the game starts. But for now, they want to be prepared for every possible scenario.
<image>
Each one of them has a set of numbers between 1 and n - 1 (inclusive). Rick's set is s1 with k1 elements and Morty's is s2 with k2 elements. One of them goes first and the player changes alternatively. In each player's turn, he should choose an arbitrary number like x from his set and the monster will move to his x-th next object from its current position (clockwise). If after his move the monster gets to the black hole he wins.
Your task is that for each of monster's initial positions and who plays first determine if the starter wins, loses, or the game will stuck in an infinite loop. In case when player can lose or make game infinity, it more profitable to choose infinity game.
Input
The first line of input contains a single integer n (2 ≤ n ≤ 7000) — number of objects in game.
The second line contains integer k1 followed by k1 distinct integers s1, 1, s1, 2, ..., s1, k1 — Rick's set.
The third line contains integer k2 followed by k2 distinct integers s2, 1, s2, 2, ..., s2, k2 — Morty's set
1 ≤ ki ≤ n - 1 and 1 ≤ si, 1, si, 2, ..., si, ki ≤ n - 1 for 1 ≤ i ≤ 2.
Output
In the first line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Rick plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Similarly, in the second line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Morty plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Examples
Input
5
2 3 2
3 1 2 3
Output
Lose Win Win Loop
Loop Win Win Win
Input
8
4 6 2 3 4
2 3 6
Output
Win Win Win Win Win Win Win
Lose Win Lose Lose Win Lose Lose | instruction | 0 | 30,592 | 19 | 61,184 |
Tags: dfs and similar, dp, games
Correct Solution:
```
class T:
h = ('Lose', 'Loop', 'Win')
def __init__(t):
t.s = list(map(int, input().split()))[1:]
t.p = [len(t.s)] * n
t.p[0] = 0
def f(t, i):
for d in t.s:
j = (i - d) % n
if t.p[j] > 0: yield j
def g(t):
print(*[t.h[min(q, 1)] for q in t.p[1:]])
n = int(input())
r, m = T(), T()
q = [(r, m, 0), (m, r, 0)]
while q:
x, y, i = q.pop()
for j in y.f(i):
y.p[j] = -1
for k in x.f(j):
x.p[k] -= 1
if not x.p[k]: q.append((x, y, k))
r.g()
m.g()
``` | output | 1 | 30,592 | 19 | 61,185 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Rick and Morty are playing their own version of Berzerk (which has nothing in common with the famous Berzerk game). This game needs a huge space, so they play it with a computer.
In this game there are n objects numbered from 1 to n arranged in a circle (in clockwise order). Object number 1 is a black hole and the others are planets. There's a monster in one of the planet. Rick and Morty don't know on which one yet, only that he's not initially in the black hole, but Unity will inform them before the game starts. But for now, they want to be prepared for every possible scenario.
<image>
Each one of them has a set of numbers between 1 and n - 1 (inclusive). Rick's set is s1 with k1 elements and Morty's is s2 with k2 elements. One of them goes first and the player changes alternatively. In each player's turn, he should choose an arbitrary number like x from his set and the monster will move to his x-th next object from its current position (clockwise). If after his move the monster gets to the black hole he wins.
Your task is that for each of monster's initial positions and who plays first determine if the starter wins, loses, or the game will stuck in an infinite loop. In case when player can lose or make game infinity, it more profitable to choose infinity game.
Input
The first line of input contains a single integer n (2 ≤ n ≤ 7000) — number of objects in game.
The second line contains integer k1 followed by k1 distinct integers s1, 1, s1, 2, ..., s1, k1 — Rick's set.
The third line contains integer k2 followed by k2 distinct integers s2, 1, s2, 2, ..., s2, k2 — Morty's set
1 ≤ ki ≤ n - 1 and 1 ≤ si, 1, si, 2, ..., si, ki ≤ n - 1 for 1 ≤ i ≤ 2.
Output
In the first line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Rick plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Similarly, in the second line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Morty plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Examples
Input
5
2 3 2
3 1 2 3
Output
Lose Win Win Loop
Loop Win Win Win
Input
8
4 6 2 3 4
2 3 6
Output
Win Win Win Win Win Win Win
Lose Win Lose Lose Win Lose Lose | instruction | 0 | 30,593 | 19 | 61,186 |
Tags: dfs and similar, dp, games
Correct Solution:
```
#!/usr/bin/env python3
from sys import stdin,stdout
def ri():
return map(int, input().split())
n = int(input())
a = list(ri())
b = list(ri())
a = a[1:]
b = b[1:]
T = [[-1 for i in range(2)] for j in range(n)]
T[0][0] = 1
T[0][1] = 0
for j in range(10**9):
c = 0
for i in range(n-1, -1, -1):
#T[i][0]
flag = 0
for k in a:
ii = (i+k)%n
if ii == 0 or T[ii][1] == 0:
if T[i][0] !=0:
c = 1
T[i][0] = 0
break
if T[ii][1] != 1:
flag = 1
else:
if flag == 0:
if T[i][0] !=1:
c = 1
T[i][0] = 1
flag = 0
for k in b:
ii = (i+k)%n
if ii == 0 or T[ii][0] == 1:
if T[i][1] !=1:
c = 1
T[i][1] = 1
break
if T[ii][0] != 0:
flag = 1
else:
if flag == 0:
if T[i][1] !=0:
c = 1
T[i][1] = 0
if c == 0:
break
ansa = ["Win", "Lose", "Loop"]
ansb = ["Lose", "Win", "Loop"]
aa = [ansa[T[i][0]] for i in range(1, n)]
bb = [ansb[T[i][1]] for i in range(1, n)]
print(" ".join(aa))
print(" ".join(bb))
``` | output | 1 | 30,593 | 19 | 61,187 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Rick and Morty are playing their own version of Berzerk (which has nothing in common with the famous Berzerk game). This game needs a huge space, so they play it with a computer.
In this game there are n objects numbered from 1 to n arranged in a circle (in clockwise order). Object number 1 is a black hole and the others are planets. There's a monster in one of the planet. Rick and Morty don't know on which one yet, only that he's not initially in the black hole, but Unity will inform them before the game starts. But for now, they want to be prepared for every possible scenario.
<image>
Each one of them has a set of numbers between 1 and n - 1 (inclusive). Rick's set is s1 with k1 elements and Morty's is s2 with k2 elements. One of them goes first and the player changes alternatively. In each player's turn, he should choose an arbitrary number like x from his set and the monster will move to his x-th next object from its current position (clockwise). If after his move the monster gets to the black hole he wins.
Your task is that for each of monster's initial positions and who plays first determine if the starter wins, loses, or the game will stuck in an infinite loop. In case when player can lose or make game infinity, it more profitable to choose infinity game.
Input
The first line of input contains a single integer n (2 ≤ n ≤ 7000) — number of objects in game.
The second line contains integer k1 followed by k1 distinct integers s1, 1, s1, 2, ..., s1, k1 — Rick's set.
The third line contains integer k2 followed by k2 distinct integers s2, 1, s2, 2, ..., s2, k2 — Morty's set
1 ≤ ki ≤ n - 1 and 1 ≤ si, 1, si, 2, ..., si, ki ≤ n - 1 for 1 ≤ i ≤ 2.
Output
In the first line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Rick plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Similarly, in the second line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Morty plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Examples
Input
5
2 3 2
3 1 2 3
Output
Lose Win Win Loop
Loop Win Win Win
Input
8
4 6 2 3 4
2 3 6
Output
Win Win Win Win Win Win Win
Lose Win Lose Lose Win Lose Lose | instruction | 0 | 30,594 | 19 | 61,188 |
Tags: dfs and similar, dp, games
Correct Solution:
```
import queue
n = int(input())
sR = list(map(int, input().split()[1:]))
sM = list(map(int, input().split()[1:]))
s = [sR, sM]
UNK = -1
WIN = 2
LOSE = 3
A = [[UNK] * n for i in range(2)]
CNT = [[0] * n for i in range(2)]
V = [[False] * n for i in range(2)]
# ricky turn 0
# morty turn 1
A[0][0] = LOSE
A[1][0] = LOSE
Q = queue.Queue()
Q.put((0, 0))
Q.put((1, 0))
while not Q.empty():
turn, planet = Q.get()
prev_turn = 1 - turn
for diff in s[prev_turn]:
prev_planet = (n + planet - diff) % n
if prev_planet == 0:
continue
if A[turn][planet] == LOSE:
A[prev_turn][prev_planet] = WIN
elif A[turn][planet] == WIN:
CNT[prev_turn][prev_planet] += 1
if CNT[prev_turn][prev_planet] == len(s[prev_turn]):
A[prev_turn][prev_planet] = LOSE
if A[prev_turn][prev_planet] != UNK and not V[prev_turn][prev_planet]:
Q.put((prev_turn, prev_planet))
V[prev_turn][prev_planet] = True
print(' '.join(["Win" if A[0][i] == WIN else "Lose" if A[0][i] == LOSE else "Loop" for i in range(1, n)]))
print(' '.join(["Win" if A[1][i] == WIN else "Lose" if A[1][i] == LOSE else "Loop" for i in range(1, n)]))
``` | output | 1 | 30,594 | 19 | 61,189 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Rick and Morty are playing their own version of Berzerk (which has nothing in common with the famous Berzerk game). This game needs a huge space, so they play it with a computer.
In this game there are n objects numbered from 1 to n arranged in a circle (in clockwise order). Object number 1 is a black hole and the others are planets. There's a monster in one of the planet. Rick and Morty don't know on which one yet, only that he's not initially in the black hole, but Unity will inform them before the game starts. But for now, they want to be prepared for every possible scenario.
<image>
Each one of them has a set of numbers between 1 and n - 1 (inclusive). Rick's set is s1 with k1 elements and Morty's is s2 with k2 elements. One of them goes first and the player changes alternatively. In each player's turn, he should choose an arbitrary number like x from his set and the monster will move to his x-th next object from its current position (clockwise). If after his move the monster gets to the black hole he wins.
Your task is that for each of monster's initial positions and who plays first determine if the starter wins, loses, or the game will stuck in an infinite loop. In case when player can lose or make game infinity, it more profitable to choose infinity game.
Input
The first line of input contains a single integer n (2 ≤ n ≤ 7000) — number of objects in game.
The second line contains integer k1 followed by k1 distinct integers s1, 1, s1, 2, ..., s1, k1 — Rick's set.
The third line contains integer k2 followed by k2 distinct integers s2, 1, s2, 2, ..., s2, k2 — Morty's set
1 ≤ ki ≤ n - 1 and 1 ≤ si, 1, si, 2, ..., si, ki ≤ n - 1 for 1 ≤ i ≤ 2.
Output
In the first line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Rick plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Similarly, in the second line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Morty plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Examples
Input
5
2 3 2
3 1 2 3
Output
Lose Win Win Loop
Loop Win Win Win
Input
8
4 6 2 3 4
2 3 6
Output
Win Win Win Win Win Win Win
Lose Win Lose Lose Win Lose Lose | instruction | 0 | 30,595 | 19 | 61,190 |
Tags: dfs and similar, dp, games
Correct Solution:
```
import sys
#range = xrange
#input = raw_input
n = int(input())
k1,*A = [int(x) for x in input().split()]
k2,*B = [int(x) for x in input().split()]
DPA = [None]*n
DPA[0] = False
counterA = [k1]*n
counterA[0] = -1
DPB = [None]*n
DPB[0] = False
counterB = [k2]*n
counterB[0] = -1
QA = [0]
QB = [0]
while QA or QB:
while QA:
i = QA.pop()
if DPA[i] == False:
for b in B:
if i!=b:
if not DPB[i-b]:
QB.append((i-b)%n)
DPB[i-b] = True
elif DPA[i]:
for b in B:
counterB[i-b] -= 1
if not counterB[i-b]:
#assert(DPB[i-b]==None)
DPB[i-b] = False
QB.append((i-b)%n)
while QB:
i = QB.pop()
if DPB[i] == False:
for a in A:
if i!=a:
if not DPA[i-a]:
QA.append((i-a)%n)
DPA[i-a] = True
elif DPB[i]:
for a in A:
counterA[i-a] -= 1
if not counterA[i-a]:
#assert(DPA[i-a]==None)
DPA[i-a] = False
QA.append((i-a)%n)
def f(x):
if x==None:
return 'Loop'
if x:
return 'Win'
return 'Lose'
print(*[f(x) for x in DPA[1:]])
print(*[f(x) for x in DPB[1:]])
``` | output | 1 | 30,595 | 19 | 61,191 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Rick and Morty are playing their own version of Berzerk (which has nothing in common with the famous Berzerk game). This game needs a huge space, so they play it with a computer.
In this game there are n objects numbered from 1 to n arranged in a circle (in clockwise order). Object number 1 is a black hole and the others are planets. There's a monster in one of the planet. Rick and Morty don't know on which one yet, only that he's not initially in the black hole, but Unity will inform them before the game starts. But for now, they want to be prepared for every possible scenario.
<image>
Each one of them has a set of numbers between 1 and n - 1 (inclusive). Rick's set is s1 with k1 elements and Morty's is s2 with k2 elements. One of them goes first and the player changes alternatively. In each player's turn, he should choose an arbitrary number like x from his set and the monster will move to his x-th next object from its current position (clockwise). If after his move the monster gets to the black hole he wins.
Your task is that for each of monster's initial positions and who plays first determine if the starter wins, loses, or the game will stuck in an infinite loop. In case when player can lose or make game infinity, it more profitable to choose infinity game.
Input
The first line of input contains a single integer n (2 ≤ n ≤ 7000) — number of objects in game.
The second line contains integer k1 followed by k1 distinct integers s1, 1, s1, 2, ..., s1, k1 — Rick's set.
The third line contains integer k2 followed by k2 distinct integers s2, 1, s2, 2, ..., s2, k2 — Morty's set
1 ≤ ki ≤ n - 1 and 1 ≤ si, 1, si, 2, ..., si, ki ≤ n - 1 for 1 ≤ i ≤ 2.
Output
In the first line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Rick plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Similarly, in the second line print n - 1 words separated by spaces where i-th word is "Win" (without quotations) if in the scenario that Morty plays first and monster is initially in object number i + 1 he wins, "Lose" if he loses and "Loop" if the game will never end.
Examples
Input
5
2 3 2
3 1 2 3
Output
Lose Win Win Loop
Loop Win Win Win
Input
8
4 6 2 3 4
2 3 6
Output
Win Win Win Win Win Win Win
Lose Win Lose Lose Win Lose Lose | instruction | 0 | 30,596 | 19 | 61,192 |
Tags: dfs and similar, dp, games
Correct Solution:
```
RESULT = ['Lose', 'Loop', 'Win']
class Player(object):
"""docstring for Player"""
def __init__(self):
super(Player, self).__init__()
self.a = list(map(int, input().split()))[1:]
self.f = [len(self.a)] * n
self.f[0] = 0
def prev(self, i):
for x in self.a:
if self.f[(i - x) % n] > 0:
yield (i - x) % n
def print_result(self):
print(*[RESULT[min(x, 1)] for x in self.f[1:]])
n = int(input())
a, b = Player(), Player()
q = [(a, b, 0), (b, a, 0)]
while q:
x, y, i = q.pop()
for j in y.prev(i):
y.f[j] = -1
for k in x.prev(j):
x.f[k] -= 1
if x.f[k] == 0:
q.append((x, y, k))
a.print_result()
b.print_result()
``` | output | 1 | 30,596 | 19 | 61,193 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win. | instruction | 0 | 30,601 | 19 | 61,202 |
Tags: games, math
Correct Solution:
```
n, k = map(int, input().split(' '))
t = n // k
if t & 1:
print("YES")
else:
print("NO")
``` | output | 1 | 30,601 | 19 | 61,203 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win. | instruction | 0 | 30,602 | 19 | 61,204 |
Tags: games, math
Correct Solution:
```
n,k=map(int,input().split())
if ((n//k)%2==0):
print("NO")
else:
print("YES")
``` | output | 1 | 30,602 | 19 | 61,205 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win. | instruction | 0 | 30,603 | 19 | 61,206 |
Tags: games, math
Correct Solution:
```
inp = input().split(" ")
turns = int(inp[0]) // int(inp[1])
if turns % 2 == 1:
print("YES")
else:
print("NO")
``` | output | 1 | 30,603 | 19 | 61,207 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win. | instruction | 0 | 30,604 | 19 | 61,208 |
Tags: games, math
Correct Solution:
```
a,b=map(int,input().split())
if a//b%2==1:
print('YES')
else:
print('NO')
``` | output | 1 | 30,604 | 19 | 61,209 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win. | instruction | 0 | 30,605 | 19 | 61,210 |
Tags: games, math
Correct Solution:
```
n,k=map(int,input().split(" "))
if(k>n):
print('NO')
elif(k==n):
print('YES')
else:
if((n//k)%2==0):
print('NO')
else:
print('YES')
``` | output | 1 | 30,605 | 19 | 61,211 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win. | instruction | 0 | 30,606 | 19 | 61,212 |
Tags: games, math
Correct Solution:
```
x, y= map(int, input().split())
z = x // y % 2
if z == 1:
print("YES")
else:
print("NO")
``` | output | 1 | 30,606 | 19 | 61,213 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win. | instruction | 0 | 30,607 | 19 | 61,214 |
Tags: games, math
Correct Solution:
```
n,k=[int(x)for x in input().split()]
a = n//k
if a%2==0:
print("no")
elif a%2!=0:
print("yes")
``` | output | 1 | 30,607 | 19 | 61,215 |
Provide tags and a correct Python 3 solution for this coding contest problem.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win. | instruction | 0 | 30,608 | 19 | 61,216 |
Tags: games, math
Correct Solution:
```
n, k = map(int, input().split())
r = n//k
if (r%2 == 1):
print('YES')
else:
print('NO')
``` | output | 1 | 30,608 | 19 | 61,217 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win.
Submitted Solution:
```
# Description of the problem can be found at http://codeforces.com/problemset/problem/832/A
import math
n, k = map(int, input().split())
if (n // k) & 1 == 1:
print("YES")
else:
print("NO")
``` | instruction | 0 | 30,609 | 19 | 61,218 |
Yes | output | 1 | 30,609 | 19 | 61,219 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win.
Submitted Solution:
```
n, m = map(int, input().split())
if (n // m) % 2 == 0:
print('NO')
else:
print('YES')
``` | instruction | 0 | 30,610 | 19 | 61,220 |
Yes | output | 1 | 30,610 | 19 | 61,221 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win.
Submitted Solution:
```
n,m=map(int,input().strip().split(' '))
k=n//m
if(k%2==1):
print("YES")
else:
print("NO")
``` | instruction | 0 | 30,611 | 19 | 61,222 |
Yes | output | 1 | 30,611 | 19 | 61,223 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win.
Submitted Solution:
```
n,k=map(int,input().split())
w=n//k
if w&1==0:
print("NO")
else:
print("YES")
``` | instruction | 0 | 30,612 | 19 | 61,224 |
Yes | output | 1 | 30,612 | 19 | 61,225 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win.
Submitted Solution:
```
n,k=map(float,input().split())
x=n/2
y=x%k
if (2*y)<k and n>k:
print("no")
elif (2*y)>=k and n>k or n==k:
print("yes")
elif n%2!=0 and k==1:
print("yes")
``` | instruction | 0 | 30,613 | 19 | 61,226 |
No | output | 1 | 30,613 | 19 | 61,227 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win.
Submitted Solution:
```
n,k=[int(i) for i in input().split()]
x=n/k
if x/2==0:
print('NO')
else :
print('YES')
``` | instruction | 0 | 30,614 | 19 | 61,228 |
No | output | 1 | 30,614 | 19 | 61,229 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win.
Submitted Solution:
```
a,b=input().strip().split(" ")
a,b=[int(a),int(b)]
count=0
count1=0
while(a>=b):
count=count+1
a=a-b
if a>b:
count1=count1+1
a=a-b
if count>count1:
print("YES")
else:
print("N0")
``` | instruction | 0 | 30,615 | 19 | 61,230 |
No | output | 1 | 30,615 | 19 | 61,231 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
It's one more school day now. Sasha doesn't like classes and is always bored at them. So, each day he invents some game and plays in it alone or with friends.
Today he invented one simple game to play with Lena, with whom he shares a desk. The rules are simple. Sasha draws n sticks in a row. After that the players take turns crossing out exactly k sticks from left or right in each turn. Sasha moves first, because he is the inventor of the game. If there are less than k sticks on the paper before some turn, the game ends. Sasha wins if he makes strictly more moves than Lena. Sasha wants to know the result of the game before playing, you are to help him.
Input
The first line contains two integers n and k (1 ≤ n, k ≤ 1018, k ≤ n) — the number of sticks drawn by Sasha and the number k — the number of sticks to be crossed out on each turn.
Output
If Sasha wins, print "YES" (without quotes), otherwise print "NO" (without quotes).
You can print each letter in arbitrary case (upper of lower).
Examples
Input
1 1
Output
YES
Input
10 4
Output
NO
Note
In the first example Sasha crosses out 1 stick, and then there are no sticks. So Lena can't make a move, and Sasha wins.
In the second example Sasha crosses out 4 sticks, then Lena crosses out 4 sticks, and after that there are only 2 sticks left. Sasha can't make a move. The players make equal number of moves, so Sasha doesn't win.
Submitted Solution:
```
n,k = [int(x) for x in input().split()]
while n>=k:
if n-k<k:
print("YES")
else:
print("NO")
break
``` | instruction | 0 | 30,616 | 19 | 61,232 |
No | output | 1 | 30,616 | 19 | 61,233 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
There used to be a game called Joseph's potatoes. Let's say n people are participating. Participants form a circle facing the center and are numbered starting from 1. One hot potato is given to participant n (the large number 30 inside the figure on the left). Participants who are given the potatoes will give the potatoes to the participant on the right. The person passed the mth time is passed to the person on the right and exits the circle (the figure on the left shows the case of m = 9). Each time you hand it over, you will pass one by one, and the last remaining person will be the winner and you will receive potatoes.
After n and m are decided, it would be nice to know where you can win before you actually start handing the potatoes. The figure above shows the case of playing this game with the rule that 30 participants exit every 9 people. The large numbers on the inside are the numbers assigned to the participants, and the small numbers on the outside are the numbers that are removed. According to it, it will break out of the circle in the order of 9,18,27,6,16,26, and 21 will remain at the end. That is, 21 is the winner (the smaller number is 30).
Enter the number of game participants n and the interval m between the participants who break out of the circle, and create a program that outputs the winner's number. However, m, n <1000.
input
Given multiple datasets. Each dataset is given in the following format:
n m
The number of game participants n (integer) and the interval m (integer) between the participants who break out of the circle are given on one line separated by blanks.
The input ends with two 0s. The number of datasets does not exceed 50.
output
For each dataset, output the number (integer) of the winner and the person who will receive the potatoes on one line.
Example
Input
41 3
30 9
0 0
Output
31
21 | instruction | 0 | 30,847 | 19 | 61,694 |
"Correct Solution:
```
while 1:
n,m=map(int,input().split())
if n==0:break
a=m-1
while a<(m-1)*n:
a=m*a//(m-1)+1
print(n*m-a)
``` | output | 1 | 30,847 | 19 | 61,695 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
There used to be a game called Joseph's potatoes. Let's say n people are participating. Participants form a circle facing the center and are numbered starting from 1. One hot potato is given to participant n (the large number 30 inside the figure on the left). Participants who are given the potatoes will give the potatoes to the participant on the right. The person passed the mth time is passed to the person on the right and exits the circle (the figure on the left shows the case of m = 9). Each time you hand it over, you will pass one by one, and the last remaining person will be the winner and you will receive potatoes.
After n and m are decided, it would be nice to know where you can win before you actually start handing the potatoes. The figure above shows the case of playing this game with the rule that 30 participants exit every 9 people. The large numbers on the inside are the numbers assigned to the participants, and the small numbers on the outside are the numbers that are removed. According to it, it will break out of the circle in the order of 9,18,27,6,16,26, and 21 will remain at the end. That is, 21 is the winner (the smaller number is 30).
Enter the number of game participants n and the interval m between the participants who break out of the circle, and create a program that outputs the winner's number. However, m, n <1000.
input
Given multiple datasets. Each dataset is given in the following format:
n m
The number of game participants n (integer) and the interval m (integer) between the participants who break out of the circle are given on one line separated by blanks.
The input ends with two 0s. The number of datasets does not exceed 50.
output
For each dataset, output the number (integer) of the winner and the person who will receive the potatoes on one line.
Example
Input
41 3
30 9
0 0
Output
31
21 | instruction | 0 | 30,848 | 19 | 61,696 |
"Correct Solution:
```
while 1:
n,m=map(int,input().split())
if n==0:break
a=0
for i in range(2,n+1):a=(a+m)%i
print(a+1)
``` | output | 1 | 30,848 | 19 | 61,697 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
There used to be a game called Joseph's potatoes. Let's say n people are participating. Participants form a circle facing the center and are numbered starting from 1. One hot potato is given to participant n (the large number 30 inside the figure on the left). Participants who are given the potatoes will give the potatoes to the participant on the right. The person passed the mth time is passed to the person on the right and exits the circle (the figure on the left shows the case of m = 9). Each time you hand it over, you will pass one by one, and the last remaining person will be the winner and you will receive potatoes.
After n and m are decided, it would be nice to know where you can win before you actually start handing the potatoes. The figure above shows the case of playing this game with the rule that 30 participants exit every 9 people. The large numbers on the inside are the numbers assigned to the participants, and the small numbers on the outside are the numbers that are removed. According to it, it will break out of the circle in the order of 9,18,27,6,16,26, and 21 will remain at the end. That is, 21 is the winner (the smaller number is 30).
Enter the number of game participants n and the interval m between the participants who break out of the circle, and create a program that outputs the winner's number. However, m, n <1000.
input
Given multiple datasets. Each dataset is given in the following format:
n m
The number of game participants n (integer) and the interval m (integer) between the participants who break out of the circle are given on one line separated by blanks.
The input ends with two 0s. The number of datasets does not exceed 50.
output
For each dataset, output the number (integer) of the winner and the person who will receive the potatoes on one line.
Example
Input
41 3
30 9
0 0
Output
31
21 | instruction | 0 | 30,849 | 19 | 61,698 |
"Correct Solution:
```
import sys
for n, m in (map(int, l.split()) for l in sys.stdin):
if not n:
break
if m == 1:
print(n)
continue
a = list(range(1, n+1))
rem = 0
while len(a) > m:
d, _rem = divmod(len(a)+rem, m)
for i in list(range(-rem+m-1, len(a), m))[::-1]:
del a[i]
rem = _rem
while len(a) > 1:
i = (m % len(a) - rem - 1) % len(a)
del a[i]
rem = len(a)-i
print(a[0])
``` | output | 1 | 30,849 | 19 | 61,699 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
There used to be a game called Joseph's potatoes. Let's say n people are participating. Participants form a circle facing the center and are numbered starting from 1. One hot potato is given to participant n (the large number 30 inside the figure on the left). Participants who are given the potatoes will give the potatoes to the participant on the right. The person passed the mth time is passed to the person on the right and exits the circle (the figure on the left shows the case of m = 9). Each time you hand it over, you will pass one by one, and the last remaining person will be the winner and you will receive potatoes.
After n and m are decided, it would be nice to know where you can win before you actually start handing the potatoes. The figure above shows the case of playing this game with the rule that 30 participants exit every 9 people. The large numbers on the inside are the numbers assigned to the participants, and the small numbers on the outside are the numbers that are removed. According to it, it will break out of the circle in the order of 9,18,27,6,16,26, and 21 will remain at the end. That is, 21 is the winner (the smaller number is 30).
Enter the number of game participants n and the interval m between the participants who break out of the circle, and create a program that outputs the winner's number. However, m, n <1000.
input
Given multiple datasets. Each dataset is given in the following format:
n m
The number of game participants n (integer) and the interval m (integer) between the participants who break out of the circle are given on one line separated by blanks.
The input ends with two 0s. The number of datasets does not exceed 50.
output
For each dataset, output the number (integer) of the winner and the person who will receive the potatoes on one line.
Example
Input
41 3
30 9
0 0
Output
31
21 | instruction | 0 | 30,850 | 19 | 61,700 |
"Correct Solution:
```
while 1:
n,m=map(int,input().split())
if n==0:break
a=m-1
while a<(m-1)*n:
a=m*a//(m-1)+1
a=n*m-a
print(a)
``` | output | 1 | 30,850 | 19 | 61,701 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
There used to be a game called Joseph's potatoes. Let's say n people are participating. Participants form a circle facing the center and are numbered starting from 1. One hot potato is given to participant n (the large number 30 inside the figure on the left). Participants who are given the potatoes will give the potatoes to the participant on the right. The person passed the mth time is passed to the person on the right and exits the circle (the figure on the left shows the case of m = 9). Each time you hand it over, you will pass one by one, and the last remaining person will be the winner and you will receive potatoes.
After n and m are decided, it would be nice to know where you can win before you actually start handing the potatoes. The figure above shows the case of playing this game with the rule that 30 participants exit every 9 people. The large numbers on the inside are the numbers assigned to the participants, and the small numbers on the outside are the numbers that are removed. According to it, it will break out of the circle in the order of 9,18,27,6,16,26, and 21 will remain at the end. That is, 21 is the winner (the smaller number is 30).
Enter the number of game participants n and the interval m between the participants who break out of the circle, and create a program that outputs the winner's number. However, m, n <1000.
input
Given multiple datasets. Each dataset is given in the following format:
n m
The number of game participants n (integer) and the interval m (integer) between the participants who break out of the circle are given on one line separated by blanks.
The input ends with two 0s. The number of datasets does not exceed 50.
output
For each dataset, output the number (integer) of the winner and the person who will receive the potatoes on one line.
Example
Input
41 3
30 9
0 0
Output
31
21 | instruction | 0 | 30,851 | 19 | 61,702 |
"Correct Solution:
```
while 1:
n, m = map(int, input().split())
if n == 0 and m == 0:
break
number = list(range(1, n+1))
cnt = 0
for i in range(2, n+1):
cnt = (cnt + m) % i
print(cnt+1)
``` | output | 1 | 30,851 | 19 | 61,703 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
There used to be a game called Joseph's potatoes. Let's say n people are participating. Participants form a circle facing the center and are numbered starting from 1. One hot potato is given to participant n (the large number 30 inside the figure on the left). Participants who are given the potatoes will give the potatoes to the participant on the right. The person passed the mth time is passed to the person on the right and exits the circle (the figure on the left shows the case of m = 9). Each time you hand it over, you will pass one by one, and the last remaining person will be the winner and you will receive potatoes.
After n and m are decided, it would be nice to know where you can win before you actually start handing the potatoes. The figure above shows the case of playing this game with the rule that 30 participants exit every 9 people. The large numbers on the inside are the numbers assigned to the participants, and the small numbers on the outside are the numbers that are removed. According to it, it will break out of the circle in the order of 9,18,27,6,16,26, and 21 will remain at the end. That is, 21 is the winner (the smaller number is 30).
Enter the number of game participants n and the interval m between the participants who break out of the circle, and create a program that outputs the winner's number. However, m, n <1000.
input
Given multiple datasets. Each dataset is given in the following format:
n m
The number of game participants n (integer) and the interval m (integer) between the participants who break out of the circle are given on one line separated by blanks.
The input ends with two 0s. The number of datasets does not exceed 50.
output
For each dataset, output the number (integer) of the winner and the person who will receive the potatoes on one line.
Example
Input
41 3
30 9
0 0
Output
31
21 | instruction | 0 | 30,852 | 19 | 61,704 |
"Correct Solution:
```
import sys
f = sys.stdin
while True:
n, m = map(int, f.readline().split())
if n == m == 0:
break
circle = [i + 1 for i in range(n)]
cnt = 0
while len(circle) != 1:
cnt += m - 1
cnt %= len(circle)
circle = circle[:cnt] + circle[cnt + 1:]
print(circle[0])
``` | output | 1 | 30,852 | 19 | 61,705 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
There used to be a game called Joseph's potatoes. Let's say n people are participating. Participants form a circle facing the center and are numbered starting from 1. One hot potato is given to participant n (the large number 30 inside the figure on the left). Participants who are given the potatoes will give the potatoes to the participant on the right. The person passed the mth time is passed to the person on the right and exits the circle (the figure on the left shows the case of m = 9). Each time you hand it over, you will pass one by one, and the last remaining person will be the winner and you will receive potatoes.
After n and m are decided, it would be nice to know where you can win before you actually start handing the potatoes. The figure above shows the case of playing this game with the rule that 30 participants exit every 9 people. The large numbers on the inside are the numbers assigned to the participants, and the small numbers on the outside are the numbers that are removed. According to it, it will break out of the circle in the order of 9,18,27,6,16,26, and 21 will remain at the end. That is, 21 is the winner (the smaller number is 30).
Enter the number of game participants n and the interval m between the participants who break out of the circle, and create a program that outputs the winner's number. However, m, n <1000.
input
Given multiple datasets. Each dataset is given in the following format:
n m
The number of game participants n (integer) and the interval m (integer) between the participants who break out of the circle are given on one line separated by blanks.
The input ends with two 0s. The number of datasets does not exceed 50.
output
For each dataset, output the number (integer) of the winner and the person who will receive the potatoes on one line.
Example
Input
41 3
30 9
0 0
Output
31
21 | instruction | 0 | 30,853 | 19 | 61,706 |
"Correct Solution:
```
while True:
n,m=map(int,input().split())
if n==0 and m==0:
break
P=[]
for i in range(1,n+1):
P.append(i)
a=m-1
for i in range(n-1):
#print(P.pop(a))
P.pop(a)
a+=m
while True:
if a<=int(len(P)):
break
a=a-int(len(P))
a=a-1
print(P[0])
``` | output | 1 | 30,853 | 19 | 61,707 |
Provide a correct Python 3 solution for this coding contest problem.
<image>
There used to be a game called Joseph's potatoes. Let's say n people are participating. Participants form a circle facing the center and are numbered starting from 1. One hot potato is given to participant n (the large number 30 inside the figure on the left). Participants who are given the potatoes will give the potatoes to the participant on the right. The person passed the mth time is passed to the person on the right and exits the circle (the figure on the left shows the case of m = 9). Each time you hand it over, you will pass one by one, and the last remaining person will be the winner and you will receive potatoes.
After n and m are decided, it would be nice to know where you can win before you actually start handing the potatoes. The figure above shows the case of playing this game with the rule that 30 participants exit every 9 people. The large numbers on the inside are the numbers assigned to the participants, and the small numbers on the outside are the numbers that are removed. According to it, it will break out of the circle in the order of 9,18,27,6,16,26, and 21 will remain at the end. That is, 21 is the winner (the smaller number is 30).
Enter the number of game participants n and the interval m between the participants who break out of the circle, and create a program that outputs the winner's number. However, m, n <1000.
input
Given multiple datasets. Each dataset is given in the following format:
n m
The number of game participants n (integer) and the interval m (integer) between the participants who break out of the circle are given on one line separated by blanks.
The input ends with two 0s. The number of datasets does not exceed 50.
output
For each dataset, output the number (integer) of the winner and the person who will receive the potatoes on one line.
Example
Input
41 3
30 9
0 0
Output
31
21 | instruction | 0 | 30,854 | 19 | 61,708 |
"Correct Solution:
```
while 1:
n,m=map(int,input().split())
if n==0:break
a=m-1
while a<(m-1)*n:a=int(m*a/(m-1)+1)
print(n*m-a)
``` | output | 1 | 30,854 | 19 | 61,709 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO | instruction | 0 | 30,977 | 19 | 61,954 |
Tags: implementation
Correct Solution:
```
x=input()
s={'6':6,'7':7,'8':8,'9':9,'T':10,'J':11,'Q':12,'K':13,'A':14}
y=(list(input().split()))
if(x==y[0][1]):
if(y[0][1]!=y[1][1]):
print("YES")
else:
if(s[y[0][0]]>s[y[1][0]]):
print("YES")
else:
print("NO")
elif(y[0][1]!=y[1][1]):
print("NO")
else:
if(s[y[0][0]]>s[y[1][0]]):
print("YES")
else:
print("NO")
``` | output | 1 | 30,977 | 19 | 61,955 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO | instruction | 0 | 30,978 | 19 | 61,956 |
Tags: implementation
Correct Solution:
```
a=input()
x,y=list(map(str,input().split()))
p=[ "6", "7", "8", "9", "T", "J", "Q", "K" , "A"]
if(x[1]==a and y[1]!=a):
print("YES")
elif((x[1]==a and y[1]==a) or x[1]==y[1]):
if(p.index(x[0])>p.index(y[0])):
print("YES")
else:
print("NO")
else:
print("NO")
``` | output | 1 | 30,978 | 19 | 61,957 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO | instruction | 0 | 30,979 | 19 | 61,958 |
Tags: implementation
Correct Solution:
```
trump=input()
s1,s2=input().split()
l1=['6','7','8','9','T','J','Q','K','A']
if s1[1]==trump:
if s2[1]==trump:
if l1.index(s1[0])>l1.index(s2[0]):
print("YES")
else :
print("NO")
else :
print("YES")
else :
if s1[1]!=s2[1]:
print("NO")
else :
if l1.index(s1[0])>l1.index(s2[0]):
print("YES")
else :
print("NO")
``` | output | 1 | 30,979 | 19 | 61,959 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO | instruction | 0 | 30,980 | 19 | 61,960 |
Tags: implementation
Correct Solution:
```
import sys
import math
input=sys.stdin.buffer.readline
#t=int(input())
mod=998244353
# Python3 function to
# calculate nCr % p
def ncr(n, r, p):
# initialize numerator
# and denominator
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
t=1
for _ in range(t):
#n=int(input())
#n,k=map(int,input().split())
#l=list(map(int,input().split()))
trump=input()
l=["6", "7", "8", "9", "T", "J", "Q", "K", "A"]
x=input()
#print(chr(x[0]),chr(x[1]),trump,x[2],x[3],x[4])
if chr(x[1])==chr(x[4]):
#print(chr(x[1]),chr(x[4]))
if l.index(chr(x[0]))>l.index(chr(x[3])):
print("YES")
else:
print("NO")
else:
if chr(x[1])==chr(trump[0]):
print("YES")
else:
print("NO")
``` | output | 1 | 30,980 | 19 | 61,961 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO | instruction | 0 | 30,981 | 19 | 61,962 |
Tags: implementation
Correct Solution:
```
trump=input()
c1,c2=input().split()
c11=c1[0]
c22=c2[0]
if c11=='T':
c11=10
if c22=='T':
c22=10
if c11=='J':
c11=11
if c22=='J':
c22=11
if c11=='Q':
c11=12
if c22=='Q':
c22=12
if c11=='K':
c11=13
if c22=='K':
c22=13
if c11=='A':
c11=14
if c22=='A':
c22=14
if c2[1]!=c1[1] and c1[1]!=trump and c2[1]!=trump:
print('NO')
elif c2[1]==c1[1] and int(c11)>int(c22):
print('YES')
elif c2[1]!=c1[1]==trump:
print('YES')
else:
print('NO')
``` | output | 1 | 30,981 | 19 | 61,963 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO | instruction | 0 | 30,982 | 19 | 61,964 |
Tags: implementation
Correct Solution:
```
ts = input()
g=["6", "7", "8", "9"]
h=["T", "J", "Q", "K" , "A"]
a,b = input().split()
if a[-1] == b[-1]:
if a[0] in g:
if b[0] in h:
print('NO')
elif b[0] in g:
if g.index(a[0])>g.index(b[0]):
print('YES')
else:
print('NO')
elif a[0] in h:
if b[0] in g:
print('YES')
elif b[0] in h:
if h.index(a[0])>h.index(b[0]):
print('YES')
else:
print('NO')
else:
if a[-1] == ts:
print('YES')
else:
print('NO')
``` | output | 1 | 30,982 | 19 | 61,965 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO | instruction | 0 | 30,983 | 19 | 61,966 |
Tags: implementation
Correct Solution:
```
l=["6", "7", "8", "9", "T", "J", "Q", "K", "A"]
s=input()
a,b=map(str,input().split())
if(a[1]==s and b[1]!=s):
print("YES")
elif(a[1]==b[1]):
if(l.index(a[0])>l.index(b[0])):
print("YES")
else:
print("NO")
else:
print("NO")
``` | output | 1 | 30,983 | 19 | 61,967 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO | instruction | 0 | 30,984 | 19 | 61,968 |
Tags: implementation
Correct Solution:
```
ranks = { "6": 6, "7": 7, "8": 8, "9": 9, "T": 10,
"J": 11, "Q": 12, "K": 13, "A": 14 }
trump = input()
((r1, s1), (r2, s2)) = input().split()
if s1 == s2:
print("YES" if ranks[r1] > ranks[r2] else "NO")
elif s1 == trump:
print("YES")
else:
print("NO")
``` | output | 1 | 30,984 | 19 | 61,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO
Submitted Solution:
```
ranks = ["6", "7", "8", "9", "T", "J", "Q", "K", "A"]
tramp = input()
cards = input().split()
if cards[0][1] == tramp and cards[1][1] != tramp or cards[0][1] == cards[1][1] and ranks.index(cards[0][0]) > ranks.index(cards[1][0]):
print('YES')
else:
print('NO')
``` | instruction | 0 | 30,985 | 19 | 61,970 |
Yes | output | 1 | 30,985 | 19 | 61,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO
Submitted Solution:
```
a = input()
b,c = input().split()
lst = ["6", "7", "8", "9", "T", "J", "Q", "K" , "A"]
if b[1] ==c[1]:
print('YES' if lst.index(b[0]) > lst.index(c[0]) else 'NO')
elif b[1] == a:
print('YES')
else:
print('NO')
``` | instruction | 0 | 30,986 | 19 | 61,972 |
Yes | output | 1 | 30,986 | 19 | 61,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO
Submitted Solution:
```
trump = input()
a, b = map(str, input().split())
arr = ["6", "7", "8", "9", "T", "J", "Q", "K", "A"]
if a[1] == b[1]:
if arr.index(a[0]) > arr.index(b[0]):
print("YES")
else:
print("NO")
else:
if a[1] == trump:
print("YES")
else:
print("NO")
``` | instruction | 0 | 30,987 | 19 | 61,974 |
Yes | output | 1 | 30,987 | 19 | 61,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO
Submitted Solution:
```
def compare(s1,s2):
x = "6 7 8 9 T J Q K A".split()
for i in range (9):
if s1 == x[i]:
t1 = i
if s2 == x[i]:
t2 = i
return t1 > t2
n = input()
res = 'NO'
s = input().split()
if s[0][1] == s[1][1]:
if compare(s[0][0],s[1][0]):
res = 'YES'
else:
if s[0][1] == n:
res = 'YES'
print(res)
``` | instruction | 0 | 30,988 | 19 | 61,976 |
Yes | output | 1 | 30,988 | 19 | 61,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO
Submitted Solution:
```
tramp = input()
l=[ "6", "7", "8", "9", "T", "J", "Q", "K" ,"A"]
first,second = map(str,input().split())
if tramp in first and tramp not in second:
print("YES")
elif tramp in second and tramp not in first:
print("NO")
elif tramp in first and tramp in second:
if first[0] in l:
if l.index(first[0])>l.index(second[0]):
print("YES")
else:
print("NO")
else:
if first[0] in l and first[1]==second[1]:
if l.index(first[0])>l.index(second[0]):
print("YES")
else:
print("NO")
``` | instruction | 0 | 30,989 | 19 | 61,978 |
No | output | 1 | 30,989 | 19 | 61,979 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO
Submitted Solution:
```
a=['6','7','8','9','T',"J","Q","K","A"]
trump=input()
first,second=input().split()
if first[1]==trump:
print("YES")
elif first[1]==second[1]:
if a.index(first[0])>a.index(second[0]):
print('YES')
else:
print("NO")
``` | instruction | 0 | 30,990 | 19 | 61,980 |
No | output | 1 | 30,990 | 19 | 61,981 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO
Submitted Solution:
```
a = input()
b = input().split()
if 48<=ord(b[-1][0])<=57 and 48<=ord(b[0][0])<=57:
if int(b[-1][0])> int((b[0][0])):
if b[0][0]!=a:
print('NO')
else:
print('YES')
else:
print('YES')
else:
s=["6", "7", "8", "9", "T", "J", "Q", "K" ,"A"]
if b[0][1]==a:
if b[-1][1]==a:
if s.index(b[0][0]) >= s.index(b[-1][0]):
print('YES')
else:
print('NO')
else:
print('YES')
else:
if b[-1][1]==a:
print('NO')
else:
if s.index(b[0][0]) >= s.index(b[-1][0]):
print('YES')
else:
print('NO')
``` | instruction | 0 | 30,991 | 19 | 61,982 |
No | output | 1 | 30,991 | 19 | 61,983 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a card game called "Durak", which means "Fool" in Russian. The game is quite popular in the countries that used to form USSR. The problem does not state all the game's rules explicitly — you can find them later yourselves if you want.
To play durak you need a pack of 36 cards. Each card has a suit ("S", "H", "D" and "C") and a rank (in the increasing order "6", "7", "8", "9", "T", "J", "Q", "K" and "A"). At the beginning of the game one suit is arbitrarily chosen as trump.
The players move like that: one player puts one or several of his cards on the table and the other one should beat each of them with his cards.
A card beats another one if both cards have similar suits and the first card has a higher rank then the second one. Besides, a trump card can beat any non-trump card whatever the cards’ ranks are. In all other cases you can not beat the second card with the first one.
You are given the trump suit and two different cards. Determine whether the first one beats the second one or not.
Input
The first line contains the tramp suit. It is "S", "H", "D" or "C".
The second line contains the description of the two different cards. Each card is described by one word consisting of two symbols. The first symbol stands for the rank ("6", "7", "8", "9", "T", "J", "Q", "K" and "A"), and the second one stands for the suit ("S", "H", "D" and "C").
Output
Print "YES" (without the quotes) if the first cards beats the second one. Otherwise, print "NO" (also without the quotes).
Examples
Input
H
QH 9S
Output
YES
Input
S
8D 6D
Output
YES
Input
C
7H AS
Output
NO
Submitted Solution:
```
a = input()
b = input().split()
if 48<=ord(b[-1][0])<=57 and 48<=ord(b[0][0])<=57:
if int(b[-1][0])> int((b[0][0])):
if b[0][1]!=a:
print('NO')
else:
print('YES')
else:
print('YES')
else:
s=["6", "7", "8", "9", "T", "J", "Q", "K" ,"A"]
if b[0][1]==a:
if b[-1][1]==a:
if s.index(b[0][0]) > s.index(b[-1][0]):
print('YES')
else:
print('NO')
else:
print('YES')
else:
if b[-1][1]==a:
print('NO')
else:
if s.index(b[0][0]) > s.index(b[-1][0]):
print('YES')
else:
print('NO')
``` | instruction | 0 | 30,992 | 19 | 61,984 |
No | output | 1 | 30,992 | 19 | 61,985 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Before the start of the football season in Berland a strange magic ritual is held. The most experienced magicians have to find a magic matrix of the size n × n (n is even number). Gods will never allow to start the championship without it. Matrix should contain integers from 0 to n - 1, main diagonal should contain only zeroes and matrix should be symmetric. Moreover, all numbers in each row should be different. Magicians are very tired of the thinking process, so they ask you to write a program to find such matrix.
Input
The first line contains one integer n (2 ≤ n ≤ 1000), n is even.
Output
Output n lines with n numbers each — the required matrix. Separate numbers with spaces. If there are several solutions, output any.
Examples
Input
2
Output
0 1
1 0
Input
4
Output
0 1 3 2
1 0 2 3
3 2 0 1
2 3 1 0 | instruction | 0 | 31,108 | 19 | 62,216 |
Tags: constructive algorithms
Correct Solution:
```
n=int(input())
a=[[0 for j in range(n)] for i in range(n)]
for i in range(n-1):
for j in range(n-1):
if i!=j:
a[i][j]=(i+j)%n+int(i+j>=n)
a[i][n-1]=((n-1+2*i)%n+int(n-1+2*i>=n))%n+int(n-1+2*i>2*(n-1))
for i in range(n-1):
a[n-1][i]=((n-1+2*i)%n+int(n-1+2*i>=n))%n+int(n-1+2*i>2*(n-1))
for i in a:
print(*i)
``` | output | 1 | 31,108 | 19 | 62,217 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.