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.
This is an interactive problem.
Yui is a girl who enjoys playing Mahjong.
<image>
She has a mysterious set which consists of tiles (this set can be empty). Each tile has an integer value between 1 and n, and at most n tiles in the set have the same value. So the set can contain at most n^2 tiles.
You want to figure out which values are on the tiles. But Yui is shy, she prefers to play a guessing game with you.
Let's call a set consisting of three tiles triplet if their values are the same. For example, \{2, 2, 2\} is a triplet, but \{2, 3, 3\} is not.
Let's call a set consisting of three tiles straight if their values are consecutive integers. For example, \{2, 3, 4\} is a straight, but \{1, 3, 5\} is not.
At first, Yui gives you the number of triplet subsets and straight subsets of the initial set respectively. After that, you can insert a tile with an integer value between 1 and n into the set at most n times. Every time you insert a tile, you will get the number of triplet subsets and straight subsets of the current set as well.
Note that two tiles with the same value are treated different. In other words, in the set \{1, 1, 2, 2, 3\} you can find 4 subsets \{1, 2, 3\}.
Try to guess the number of tiles in the initial set with value i for all integers i from 1 to n.
Input
The first line contains a single integer n (4 ≤ n ≤ 100).
The second line contains two integers which represent the number of triplet subsets and straight subsets of the initial set respectively.
Output
When you are ready to answer, print a single line of form "! a_1 a_2 … a_n" (0 ≤ a_i ≤ n), where a_i is equal to the number of tiles in the initial set with value i.
Interaction
To insert a tile, print a single line of form "+ x" (1 ≤ x ≤ n), where x is the value of the tile you insert. Then you should read two integers which represent the number of triplet subsets and straight subsets of the current set respectively.
After printing a line, do not forget to flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
You will get Wrong answer if you insert more than n tiles.
Hacks
To make a hack you should provide a test in such format:
The first line contains a single integer n (4 ≤ n ≤ 100).
The second line contains n integers a_1,a_2,…,a_n (0 ≤ a_i ≤ n) — a_i is equal to the number of tiles with value i in the set.
Example
Input
5
1 6
2 9
5 12
5 24
6 24
Output
+ 1
+ 1
+ 2
+ 5
! 2 1 3 0 2
Note
In the first test, the initial set of tiles is \{1, 1, 2, 3, 3, 3, 5, 5\}. It has only one triplet subset \{3, 3, 3\} and six straight subsets, all equal to \{1, 2, 3\}. After inserting a tile with value 1 the set of tiles will be \{1, 1, 1, 2, 3, 3, 3, 5, 5\} and will have two triplet subsets \{1, 1, 1\}, \{3, 3, 3\} and nine straight subsets, all equal to \{1, 2, 3\}.
Submitted Solution:
```
import os
import sys
#input = sys.stdin.buffer.readline
#sys.setrecursionlimit(int(3e5))
from collections import deque
from queue import PriorityQueue
import math
# list(map(int, input().split()))
#####################################################################################
class CF(object):
def get(self):
a, b = list(map(int, input().split()))
self.pre = self.now
self.now = [a,b]
def ask(self, x):
self.s[x]+=1
if(self.a[x] != -1):
self.a[x] += 1
print('+ ' + str(x))
sys.stdout.flush()
self.get()
self.r = [self.now[0] - self.pre[0], self.now[1] - self.pre[1]]
pass
def cal(self, x):
return int((2*x)**0.5)+1 + 1
def __init__(self):
self.eps = 1e-6
self.n = int(input())
self.a = [-1] * (self.n + 1)
self.s = [0] * (self.n + 1)
self.r = None
self.pre = None
self.now = list(map(int, input().split()))
self.ask(1)
if(self.r[0]>0):
self.a[1] = self.cal(self.r[0])
else:
self.ask(1)
self.a[1] = self.cal(self.r[0])
t1 = self.r[1]
self.ask(2)
if(self.r[0]>0):
self.a[2] = self.cal(self.r[0])
self.a[3] = int(t1 // (self.a[2] - 1 + self.eps))
self.a[4] = int((self.r[1] - (self.a[1] * self.a[2])) // (self.a[3] + self.eps))
else:
self.ask(2)
self.a[2] = self.cal(self.r[0])
self.a[3] = int(t1 // (self.a[2] - 2 + self.eps))
self.a[4] = int((self.r[1] - (self.a[1] * self.a[2]) * 2 ) // (self.a[3] + self.eps))
for i in range(3, self.n-1):
self.ask(i)
temp = self.r[1] - self.a[i-2]*self.a[i-1] - self.a[i-1] * self.a[i+1]
self.a[i+2] = int(temp//(self.a[i+1] + self.eps))
for i in range(1, self.n + 1):
self.a[i] -= self.s[i]
print('! '+ ' '.join(map(str, self.a[1:])))
def main(self):
pass
if __name__ == "__main__":
cf = CF()
cf.main()
pass
``` | instruction | 0 | 17,843 | 19 | 35,686 |
No | output | 1 | 17,843 | 19 | 35,687 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
Yui is a girl who enjoys playing Mahjong.
<image>
She has a mysterious set which consists of tiles (this set can be empty). Each tile has an integer value between 1 and n, and at most n tiles in the set have the same value. So the set can contain at most n^2 tiles.
You want to figure out which values are on the tiles. But Yui is shy, she prefers to play a guessing game with you.
Let's call a set consisting of three tiles triplet if their values are the same. For example, \{2, 2, 2\} is a triplet, but \{2, 3, 3\} is not.
Let's call a set consisting of three tiles straight if their values are consecutive integers. For example, \{2, 3, 4\} is a straight, but \{1, 3, 5\} is not.
At first, Yui gives you the number of triplet subsets and straight subsets of the initial set respectively. After that, you can insert a tile with an integer value between 1 and n into the set at most n times. Every time you insert a tile, you will get the number of triplet subsets and straight subsets of the current set as well.
Note that two tiles with the same value are treated different. In other words, in the set \{1, 1, 2, 2, 3\} you can find 4 subsets \{1, 2, 3\}.
Try to guess the number of tiles in the initial set with value i for all integers i from 1 to n.
Input
The first line contains a single integer n (4 ≤ n ≤ 100).
The second line contains two integers which represent the number of triplet subsets and straight subsets of the initial set respectively.
Output
When you are ready to answer, print a single line of form "! a_1 a_2 … a_n" (0 ≤ a_i ≤ n), where a_i is equal to the number of tiles in the initial set with value i.
Interaction
To insert a tile, print a single line of form "+ x" (1 ≤ x ≤ n), where x is the value of the tile you insert. Then you should read two integers which represent the number of triplet subsets and straight subsets of the current set respectively.
After printing a line, do not forget to flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
You will get Wrong answer if you insert more than n tiles.
Hacks
To make a hack you should provide a test in such format:
The first line contains a single integer n (4 ≤ n ≤ 100).
The second line contains n integers a_1,a_2,…,a_n (0 ≤ a_i ≤ n) — a_i is equal to the number of tiles with value i in the set.
Example
Input
5
1 6
2 9
5 12
5 24
6 24
Output
+ 1
+ 1
+ 2
+ 5
! 2 1 3 0 2
Note
In the first test, the initial set of tiles is \{1, 1, 2, 3, 3, 3, 5, 5\}. It has only one triplet subset \{3, 3, 3\} and six straight subsets, all equal to \{1, 2, 3\}. After inserting a tile with value 1 the set of tiles will be \{1, 1, 1, 2, 3, 3, 3, 5, 5\} and will have two triplet subsets \{1, 1, 1\}, \{3, 3, 3\} and nine straight subsets, all equal to \{1, 2, 3\}.
Submitted Solution:
```
# Don't brood. Get on with living and loving. You don't have forever. Leo Buscaglia
# by : Blue Edge - Create some chaos
def give(y):
if y==0:
return -1
x=(1+(1+8*y)**0.5)//2
return int(x)
# print(give(1))
#a 1 2 3 4 5
# 2 1 3 0 2
# 3 1 3 0 2
# 3 2 3 0 2
# 3 2 4 0 2
# 3 2 4 1 2
# 3 2 4 1 3
n=int(input())
t,s=map(int,input().split())
a=[0]*(n+3)
b=[s]
for i in range(1,n+1):
print("+",i)
t1,s1=map(int,input().split())
b.append(s1)
a[i]=give(t1-t)
if a[i]!=-1:
a[i]+=1
t=t1
b.append(0)
# print(b)
for i in range(1,n+1):
if a[i]==-1:
a[i] =int( (b[i-1] -b[i-2])!=(a[i-2]*a[i-3]) )
a[i]+=1
a=[x-1 for x in a]
print("!",*a[1:n+1])
``` | instruction | 0 | 17,844 | 19 | 35,688 |
No | output | 1 | 17,844 | 19 | 35,689 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
Yui is a girl who enjoys playing Mahjong.
<image>
She has a mysterious set which consists of tiles (this set can be empty). Each tile has an integer value between 1 and n, and at most n tiles in the set have the same value. So the set can contain at most n^2 tiles.
You want to figure out which values are on the tiles. But Yui is shy, she prefers to play a guessing game with you.
Let's call a set consisting of three tiles triplet if their values are the same. For example, \{2, 2, 2\} is a triplet, but \{2, 3, 3\} is not.
Let's call a set consisting of three tiles straight if their values are consecutive integers. For example, \{2, 3, 4\} is a straight, but \{1, 3, 5\} is not.
At first, Yui gives you the number of triplet subsets and straight subsets of the initial set respectively. After that, you can insert a tile with an integer value between 1 and n into the set at most n times. Every time you insert a tile, you will get the number of triplet subsets and straight subsets of the current set as well.
Note that two tiles with the same value are treated different. In other words, in the set \{1, 1, 2, 2, 3\} you can find 4 subsets \{1, 2, 3\}.
Try to guess the number of tiles in the initial set with value i for all integers i from 1 to n.
Input
The first line contains a single integer n (4 ≤ n ≤ 100).
The second line contains two integers which represent the number of triplet subsets and straight subsets of the initial set respectively.
Output
When you are ready to answer, print a single line of form "! a_1 a_2 … a_n" (0 ≤ a_i ≤ n), where a_i is equal to the number of tiles in the initial set with value i.
Interaction
To insert a tile, print a single line of form "+ x" (1 ≤ x ≤ n), where x is the value of the tile you insert. Then you should read two integers which represent the number of triplet subsets and straight subsets of the current set respectively.
After printing a line, do not forget to flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
You will get Wrong answer if you insert more than n tiles.
Hacks
To make a hack you should provide a test in such format:
The first line contains a single integer n (4 ≤ n ≤ 100).
The second line contains n integers a_1,a_2,…,a_n (0 ≤ a_i ≤ n) — a_i is equal to the number of tiles with value i in the set.
Example
Input
5
1 6
2 9
5 12
5 24
6 24
Output
+ 1
+ 1
+ 2
+ 5
! 2 1 3 0 2
Note
In the first test, the initial set of tiles is \{1, 1, 2, 3, 3, 3, 5, 5\}. It has only one triplet subset \{3, 3, 3\} and six straight subsets, all equal to \{1, 2, 3\}. After inserting a tile with value 1 the set of tiles will be \{1, 1, 1, 2, 3, 3, 3, 5, 5\} and will have two triplet subsets \{1, 1, 1\}, \{3, 3, 3\} and nine straight subsets, all equal to \{1, 2, 3\}.
Submitted Solution:
```
"""
Author : thekushalghosh
Team : CodeDiggers
"""
import sys,math,cmath,time
start_time = time.time()
################# ---- USER DEFINED INPUT FUNCTIONS ---- #################
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(s[:len(s) - 1])
def invr():
return(map(int,input().split()))
##########################################################################
################# ---- THE ACTUAL CODE STARTS BELOW ---- #################
def solve():
n = inp()
a,b = invr()
for i in range(n):
print("+ 1")
sys.stdout.flush()
q,w = invr()
if b % (2 + a) == 0:
qw = "! " + str(b // (2 + a)) + " 1 " + str(2 + a) + (" 0 " * (n - 4)) + str(b // (2 + a))
else:
c = 0
while b % (2 + a) != 0:
a = a - 1
c = c + 1
qw = "! " + str(2 + a) + " 1 " + str(b // (2 + a)) + " 0 " + str(c) + (" 0" * (n - 4))
print(qw)
################## ---- THE ACTUAL CODE ENDS ABOVE ---- ##################
##########################################################################
ONLINE_JUDGE = __debug__
if not ONLINE_JUDGE:
sys.stdin = open('input.txt','r')
sys.stdout = open('output.txt','w')
else:
input = sys.stdin.readline
t = 1
for tt in range(t):
solve()
if not ONLINE_JUDGE:
print("Time Elapsed:",time.time() - start_time,"seconds")
sys.stdout.close()
``` | instruction | 0 | 17,845 | 19 | 35,690 |
No | output | 1 | 17,845 | 19 | 35,691 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This is an interactive problem.
Yui is a girl who enjoys playing Mahjong.
<image>
She has a mysterious set which consists of tiles (this set can be empty). Each tile has an integer value between 1 and n, and at most n tiles in the set have the same value. So the set can contain at most n^2 tiles.
You want to figure out which values are on the tiles. But Yui is shy, she prefers to play a guessing game with you.
Let's call a set consisting of three tiles triplet if their values are the same. For example, \{2, 2, 2\} is a triplet, but \{2, 3, 3\} is not.
Let's call a set consisting of three tiles straight if their values are consecutive integers. For example, \{2, 3, 4\} is a straight, but \{1, 3, 5\} is not.
At first, Yui gives you the number of triplet subsets and straight subsets of the initial set respectively. After that, you can insert a tile with an integer value between 1 and n into the set at most n times. Every time you insert a tile, you will get the number of triplet subsets and straight subsets of the current set as well.
Note that two tiles with the same value are treated different. In other words, in the set \{1, 1, 2, 2, 3\} you can find 4 subsets \{1, 2, 3\}.
Try to guess the number of tiles in the initial set with value i for all integers i from 1 to n.
Input
The first line contains a single integer n (4 ≤ n ≤ 100).
The second line contains two integers which represent the number of triplet subsets and straight subsets of the initial set respectively.
Output
When you are ready to answer, print a single line of form "! a_1 a_2 … a_n" (0 ≤ a_i ≤ n), where a_i is equal to the number of tiles in the initial set with value i.
Interaction
To insert a tile, print a single line of form "+ x" (1 ≤ x ≤ n), where x is the value of the tile you insert. Then you should read two integers which represent the number of triplet subsets and straight subsets of the current set respectively.
After printing a line, do not forget to flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:
* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.
You will get Wrong answer if you insert more than n tiles.
Hacks
To make a hack you should provide a test in such format:
The first line contains a single integer n (4 ≤ n ≤ 100).
The second line contains n integers a_1,a_2,…,a_n (0 ≤ a_i ≤ n) — a_i is equal to the number of tiles with value i in the set.
Example
Input
5
1 6
2 9
5 12
5 24
6 24
Output
+ 1
+ 1
+ 2
+ 5
! 2 1 3 0 2
Note
In the first test, the initial set of tiles is \{1, 1, 2, 3, 3, 3, 5, 5\}. It has only one triplet subset \{3, 3, 3\} and six straight subsets, all equal to \{1, 2, 3\}. After inserting a tile with value 1 the set of tiles will be \{1, 1, 1, 2, 3, 3, 3, 5, 5\} and will have two triplet subsets \{1, 1, 1\}, \{3, 3, 3\} and nine straight subsets, all equal to \{1, 2, 3\}.
Submitted Solution:
```
"""
Author : thekushalghosh
Team : CodeDiggers
"""
import sys,math,cmath,time
start_time = time.time()
################# ---- USER DEFINED INPUT FUNCTIONS ---- #################
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(s[:len(s) - 1])
def invr():
return(map(int,input().split()))
##########################################################################
################# ---- THE ACTUAL CODE STARTS BELOW ---- #################
def solve():
n = inp()
a,b = invr()
for i in range(1):
print("+ 1")
sys.stdout.flush()
q,w = invr()
if b % (2 + a) == 0:
qw = "! " + str(b // (2 + a)) + " 1 " + str(2 + a) + (" 0 " * (n - 4)) + str(b // (2 + a))
else:
c = 0
while b % (2 + a) != 0:
a = a - 1
c = c + 1
qw = "! " + str(2 + a) + " 1 " + str(b // (2 + a)) + " 0 " + str(c) + (" 0" * (n - 4))
print(qw)
################## ---- THE ACTUAL CODE ENDS ABOVE ---- ##################
##########################################################################
ONLINE_JUDGE = __debug__
if not ONLINE_JUDGE:
sys.stdin = open('input.txt','r')
sys.stdout = open('output.txt','w')
else:
input = sys.stdin.readline
t = 1
for tt in range(t):
solve()
if not ONLINE_JUDGE:
print("Time Elapsed:",time.time() - start_time,"seconds")
sys.stdout.close()
``` | instruction | 0 | 17,846 | 19 | 35,692 |
No | output | 1 | 17,846 | 19 | 35,693 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya likes to play a lot. Most of all he likes to play a game «Holes». This is a game for one person with following rules:
There are N holes located in a single row and numbered from left to right with numbers from 1 to N. Each hole has it's own power (hole number i has the power ai). If you throw a ball into hole i it will immediately jump to hole i + ai, then it will jump out of it and so on. If there is no hole with such number, the ball will just jump out of the row. On each of the M moves the player can perform one of two actions:
* Set the power of the hole a to value b.
* Throw a ball into the hole a and count the number of jumps of a ball before it jump out of the row and also write down the number of the hole from which it jumped out just before leaving the row.
Petya is not good at math, so, as you have already guessed, you are to perform all computations.
Input
The first line contains two integers N and M (1 ≤ N ≤ 105, 1 ≤ M ≤ 105) — the number of holes in a row and the number of moves. The second line contains N positive integers not exceeding N — initial values of holes power. The following M lines describe moves made by Petya. Each of these line can be one of the two types:
* 0 a b
* 1 a
Type 0 means that it is required to set the power of hole a to b, and type 1 means that it is required to throw a ball into the a-th hole. Numbers a and b are positive integers do not exceeding N.
Output
For each move of the type 1 output two space-separated numbers on a separate line — the number of the last hole the ball visited before leaving the row and the number of jumps it made.
Examples
Input
8 5
1 1 1 1 1 2 8 2
1 1
0 1 3
1 1
0 3 4
1 2
Output
8 7
8 5
7 3
Submitted Solution:
```
__author__ = 'Darren'
def solve():
def update(index):
if index + power[index] >= n:
next_hole[index] = n
count[index] = 1
else:
if index // k == (index + power[index]) // k:
next_hole[index] = next_hole[index+power[index]]
count[index] = count[index+power[index]] + 1
else:
next_hole[index] = index + power[index]
count[index] = 1
def query(index):
jumps = 0
while next_hole[index] != n:
jumps += count[index]
index = next_hole[index]
jumps += 1
return index + 1, jumps
n, m = map(int, input().split())
power = [int(x) for x in input().split()]
from math import ceil
k = ceil(n ** 0.5)
next_hole, count = [0] * n, [0] * n
for i in range(n-1, -1, -1):
update(i)
for _i in range(m):
move = [int(x) for x in input().split()]
if move[0] == 0:
hole = move[1] - 1
power[hole] = move[2]
for j in range(hole, hole // k * k - 1, -1):
update(j)
else:
print('%d %d' % query(move[1] - 1))
if __name__ == '__main__':
solve()
``` | instruction | 0 | 17,852 | 19 | 35,704 |
No | output | 1 | 17,852 | 19 | 35,705 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha and Ira are two best friends. But they aren’t just friends, they are software engineers and experts in artificial intelligence. They are developing an algorithm for two bots playing a two-player game. The game is cooperative and turn based. In each turn, one of the players makes a move (it doesn’t matter which player, it's possible that players turns do not alternate).
Algorithm for bots that Sasha and Ira are developing works by keeping track of the state the game is in. Each time either bot makes a move, the state changes. And, since the game is very dynamic, it will never go back to the state it was already in at any point in the past.
Sasha and Ira are perfectionists and want their algorithm to have an optimal winning strategy. They have noticed that in the optimal winning strategy, both bots make exactly N moves each. But, in order to find the optimal strategy, their algorithm needs to analyze all possible states of the game (they haven’t learned about alpha-beta pruning yet) and pick the best sequence of moves.
They are worried about the efficiency of their algorithm and are wondering what is the total number of states of the game that need to be analyzed?
Input
The first and only line contains integer N.
* 1 ≤ N ≤ 106
Output
Output should contain a single integer – number of possible states modulo 109 + 7.
Examples
Input
2
Output
19
Note
Start: Game is in state A.
* Turn 1: Either bot can make a move (first bot is red and second bot is blue), so there are two possible states after the first turn – B and C.
* Turn 2: In both states B and C, either bot can again make a turn, so the list of possible states is expanded to include D, E, F and G.
* Turn 3: Red bot already did N=2 moves when in state D, so it cannot make any more moves there. It can make moves when in state E, F and G, so states I, K and M are added to the list. Similarly, blue bot cannot make a move when in state G, but can when in D, E and F, so states H, J and L are added.
* Turn 4: Red bot already did N=2 moves when in states H, I and K, so it can only make moves when in J, L and M, so states P, R and S are added. Blue bot cannot make a move when in states J, L and M, but only when in H, I and K, so states N, O and Q are added.
Overall, there are 19 possible states of the game their algorithm needs to analyze.
<image> | instruction | 0 | 18,098 | 19 | 36,196 |
Tags: combinatorics, number theory
Correct Solution:
```
MOD = 10**9+7
x=int(input())+1
n=1
n2=1
fac=1
for i in range(1,2*x+1):
fac = (fac*i)%MOD
if i==x:
n=fac
if i==2*x:
n2=fac
res= (n2*pow(n,MOD-2,MOD)**2)%MOD-1
print(res)
``` | output | 1 | 18,098 | 19 | 36,197 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha and Ira are two best friends. But they aren’t just friends, they are software engineers and experts in artificial intelligence. They are developing an algorithm for two bots playing a two-player game. The game is cooperative and turn based. In each turn, one of the players makes a move (it doesn’t matter which player, it's possible that players turns do not alternate).
Algorithm for bots that Sasha and Ira are developing works by keeping track of the state the game is in. Each time either bot makes a move, the state changes. And, since the game is very dynamic, it will never go back to the state it was already in at any point in the past.
Sasha and Ira are perfectionists and want their algorithm to have an optimal winning strategy. They have noticed that in the optimal winning strategy, both bots make exactly N moves each. But, in order to find the optimal strategy, their algorithm needs to analyze all possible states of the game (they haven’t learned about alpha-beta pruning yet) and pick the best sequence of moves.
They are worried about the efficiency of their algorithm and are wondering what is the total number of states of the game that need to be analyzed?
Input
The first and only line contains integer N.
* 1 ≤ N ≤ 106
Output
Output should contain a single integer – number of possible states modulo 109 + 7.
Examples
Input
2
Output
19
Note
Start: Game is in state A.
* Turn 1: Either bot can make a move (first bot is red and second bot is blue), so there are two possible states after the first turn – B and C.
* Turn 2: In both states B and C, either bot can again make a turn, so the list of possible states is expanded to include D, E, F and G.
* Turn 3: Red bot already did N=2 moves when in state D, so it cannot make any more moves there. It can make moves when in state E, F and G, so states I, K and M are added to the list. Similarly, blue bot cannot make a move when in state G, but can when in D, E and F, so states H, J and L are added.
* Turn 4: Red bot already did N=2 moves when in states H, I and K, so it can only make moves when in J, L and M, so states P, R and S are added. Blue bot cannot make a move when in states J, L and M, but only when in H, I and K, so states N, O and Q are added.
Overall, there are 19 possible states of the game their algorithm needs to analyze.
<image> | instruction | 0 | 18,099 | 19 | 36,198 |
Tags: combinatorics, number theory
Correct Solution:
```
import cmath
n = int(input())
q=1
p=1
def inv(a,b):
if(a>1):
return b-inv(b%a,a)*b//a
else:
return 1
for j in range(1,n+2):
p=p*(n+1+j)% 1000000007
q=(q*j)% 1000000007
print(p*inv(q,1000000007) % 1000000007 -1)
``` | output | 1 | 18,099 | 19 | 36,199 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha and Ira are two best friends. But they aren’t just friends, they are software engineers and experts in artificial intelligence. They are developing an algorithm for two bots playing a two-player game. The game is cooperative and turn based. In each turn, one of the players makes a move (it doesn’t matter which player, it's possible that players turns do not alternate).
Algorithm for bots that Sasha and Ira are developing works by keeping track of the state the game is in. Each time either bot makes a move, the state changes. And, since the game is very dynamic, it will never go back to the state it was already in at any point in the past.
Sasha and Ira are perfectionists and want their algorithm to have an optimal winning strategy. They have noticed that in the optimal winning strategy, both bots make exactly N moves each. But, in order to find the optimal strategy, their algorithm needs to analyze all possible states of the game (they haven’t learned about alpha-beta pruning yet) and pick the best sequence of moves.
They are worried about the efficiency of their algorithm and are wondering what is the total number of states of the game that need to be analyzed?
Input
The first and only line contains integer N.
* 1 ≤ N ≤ 106
Output
Output should contain a single integer – number of possible states modulo 109 + 7.
Examples
Input
2
Output
19
Note
Start: Game is in state A.
* Turn 1: Either bot can make a move (first bot is red and second bot is blue), so there are two possible states after the first turn – B and C.
* Turn 2: In both states B and C, either bot can again make a turn, so the list of possible states is expanded to include D, E, F and G.
* Turn 3: Red bot already did N=2 moves when in state D, so it cannot make any more moves there. It can make moves when in state E, F and G, so states I, K and M are added to the list. Similarly, blue bot cannot make a move when in state G, but can when in D, E and F, so states H, J and L are added.
* Turn 4: Red bot already did N=2 moves when in states H, I and K, so it can only make moves when in J, L and M, so states P, R and S are added. Blue bot cannot make a move when in states J, L and M, but only when in H, I and K, so states N, O and Q are added.
Overall, there are 19 possible states of the game their algorithm needs to analyze.
<image> | instruction | 0 | 18,100 | 19 | 36,200 |
Tags: combinatorics, number theory
Correct Solution:
```
n = int(input())
u, v, f, B = 1, 1 , 1, 10**9+7
for i in range(2,n+2):
u = u * i % B
for i in range(2,n+n+3):
f = f * i % B
def inv(u):
if u < 2:
return 1
return (-(B // u) * inv(B % u)) % B
print((f * inv(u) * inv(u) + B - 1) % B)
``` | output | 1 | 18,100 | 19 | 36,201 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha and Ira are two best friends. But they aren’t just friends, they are software engineers and experts in artificial intelligence. They are developing an algorithm for two bots playing a two-player game. The game is cooperative and turn based. In each turn, one of the players makes a move (it doesn’t matter which player, it's possible that players turns do not alternate).
Algorithm for bots that Sasha and Ira are developing works by keeping track of the state the game is in. Each time either bot makes a move, the state changes. And, since the game is very dynamic, it will never go back to the state it was already in at any point in the past.
Sasha and Ira are perfectionists and want their algorithm to have an optimal winning strategy. They have noticed that in the optimal winning strategy, both bots make exactly N moves each. But, in order to find the optimal strategy, their algorithm needs to analyze all possible states of the game (they haven’t learned about alpha-beta pruning yet) and pick the best sequence of moves.
They are worried about the efficiency of their algorithm and are wondering what is the total number of states of the game that need to be analyzed?
Input
The first and only line contains integer N.
* 1 ≤ N ≤ 106
Output
Output should contain a single integer – number of possible states modulo 109 + 7.
Examples
Input
2
Output
19
Note
Start: Game is in state A.
* Turn 1: Either bot can make a move (first bot is red and second bot is blue), so there are two possible states after the first turn – B and C.
* Turn 2: In both states B and C, either bot can again make a turn, so the list of possible states is expanded to include D, E, F and G.
* Turn 3: Red bot already did N=2 moves when in state D, so it cannot make any more moves there. It can make moves when in state E, F and G, so states I, K and M are added to the list. Similarly, blue bot cannot make a move when in state G, but can when in D, E and F, so states H, J and L are added.
* Turn 4: Red bot already did N=2 moves when in states H, I and K, so it can only make moves when in J, L and M, so states P, R and S are added. Blue bot cannot make a move when in states J, L and M, but only when in H, I and K, so states N, O and Q are added.
Overall, there are 19 possible states of the game their algorithm needs to analyze.
<image> | instruction | 0 | 18,101 | 19 | 36,202 |
Tags: combinatorics, number theory
Correct Solution:
```
def f(n, mod=10**9+7):
ans = 1
for i in range(1, n + 1): ans = ans * i % mod
return ans
def g(n, mod=10**9+7):
num1 = f(n * 2)
den1 = f(n) ** 2 % mod
return num1 * pow(den1, mod - 2, mod) % mod
n = int(input()) + 1
print(g(n) - 1)
``` | output | 1 | 18,101 | 19 | 36,203 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Sasha and Ira are two best friends. But they aren’t just friends, they are software engineers and experts in artificial intelligence. They are developing an algorithm for two bots playing a two-player game. The game is cooperative and turn based. In each turn, one of the players makes a move (it doesn’t matter which player, it's possible that players turns do not alternate).
Algorithm for bots that Sasha and Ira are developing works by keeping track of the state the game is in. Each time either bot makes a move, the state changes. And, since the game is very dynamic, it will never go back to the state it was already in at any point in the past.
Sasha and Ira are perfectionists and want their algorithm to have an optimal winning strategy. They have noticed that in the optimal winning strategy, both bots make exactly N moves each. But, in order to find the optimal strategy, their algorithm needs to analyze all possible states of the game (they haven’t learned about alpha-beta pruning yet) and pick the best sequence of moves.
They are worried about the efficiency of their algorithm and are wondering what is the total number of states of the game that need to be analyzed?
Input
The first and only line contains integer N.
* 1 ≤ N ≤ 106
Output
Output should contain a single integer – number of possible states modulo 109 + 7.
Examples
Input
2
Output
19
Note
Start: Game is in state A.
* Turn 1: Either bot can make a move (first bot is red and second bot is blue), so there are two possible states after the first turn – B and C.
* Turn 2: In both states B and C, either bot can again make a turn, so the list of possible states is expanded to include D, E, F and G.
* Turn 3: Red bot already did N=2 moves when in state D, so it cannot make any more moves there. It can make moves when in state E, F and G, so states I, K and M are added to the list. Similarly, blue bot cannot make a move when in state G, but can when in D, E and F, so states H, J and L are added.
* Turn 4: Red bot already did N=2 moves when in states H, I and K, so it can only make moves when in J, L and M, so states P, R and S are added. Blue bot cannot make a move when in states J, L and M, but only when in H, I and K, so states N, O and Q are added.
Overall, there are 19 possible states of the game their algorithm needs to analyze.
<image> | instruction | 0 | 18,102 | 19 | 36,204 |
Tags: combinatorics, number theory
Correct Solution:
```
# https://codeforces.com/problemset/problem/575/H
import sys
import math
MOD = 1000000007
def inv(a, b):
if(a > 1):
return b-inv(b % a, a)*b//a
else:
return 1
def main():
# sys.stdin = open('E:\\Sublime\\in.txt', 'r')
# sys.stdout = open('E:\\Sublime\\out.txt', 'w')
# sys.stderr = open('E:\\Sublime\\err.txt', 'w')
n = int(sys.stdin.readline().strip())
# a, b = map(int, sys.stdin.readline().strip().split()[:2])
# C(n+1, 2n + 2) = (2n+2)! : (n+1)! : n+1!
# = (n+2)(n+3)...(2n+2) /
t = 1
m = 1
for i in range(1, n + 2):
t = (t * (n + i + 1)) % MOD
m = (m * i) % MOD
print(t * inv(m, MOD) % MOD - 1)
if __name__ == '__main__':
main()
# hajj
# ＿＿
# ／＞ フ
# | _ _ l
# ／` ミ＿xノ
# / |
# / ヽ ﾉ
# │ | | |
# ／￣| | | |
# | (￣ヽ＿_ヽ_)__)
# ＼二つ
``` | output | 1 | 18,102 | 19 | 36,205 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha and Ira are two best friends. But they aren’t just friends, they are software engineers and experts in artificial intelligence. They are developing an algorithm for two bots playing a two-player game. The game is cooperative and turn based. In each turn, one of the players makes a move (it doesn’t matter which player, it's possible that players turns do not alternate).
Algorithm for bots that Sasha and Ira are developing works by keeping track of the state the game is in. Each time either bot makes a move, the state changes. And, since the game is very dynamic, it will never go back to the state it was already in at any point in the past.
Sasha and Ira are perfectionists and want their algorithm to have an optimal winning strategy. They have noticed that in the optimal winning strategy, both bots make exactly N moves each. But, in order to find the optimal strategy, their algorithm needs to analyze all possible states of the game (they haven’t learned about alpha-beta pruning yet) and pick the best sequence of moves.
They are worried about the efficiency of their algorithm and are wondering what is the total number of states of the game that need to be analyzed?
Input
The first and only line contains integer N.
* 1 ≤ N ≤ 106
Output
Output should contain a single integer – number of possible states modulo 109 + 7.
Examples
Input
2
Output
19
Note
Start: Game is in state A.
* Turn 1: Either bot can make a move (first bot is red and second bot is blue), so there are two possible states after the first turn – B and C.
* Turn 2: In both states B and C, either bot can again make a turn, so the list of possible states is expanded to include D, E, F and G.
* Turn 3: Red bot already did N=2 moves when in state D, so it cannot make any more moves there. It can make moves when in state E, F and G, so states I, K and M are added to the list. Similarly, blue bot cannot make a move when in state G, but can when in D, E and F, so states H, J and L are added.
* Turn 4: Red bot already did N=2 moves when in states H, I and K, so it can only make moves when in J, L and M, so states P, R and S are added. Blue bot cannot make a move when in states J, L and M, but only when in H, I and K, so states N, O and Q are added.
Overall, there are 19 possible states of the game their algorithm needs to analyze.
<image>
Submitted Solution:
```
n = int(input())
m = 1000000007
print((pow(2, n+n, m) + n + n - 1) % m)
``` | instruction | 0 | 18,103 | 19 | 36,206 |
No | output | 1 | 18,103 | 19 | 36,207 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha and Ira are two best friends. But they aren’t just friends, they are software engineers and experts in artificial intelligence. They are developing an algorithm for two bots playing a two-player game. The game is cooperative and turn based. In each turn, one of the players makes a move (it doesn’t matter which player, it's possible that players turns do not alternate).
Algorithm for bots that Sasha and Ira are developing works by keeping track of the state the game is in. Each time either bot makes a move, the state changes. And, since the game is very dynamic, it will never go back to the state it was already in at any point in the past.
Sasha and Ira are perfectionists and want their algorithm to have an optimal winning strategy. They have noticed that in the optimal winning strategy, both bots make exactly N moves each. But, in order to find the optimal strategy, their algorithm needs to analyze all possible states of the game (they haven’t learned about alpha-beta pruning yet) and pick the best sequence of moves.
They are worried about the efficiency of their algorithm and are wondering what is the total number of states of the game that need to be analyzed?
Input
The first and only line contains integer N.
* 1 ≤ N ≤ 106
Output
Output should contain a single integer – number of possible states modulo 109 + 7.
Examples
Input
2
Output
19
Note
Start: Game is in state A.
* Turn 1: Either bot can make a move (first bot is red and second bot is blue), so there are two possible states after the first turn – B and C.
* Turn 2: In both states B and C, either bot can again make a turn, so the list of possible states is expanded to include D, E, F and G.
* Turn 3: Red bot already did N=2 moves when in state D, so it cannot make any more moves there. It can make moves when in state E, F and G, so states I, K and M are added to the list. Similarly, blue bot cannot make a move when in state G, but can when in D, E and F, so states H, J and L are added.
* Turn 4: Red bot already did N=2 moves when in states H, I and K, so it can only make moves when in J, L and M, so states P, R and S are added. Blue bot cannot make a move when in states J, L and M, but only when in H, I and K, so states N, O and Q are added.
Overall, there are 19 possible states of the game their algorithm needs to analyze.
<image>
Submitted Solution:
```
n = int(input()) + 1
from math import pi
print(int(4 ** n / (pi * n) ** 0.5) - 1)
``` | instruction | 0 | 18,104 | 19 | 36,208 |
No | output | 1 | 18,104 | 19 | 36,209 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha and Ira are two best friends. But they aren’t just friends, they are software engineers and experts in artificial intelligence. They are developing an algorithm for two bots playing a two-player game. The game is cooperative and turn based. In each turn, one of the players makes a move (it doesn’t matter which player, it's possible that players turns do not alternate).
Algorithm for bots that Sasha and Ira are developing works by keeping track of the state the game is in. Each time either bot makes a move, the state changes. And, since the game is very dynamic, it will never go back to the state it was already in at any point in the past.
Sasha and Ira are perfectionists and want their algorithm to have an optimal winning strategy. They have noticed that in the optimal winning strategy, both bots make exactly N moves each. But, in order to find the optimal strategy, their algorithm needs to analyze all possible states of the game (they haven’t learned about alpha-beta pruning yet) and pick the best sequence of moves.
They are worried about the efficiency of their algorithm and are wondering what is the total number of states of the game that need to be analyzed?
Input
The first and only line contains integer N.
* 1 ≤ N ≤ 106
Output
Output should contain a single integer – number of possible states modulo 109 + 7.
Examples
Input
2
Output
19
Note
Start: Game is in state A.
* Turn 1: Either bot can make a move (first bot is red and second bot is blue), so there are two possible states after the first turn – B and C.
* Turn 2: In both states B and C, either bot can again make a turn, so the list of possible states is expanded to include D, E, F and G.
* Turn 3: Red bot already did N=2 moves when in state D, so it cannot make any more moves there. It can make moves when in state E, F and G, so states I, K and M are added to the list. Similarly, blue bot cannot make a move when in state G, but can when in D, E and F, so states H, J and L are added.
* Turn 4: Red bot already did N=2 moves when in states H, I and K, so it can only make moves when in J, L and M, so states P, R and S are added. Blue bot cannot make a move when in states J, L and M, but only when in H, I and K, so states N, O and Q are added.
Overall, there are 19 possible states of the game their algorithm needs to analyze.
<image>
Submitted Solution:
```
import math
x= int(input())
mod = 10**9+7
res = math.factorial((x+1)*2)/math.factorial(x+1)**2-1
print(int(res)%mod)
``` | instruction | 0 | 18,105 | 19 | 36,210 |
No | output | 1 | 18,105 | 19 | 36,211 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Sasha and Ira are two best friends. But they aren’t just friends, they are software engineers and experts in artificial intelligence. They are developing an algorithm for two bots playing a two-player game. The game is cooperative and turn based. In each turn, one of the players makes a move (it doesn’t matter which player, it's possible that players turns do not alternate).
Algorithm for bots that Sasha and Ira are developing works by keeping track of the state the game is in. Each time either bot makes a move, the state changes. And, since the game is very dynamic, it will never go back to the state it was already in at any point in the past.
Sasha and Ira are perfectionists and want their algorithm to have an optimal winning strategy. They have noticed that in the optimal winning strategy, both bots make exactly N moves each. But, in order to find the optimal strategy, their algorithm needs to analyze all possible states of the game (they haven’t learned about alpha-beta pruning yet) and pick the best sequence of moves.
They are worried about the efficiency of their algorithm and are wondering what is the total number of states of the game that need to be analyzed?
Input
The first and only line contains integer N.
* 1 ≤ N ≤ 106
Output
Output should contain a single integer – number of possible states modulo 109 + 7.
Examples
Input
2
Output
19
Note
Start: Game is in state A.
* Turn 1: Either bot can make a move (first bot is red and second bot is blue), so there are two possible states after the first turn – B and C.
* Turn 2: In both states B and C, either bot can again make a turn, so the list of possible states is expanded to include D, E, F and G.
* Turn 3: Red bot already did N=2 moves when in state D, so it cannot make any more moves there. It can make moves when in state E, F and G, so states I, K and M are added to the list. Similarly, blue bot cannot make a move when in state G, but can when in D, E and F, so states H, J and L are added.
* Turn 4: Red bot already did N=2 moves when in states H, I and K, so it can only make moves when in J, L and M, so states P, R and S are added. Blue bot cannot make a move when in states J, L and M, but only when in H, I and K, so states N, O and Q are added.
Overall, there are 19 possible states of the game their algorithm needs to analyze.
<image>
Submitted Solution:
```
n = int(input())
i=0
buf = 0
while i <= 2*n:
buf+=2**i
i+=1
print(buf - (2*n*(2*n-1)))
``` | instruction | 0 | 18,106 | 19 | 36,212 |
No | output | 1 | 18,106 | 19 | 36,213 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob | instruction | 0 | 18,419 | 19 | 36,838 |
"Correct Solution:
```
x,y=list(map(int, input().split()))
if x==1:
x=14
if y==1:
y=14
if x>y:
print('Alice')
elif x<y:
print('Bob')
else:
print('Draw')
``` | output | 1 | 18,419 | 19 | 36,839 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob | instruction | 0 | 18,420 | 19 | 36,840 |
"Correct Solution:
```
a,b = map(int,input().split())
print("Draw" if a==b else "Bob" if (a+13)%15<(b+13)%15 else "Alice")
``` | output | 1 | 18,420 | 19 | 36,841 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob | instruction | 0 | 18,421 | 19 | 36,842 |
"Correct Solution:
```
a=[2,3,4,5,6,7,8,9,10,11,12,13,1]
b,c=map(int,input().split())
print('Draw' if c==b else('Alice' if a.index(b)>a.index(c)else'Bob'))
``` | output | 1 | 18,421 | 19 | 36,843 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob | instruction | 0 | 18,422 | 19 | 36,844 |
"Correct Solution:
```
A,B = map(int,input().split())
if A == B:
print("Draw")
elif A > B and B != 1 or A == 1:
print("Alice")
else:
print("Bob")
``` | output | 1 | 18,422 | 19 | 36,845 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob | instruction | 0 | 18,423 | 19 | 36,846 |
"Correct Solution:
```
a,b=map(int,input().split());n=13;x,y=(n-~-a)%n,(n-~-b)%n;print('Draw' if x==y else ['Alice','Bob'][x>y])
``` | output | 1 | 18,423 | 19 | 36,847 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob | instruction | 0 | 18,424 | 19 | 36,848 |
"Correct Solution:
```
a, b = map(int, input().split())
if a == b:
print('Draw')
elif a == 1 or 2 <= b < a <= 13:
print('Alice')
else:
print('Bob')
``` | output | 1 | 18,424 | 19 | 36,849 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob | instruction | 0 | 18,425 | 19 | 36,850 |
"Correct Solution:
```
a,b=map(int,input().split())
if a==1:a=14
if b==1:b=14
if a>b:s="Alice"
elif a<b:s="Bob"
else:s="Draw"
print(s)
``` | output | 1 | 18,425 | 19 | 36,851 |
Provide a correct Python 3 solution for this coding contest problem.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob | instruction | 0 | 18,426 | 19 | 36,852 |
"Correct Solution:
```
a, b = map(int, input().split())
print('Draw' if a == b else 'Alice' if (a+12) % 14 > (b+12) % 14 else 'Bob')
``` | output | 1 | 18,426 | 19 | 36,853 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob
Submitted Solution:
```
a,b=map(int,input().split())
a=14 if a==1 else a
b=14 if b==1 else b
print('Draw' if a==b else 'Bob' if b>a else 'Alice')
``` | instruction | 0 | 18,427 | 19 | 36,854 |
Yes | output | 1 | 18,427 | 19 | 36,855 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob
Submitted Solution:
```
A,B=map(int,input().split())
if A==1:A+=13
if B==1:B+=13
print("Alice" if A>B else ("Bob"if A<B else "Draw"))
``` | instruction | 0 | 18,428 | 19 | 36,856 |
Yes | output | 1 | 18,428 | 19 | 36,857 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob
Submitted Solution:
```
a,b=map(int,input().split())
if a==b: print("Draw")
elif a==1: print("Alice")
elif b==1: print("Bob")
else: print(["Alice","Bob"][a<b])
``` | instruction | 0 | 18,429 | 19 | 36,858 |
Yes | output | 1 | 18,429 | 19 | 36,859 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob
Submitted Solution:
```
a,b=map(int,input().split())
if (a-2)%13 > (b-2)%13:
print("Alice")
elif a == b:
print("Draw")
else:
print("Bob")
``` | instruction | 0 | 18,430 | 19 | 36,860 |
Yes | output | 1 | 18,430 | 19 | 36,861 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob
Submitted Solution:
```
n = list(map(int, input().split))
a = n[0]
b = n[1]
if a == b:
print("Draw")
elif a == 1:
print("Alice")
elif b == 1:
print("Bob")
elif a > b:
print("Alice")
elif b > a:
print("Bob")
``` | instruction | 0 | 18,431 | 19 | 36,862 |
No | output | 1 | 18,431 | 19 | 36,863 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob
Submitted Solution:
```
a, b = map(int, input().split())
if a < b:
ans = 'Bob'
elif a == b:
ans = 'Draw'
else:
a > b:
ans = 'Alice'
print(ans)
``` | instruction | 0 | 18,432 | 19 | 36,864 |
No | output | 1 | 18,432 | 19 | 36,865 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob
Submitted Solution:
```
A,B = map(int, input().split())
if A == B:
print("Draw")
elif A < B and A != 1:
print("Bob")
elif B < A and B != 1:
print("Alice")
elif A < B and A==1:
print("Alice")
elif B < A and A==1:
print("Bob")
``` | instruction | 0 | 18,433 | 19 | 36,866 |
No | output | 1 | 18,433 | 19 | 36,867 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alice and Bob are playing One Card Poker.
One Card Poker is a two-player game using playing cards.
Each card in this game shows an integer between `1` and `13`, inclusive.
The strength of a card is determined by the number written on it, as follows:
Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong
One Card Poker is played as follows:
1. Each player picks one card from the deck. The chosen card becomes the player's hand.
2. The players reveal their hands to each other. The player with the stronger card wins the game.
If their cards are equally strong, the game is drawn.
You are watching Alice and Bob playing the game, and can see their hands.
The number written on Alice's card is A, and the number written on Bob's card is B.
Write a program to determine the outcome of the game.
Constraints
* 1≦A≦13
* 1≦B≦13
* A and B are integers.
Input
The input is given from Standard Input in the following format:
A B
Output
Print `Alice` if Alice will win. Print `Bob` if Bob will win. Print `Draw` if the game will be drawn.
Examples
Input
8 6
Output
Alice
Input
1 1
Output
Draw
Input
13 1
Output
Bob
Submitted Solution:
```
a,b=map(int,input().split())
if a>b:
print('Alice')
elif a<b:
print('Bob')
else:
print('Draw')
``` | instruction | 0 | 18,434 | 19 | 36,868 |
No | output | 1 | 18,434 | 19 | 36,869 |
Provide a correct Python 3 solution for this coding contest problem.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO | instruction | 0 | 18,451 | 19 | 36,902 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
"""
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0060
"""
import sys
def calc_possibility(open_cards):
cards = [x for x in range(1, 11)]
c1, c2, c3 = open_cards
my_total = c1 + c2
cards.remove(c1)
cards.remove(c2)
cards.remove(c3)
combinations = 0
hit = 0
for c in cards:
combinations += 1
if my_total + c <= 20:
hit += 1
# print('{}/{}'.format(hit, combinations))
return (hit / combinations >= 0.5)
def main(args):
for line in sys.stdin:
open_cards = [int(x) for x in line.strip().split(' ')]
if calc_possibility(open_cards):
print('YES')
else:
print('NO')
if __name__ == '__main__':
main(sys.argv[1:])
``` | output | 1 | 18,451 | 19 | 36,903 |
Provide a correct Python 3 solution for this coding contest problem.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO | instruction | 0 | 18,452 | 19 | 36,904 |
"Correct Solution:
```
# -*- coding: utf-8 -*-
import sys
import os
for s in sys.stdin:
C1, C2, C3 = map(int, s.split())
cards = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
cards.remove(C1)
cards.remove(C2)
cards.remove(C3)
capacity = 20 - C1 - C2
want_cards = [card for card in cards if card <= capacity]
if len(want_cards) / len(cards) >= 0.5:
print('YES')
else:
print('NO')
``` | output | 1 | 18,452 | 19 | 36,905 |
Provide a correct Python 3 solution for this coding contest problem.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO | instruction | 0 | 18,453 | 19 | 36,906 |
"Correct Solution:
```
import sys
def shu(j):
t=list(set((range(1,11)))-set(j))
if sum([1 for i in t if sum(j[:2])+i<=20])/len(t)>0.5:
return "YES"
else:
return "NO"
[print(shu(i)) for i in [list(map(int,l.split())) for l in sys.stdin]]
``` | output | 1 | 18,453 | 19 | 36,907 |
Provide a correct Python 3 solution for this coding contest problem.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO | instruction | 0 | 18,454 | 19 | 36,908 |
"Correct Solution:
```
while True:
try:
c1, c2, c3 = map(int, input().split())
except:
break
N = list(range(1,11))
N.remove(c1)
N.remove(c2)
N.remove(c3)
y = 0
n = 0
for i in range(7):
S = c1 + c2 + N[i]
if S<=20:
y += 1
if 20<S:
n += 1
j = y/(y+n)
if 0.5<=j:
print('YES')
else:
print('NO')
``` | output | 1 | 18,454 | 19 | 36,909 |
Provide a correct Python 3 solution for this coding contest problem.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO | instruction | 0 | 18,455 | 19 | 36,910 |
"Correct Solution:
```
while 1:
try:
number=[1,2,3,4,5,6,7,8,9,10]
C1,C2,C3=map(int,input().split())
number.remove(C1)
number.remove(C2)
number.remove(C3)
my_sum=C1+C2
count=0
for i in number:
if my_sum+i>20:
count +=1
if count/len(number)<0.5:print("YES")
else:print("NO")
except:break
``` | output | 1 | 18,455 | 19 | 36,911 |
Provide a correct Python 3 solution for this coding contest problem.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO | instruction | 0 | 18,456 | 19 | 36,912 |
"Correct Solution:
```
import sys
for x in sys.stdin:
a,b,c=map(int,x.split())
print(['YES','NO'][len({*range(1,21-a-b)}-{a,b,c})<3.5])
``` | output | 1 | 18,456 | 19 | 36,913 |
Provide a correct Python 3 solution for this coding contest problem.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO | instruction | 0 | 18,457 | 19 | 36,914 |
"Correct Solution:
```
while 1:
try:
n=list(map(int,input().split()))
card=[1,2,3,4,5,6,7,8,9,10]
if sum(n[0:2])<11:
print("YES")
else:
card.remove(n[0])
card.remove(n[1])
card.remove(n[2])
margin=20-sum(n[0:2])
if card[3]<=margin:
print("YES")
else:
print("NO")
except:break
``` | output | 1 | 18,457 | 19 | 36,915 |
Provide a correct Python 3 solution for this coding contest problem.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO | instruction | 0 | 18,458 | 19 | 36,916 |
"Correct Solution:
```
while True:
try:
a, b, c = map(int, input().split())
except:
break
l=[True] * 11
l[a] = l[b] = l[c] = False
sum = a + b
over = 0
for i in range(1,11):
if l[i]:
if sum + i > 20:
over += 1
if over / 7 < 0.5:
print("YES")
else:
print("NO")
``` | output | 1 | 18,458 | 19 | 36,917 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO
Submitted Solution:
```
while(1):
try:
c1,c2,c3 = [int(i) for i in input().split()]
tot = [i for i in range(1,11)]
tot.remove(c1);tot.remove(c2),tot.remove(c3)
tot = [i + c1+c2 for i in tot]
count = [1 if i <= 20 else 0 for i in tot]
if sum(count) > 3:
print("YES")
else:
print("NO")
except EOFError:
break
``` | instruction | 0 | 18,459 | 19 | 36,918 |
Yes | output | 1 | 18,459 | 19 | 36,919 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO
Submitted Solution:
```
import sys
for line in sys.stdin.readlines():
c1,c2,c3 = line.split()
c1,c2,c3 = int(c1),int(c2),int(c3)
l = [i for i in range(1,11) if i != c1 and i != c2 and i != c3]
s = c1 + c2
count = 0
for i in l:
if s + i <= 20:
count += 1
if count >= 4:
print('YES')
else:
print('NO')
``` | instruction | 0 | 18,460 | 19 | 36,920 |
Yes | output | 1 | 18,460 | 19 | 36,921 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO
Submitted Solution:
```
while True:
try:
Clst = list(map(int, input().split()))
mynum = 21 - (Clst[0] + Clst[1])
a = list(range(1, min(11, mynum)))
for i in Clst:
if i in a:
a.remove(i)
if len(a)/7 >= 0.5 :
print('YES')
else:
print('NO')
except EOFError:
break
``` | instruction | 0 | 18,461 | 19 | 36,922 |
Yes | output | 1 | 18,461 | 19 | 36,923 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO
Submitted Solution:
```
#表 数字
#裏 白紙
#「1～10」のカードで同じカードは引けない
def judge(c1,c2,c3):
num=[i for i in range(1,11) if i!=c1 or i!=c2 or i!=c3]
if c1+c2<=14:
return True
elif c1+c2>=17:
return False
tmp=0
for x in range(20-c1-c2,0,-1):
if x in num:
tmp+=1
if tmp>=4:
return True
return False
while True:
try:
c1,c2,c3=map(int,input().split())
except EOFError:
break
if judge(c1,c2,c3)==True:
print("YES")
else:
print("NO")
``` | instruction | 0 | 18,462 | 19 | 36,924 |
Yes | output | 1 | 18,462 | 19 | 36,925 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO
Submitted Solution:
```
while True:
try: c1, c2, c3 = list(map(int,input().split()))
except: break
countw = 0
deck = [i for i in range(1,11) if i != c1 and i != c2 and i != c3]
for i in range(len(deck)):
eq = 0
eq = c1 + c2 + deck[i]
if eq > 20:
break
countw +=1
print(["YES","NO"][countw <=4])
``` | instruction | 0 | 18,463 | 19 | 36,926 |
No | output | 1 | 18,463 | 19 | 36,927 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO
Submitted Solution:
```
while True:
try:
a, b, c = map(int, input().split())
except:
break
l=[True] * 11
l[a] = l[b] = l[c] = False
sum = a + b
over = 0
for i in range(1,11):
if l[i]:
if sum + i > 20:
print(i)
over += 1
if over / 7 <= 0.5:
print("YES")
else:
print("NO")
``` | instruction | 0 | 18,464 | 19 | 36,928 |
No | output | 1 | 18,464 | 19 | 36,929 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO
Submitted Solution:
```
import sys
for x in sys.stdin:
a,b,c=list(map(int,x.split()))
print(['YES','NO'][len(set(range(1,21-sum(a,b)))-{a,b,c})/7<.5])
``` | instruction | 0 | 18,465 | 19 | 36,930 |
No | output | 1 | 18,465 | 19 | 36,931 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is one card each with the numbers from "1" to "10", for a total of 10 cards. This card has numbers on the front and nothing on the back. Using this card, you and your opponent will play the game according to the following rules.
1. You and your opponent are dealt a total of two cards, one face up and one back up. You can see the numbers on the front card of your opponent, but not the numbers on the back card.
2. You win when the total number of cards dealt is 20 or less and greater than the total number of your opponent. For example, if your card is "7" "8" (15 total) and your opponent's card is "9" "10" (19 total), your opponent wins.
3. You and your opponent can draw up to one more card. You don't have to pull it.
Now, as a guide to deciding whether to draw one more card, consider the probability that the total will be 20 or less when you draw a card, and if that probability is 50% or more, draw a card. When calculating this probability, you can use the information of your two cards and the card on the opponent's table for a total of three cards. In other words, you don't draw those cards because you only have one for each card.
A program that reads your two cards and your opponent's front card, and outputs YES if there is a 50% or greater probability that the total will be 20 or less when you draw one more card, otherwise it will output NO. Please create.
Input
The input consists of multiple datasets. Given that the number on your first card is C1, the number on your second card is C2, and the number on your opponent's face card is C3, each dataset is given in the following format: ..
C1 C2 C3
Output
Print YES or NO on one line for each dataset.
Example
Input
1 2 3
5 6 9
8 9 10
Output
YES
YES
NO
Submitted Solution:
```
while True:
try:
a, b, c = map(int, input().split())
except:
break
l=[True] * 11
l[a] = l[b] = l[c] = False
sum = a + b
over = 0
for i in range(1,11):
if l[i]:
if sum + i >= 20:
over += 1
if over / 7 < 0.5:
print("YES")
else:
print("NO")
``` | instruction | 0 | 18,466 | 19 | 36,932 |
No | output | 1 | 18,466 | 19 | 36,933 |
Provide a correct Python 3 solution for this coding contest problem.
Ikta, who hates to lose, has recently been enthusiastic about playing games using the Go board. However, neither Go nor Gomoku can beat my friends at all, so I decided to give a special training to the lesser-known game Phutball.
This game is a difficult game, so I decided to give special training so that I could win my turn and decide if I could finish it.
The conditions for winning the game are as follows.
* Shiraishi cannot jump to the place where Kuroishi is placed.
* Use the 19 x 15 part in the center of the board.
* The board for which you want to judge the victory conditions is given with one white stone and several black stones.
* The goal point is the lower end of the board or the lower side. (See the figure below.)
* If you bring Shiraishi to the goal point, you will win.
* To win, do the following:
* Shiraishi can make one or more jumps.
* Jumping can be done by jumping over any of the eight directions (up, down, left, right, diagonally above, diagonally below) adjacent to Shiraishi.
* It is not possible to jump in a direction where Kuroishi is not adjacent.
* The jumped Kuroishi is removed from the board for each jump.
* After jumping, Shiraishi must be at the goal point or on the game board.
* Even if there are two or more Kuroishi in a row, you can jump just across them.
* Shiraishi cannot jump to the place where Kuroishi is placed. (Kuroishi that is continuous in the direction of jump must be jumped over.)
<image>
It is possible to jump to the places marked with circles in the figure, all of which are goal points, but since the places marked with crosses are neither the goal points nor the inside of the board, it is not possible to jump.
Your job is to help Ikta write a program to determine if you can reach the goal and to find the minimum number of jumps to reach the goal.
Input
A 19 x 15 board composed of .OX is given in 19 lines. Each line always consists of 15 characters, and each character represents the following:
* "." Represents a blank.
* "O" stands for Shiraishi.
* "X" stands for Kuroishi.
Constraints
* The number of black stones is 20 or less.
* There is always only one Shiraishi.
* The state that has already been reached will not be entered.
Output
Goal If possible, output the shortest effort on one line. If it is impossible to reach the goal, output -1.
Examples
Input
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
......O........
......X........
Output
1
Input
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
......O........
...............
Output
-1
Input
...............
...............
...............
...............
...............
...............
...............
...............
...........O...
............X..
.............X.
.............X.
.............X.
...............
..............X
.........X.....
.............X.
......X....X..X
.....X.X.XX.X..
Output
6
Input
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
.....XX........
.....XXXO......
......X........
Output
4 | instruction | 0 | 18,523 | 19 | 37,046 |
"Correct Solution:
```
def main():
N = 20; M = 15
MP = [[-1]*M for i in range(N)]
L = 0
for i in range(N-1):
s = input()
for j in range(M):
c = s[j]
if c == 'O':
sx = j; sy = i
elif c == 'X':
MP[i][j] = L
L += 1
dd = ((-1, 0), (-1, -1), (0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1))
INF = 30
D = {}
def dfs(state, x, y):
key = (state, x, y)
if key in D:
return D[key]
if y >= N-2:
return 0
r = INF
for dx, dy in dd:
nx = x + dx; ny = y + dy
if not 0 <= nx < M or not 0 <= ny < N:
continue
k = MP[ny][nx]
if k == -1 or state & (1 << k) == 0:
continue
n_state = state ^ (1 << k)
nx += dx; ny += dy
while 0 <= nx < M and 0 <= ny < N:
k = MP[ny][nx]
if k == -1 or state & (1 << k) == 0:
break
n_state ^= (1 << k)
nx += dx; ny += dy
else:
if (nx == -1 or nx == M) and ny == N-1:
return 1
continue
r = min(r, dfs(n_state, nx, ny) + 1)
D[key] = r
return D[key]
r = dfs(2**L-1, sx, sy)
print(r if r < INF else -1)
main()
``` | output | 1 | 18,523 | 19 | 37,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ikta, who hates to lose, has recently been enthusiastic about playing games using the Go board. However, neither Go nor Gomoku can beat my friends at all, so I decided to give a special training to the lesser-known game Phutball.
This game is a difficult game, so I decided to give special training so that I could win my turn and decide if I could finish it.
The conditions for winning the game are as follows.
* Shiraishi cannot jump to the place where Kuroishi is placed.
* Use the 19 x 15 part in the center of the board.
* The board for which you want to judge the victory conditions is given with one white stone and several black stones.
* The goal point is the lower end of the board or the lower side. (See the figure below.)
* If you bring Shiraishi to the goal point, you will win.
* To win, do the following:
* Shiraishi can make one or more jumps.
* Jumping can be done by jumping over any of the eight directions (up, down, left, right, diagonally above, diagonally below) adjacent to Shiraishi.
* It is not possible to jump in a direction where Kuroishi is not adjacent.
* The jumped Kuroishi is removed from the board for each jump.
* After jumping, Shiraishi must be at the goal point or on the game board.
* Even if there are two or more Kuroishi in a row, you can jump just across them.
* Shiraishi cannot jump to the place where Kuroishi is placed. (Kuroishi that is continuous in the direction of jump must be jumped over.)
<image>
It is possible to jump to the places marked with circles in the figure, all of which are goal points, but since the places marked with crosses are neither the goal points nor the inside of the board, it is not possible to jump.
Your job is to help Ikta write a program to determine if you can reach the goal and to find the minimum number of jumps to reach the goal.
Input
A 19 x 15 board composed of .OX is given in 19 lines. Each line always consists of 15 characters, and each character represents the following:
* "." Represents a blank.
* "O" stands for Shiraishi.
* "X" stands for Kuroishi.
Constraints
* The number of black stones is 20 or less.
* There is always only one Shiraishi.
* The state that has already been reached will not be entered.
Output
Goal If possible, output the shortest effort on one line. If it is impossible to reach the goal, output -1.
Examples
Input
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
......O........
......X........
Output
1
Input
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
......O........
...............
Output
-1
Input
...............
...............
...............
...............
...............
...............
...............
...............
...........O...
............X..
.............X.
.............X.
.............X.
...............
..............X
.........X.....
.............X.
......X....X..X
.....X.X.XX.X..
Output
6
Input
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
.....XX........
.....XXXO......
......X........
Output
4
Submitted Solution:
```
INF = 100
mp = [list("#" * 17)] + [list("#" + input() + "#") for _ in range(19)] + [list("G" * 17)]
for y in range(1, 20):
for x in range(1, 16):
if mp[y][x] == "O":
sx, sy = x, y
mp[y][x] = "."
for x in range(17):
if mp[19][x] != "X":mp[19][x] = "G"
vec = ((1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0), (-1, 1), (0, 1), (1, 1))
ans = INF
def search(x, y, score):
global ans
if score >= ans:return
for dx, dy in vec:
nx, ny = x, y
use = []
while mp[ny + dy][nx + dx] == "X":
nx += dx
ny += dy
use.append((nx, ny))
if not use:continue
if mp[ny + dy][nx + dx] == "G":
ans = score + 1
return
if mp[ny + dy][nx + dx] == "#":
continue
if mp[ny + dy][nx + dx] == ".":
for ux, uy in use:
mp[uy][ux] = "."
search(nx + dx, ny + dy, score + 1)
for ux, uy in use:
mp[uy][ux] = "X"
search(sx, sy, 0)
if ans == INF:print(-1)
else:print(ans)
``` | instruction | 0 | 18,524 | 19 | 37,048 |
No | output | 1 | 18,524 | 19 | 37,049 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ikta, who hates to lose, has recently been enthusiastic about playing games using the Go board. However, neither Go nor Gomoku can beat my friends at all, so I decided to give a special training to the lesser-known game Phutball.
This game is a difficult game, so I decided to give special training so that I could win my turn and decide if I could finish it.
The conditions for winning the game are as follows.
* Shiraishi cannot jump to the place where Kuroishi is placed.
* Use the 19 x 15 part in the center of the board.
* The board for which you want to judge the victory conditions is given with one white stone and several black stones.
* The goal point is the lower end of the board or the lower side. (See the figure below.)
* If you bring Shiraishi to the goal point, you will win.
* To win, do the following:
* Shiraishi can make one or more jumps.
* Jumping can be done by jumping over any of the eight directions (up, down, left, right, diagonally above, diagonally below) adjacent to Shiraishi.
* It is not possible to jump in a direction where Kuroishi is not adjacent.
* The jumped Kuroishi is removed from the board for each jump.
* After jumping, Shiraishi must be at the goal point or on the game board.
* Even if there are two or more Kuroishi in a row, you can jump just across them.
* Shiraishi cannot jump to the place where Kuroishi is placed. (Kuroishi that is continuous in the direction of jump must be jumped over.)
<image>
It is possible to jump to the places marked with circles in the figure, all of which are goal points, but since the places marked with crosses are neither the goal points nor the inside of the board, it is not possible to jump.
Your job is to help Ikta write a program to determine if you can reach the goal and to find the minimum number of jumps to reach the goal.
Input
A 19 x 15 board composed of .OX is given in 19 lines. Each line always consists of 15 characters, and each character represents the following:
* "." Represents a blank.
* "O" stands for Shiraishi.
* "X" stands for Kuroishi.
Constraints
* The number of black stones is 20 or less.
* There is always only one Shiraishi.
* The state that has already been reached will not be entered.
Output
Goal If possible, output the shortest effort on one line. If it is impossible to reach the goal, output -1.
Examples
Input
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
......O........
......X........
Output
1
Input
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
......O........
...............
Output
-1
Input
...............
...............
...............
...............
...............
...............
...............
...............
...........O...
............X..
.............X.
.............X.
.............X.
...............
..............X
.........X.....
.............X.
......X....X..X
.....X.X.XX.X..
Output
6
Input
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
.....XX........
.....XXXO......
......X........
Output
4
Submitted Solution:
```
INF = 100
mp = [list("#" * 17)] + [list("#" + input() + "#") for _ in range(19)] + [list("G" * 17)]
for y in range(1, 20):
for x in range(1, 16):
if mp[y][x] == "O":
sx, sy = x, y
mp[y][x] = "."
vec = ((1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0), (-1, 1), (0, 1), (1, 1))
ans = INF
def search(x, y, score):
global ans
if score >= ans:return
for dx, dy in vec:
nx, ny = x, y
use = []
while mp[ny + dy][nx + dx] == "X":
nx += dx
ny += dy
use.append((nx, ny))
if mp[ny + dy][nx + dx] == "G":
ans = score + 1
return
if mp[ny + dy][nx + dx] == "#":
continue
if mp[ny + dy][nx + dx] == "." and use:
for ux, uy in use:
mp[uy][ux] = "."
search(nx + dx, ny + dy, score + 1)
for ux, uy in use:
mp[uy][ux] = "X"
search(sx, sy, 0)
if ans == INF:print(-1)
else:print(ans)
``` | instruction | 0 | 18,525 | 19 | 37,050 |
No | output | 1 | 18,525 | 19 | 37,051 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Ikta, who hates to lose, has recently been enthusiastic about playing games using the Go board. However, neither Go nor Gomoku can beat my friends at all, so I decided to give a special training to the lesser-known game Phutball.
This game is a difficult game, so I decided to give special training so that I could win my turn and decide if I could finish it.
The conditions for winning the game are as follows.
* Shiraishi cannot jump to the place where Kuroishi is placed.
* Use the 19 x 15 part in the center of the board.
* The board for which you want to judge the victory conditions is given with one white stone and several black stones.
* The goal point is the lower end of the board or the lower side. (See the figure below.)
* If you bring Shiraishi to the goal point, you will win.
* To win, do the following:
* Shiraishi can make one or more jumps.
* Jumping can be done by jumping over any of the eight directions (up, down, left, right, diagonally above, diagonally below) adjacent to Shiraishi.
* It is not possible to jump in a direction where Kuroishi is not adjacent.
* The jumped Kuroishi is removed from the board for each jump.
* After jumping, Shiraishi must be at the goal point or on the game board.
* Even if there are two or more Kuroishi in a row, you can jump just across them.
* Shiraishi cannot jump to the place where Kuroishi is placed. (Kuroishi that is continuous in the direction of jump must be jumped over.)
<image>
It is possible to jump to the places marked with circles in the figure, all of which are goal points, but since the places marked with crosses are neither the goal points nor the inside of the board, it is not possible to jump.
Your job is to help Ikta write a program to determine if you can reach the goal and to find the minimum number of jumps to reach the goal.
Input
A 19 x 15 board composed of .OX is given in 19 lines. Each line always consists of 15 characters, and each character represents the following:
* "." Represents a blank.
* "O" stands for Shiraishi.
* "X" stands for Kuroishi.
Constraints
* The number of black stones is 20 or less.
* There is always only one Shiraishi.
* The state that has already been reached will not be entered.
Output
Goal If possible, output the shortest effort on one line. If it is impossible to reach the goal, output -1.
Examples
Input
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
......O........
......X........
Output
1
Input
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
......O........
...............
Output
-1
Input
...............
...............
...............
...............
...............
...............
...............
...............
...........O...
............X..
.............X.
.............X.
.............X.
...............
..............X
.........X.....
.............X.
......X....X..X
.....X.X.XX.X..
Output
6
Input
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
...............
.....XX........
.....XXXO......
......X........
Output
4
Submitted Solution:
```
INF = 100
mp = [list("#" * 17)] + [list("#" + input() + "#") for _ in range(19)] + [list("G" * 17)]
for y in range(1, 20):
for x in range(1, 16):
if mp[y][x] == "O":
sx, sy = x, y
mp[y][x] = "."
for x in range(1, 16):
if mp[19][x] != "X":mp[19][x] = "G"
vec = ((1, 0), (1, -1), (0, -1), (-1, -1), (-1, 0), (-1, 1), (0, 1), (1, 1))
ans = INF
def search(x, y, score):
global ans
if score >= ans:return
for dx, dy in vec:
nx, ny = x, y
use = []
while mp[ny + dy][nx + dx] == "X":
nx += dx
ny += dy
use.append((nx, ny))
if not use:continue
if mp[ny + dy][nx + dx] == "G":
ans = score + 1
return
if mp[ny + dy][nx + dx] == "#":
continue
if mp[ny + dy][nx + dx] == ".":
for ux, uy in use:
mp[uy][ux] = "." if uy < 19 else "G"
search(nx + dx, ny + dy, score + 1)
for ux, uy in use:
mp[uy][ux] = "X"
search(sx, sy, 0)
if ans == INF:print(-1)
else:print(ans)
``` | instruction | 0 | 18,526 | 19 | 37,052 |
No | output | 1 | 18,526 | 19 | 37,053 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.