problem_id
stringlengths 6
6
| user_id
stringlengths 10
10
| time_limit
float64 1k
8k
| memory_limit
float64 262k
1.05M
| problem_description
stringlengths 48
1.55k
| codes
stringlengths 35
98.9k
| status
stringlengths 28
1.7k
| submission_ids
stringlengths 28
1.41k
| memories
stringlengths 13
808
| cpu_times
stringlengths 11
610
| code_sizes
stringlengths 7
505
|
|---|---|---|---|---|---|---|---|---|---|---|
p03803 | u557523358 | 2,000 | 262,144 | 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. | ["a, b = ((int(x) - 2) % 100 for x in input().split())\nprint('Draw' if a == b else 'Alice' a > b else 'Bob')", "a, b = ((int(x) - 2) % 100 for x in input().split())\nprint('Draw' if a == b else 'Alice' if a > b else 'Bob')"] | ['Runtime Error', 'Accepted'] | ['s286218796', 's659696382'] | [2940.0, 2940.0] | [17.0, 17.0] | [106, 109] |
p03803 | u558059388 | 2,000 | 262,144 | 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. | ['1<=A<=13\n1<=B<=13\n\nif A > B >=2 or A=1 ,B >= 2 :\n print(Alice)\nelif B > A =2 or B=1 ,A >= 2:\n print(Bob)\nelif A = B:\n print(Draw)\n ', "A,B=(int(x) forx in input.split())\nif A=1:\n A==14\nif B=1:\n B==14\nif A>B:\n print('Alice')\nelif B>A:\n print('Bob')\nelse:\n ('Drow')", "A,B=[int(x) for in x input().split()]\nif A=1:\n A==14\nif B=1:\n B==14\nif A>B:\n print('Alice')\nelif B>A:\n print('Bob')\nelse:\n print('Drow')", "A,B=[int(x) for in x input().split()]\nif A==1:\n A=14\nif B==1:\n B=14\nif A>B:\n print('Alice')\nelif B>A:\n print('Bob')\nelse:\n print('Drow')", "A,B=[int(x) for x in input().split()]\nif A==1:\n A=14\nif B==1:\n B=14\nif A>B:\n print('Alice')\nelif B>A:\n print('Bob')\nelse:\n print('Draw')"] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s159405806', 's291054267', 's506161700', 's830252297', 's223129833'] | [2940.0, 2940.0, 2940.0, 2940.0, 3064.0] | [18.0, 17.0, 17.0, 17.0, 17.0] | [137, 133, 141, 141, 141] |
p03803 | u558836062 | 2,000 | 262,144 | 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. | ['N,M = map(int,input().split())\n\nA = ""\nB = ""\n\nfor i in range(N):\n\tA += input()\n\n\n\nfor i in range(M):\n\tif i % 2 == 0:\n\t\tB += input()\n\telse:\n\t\tB += input()[::-1]\n\nif B in A:\n\tprint("Yes")\nelse:\n\tprint("No")', "\n\nA,B = map(int,input().split())\n\nif A == 1 and B != 1:\n\tprint('Alice')\n\texit()\n\nif B == 1 and A != 1 :\n\tprint('Bob')\n\texit()\nif A > B:\n\tprint('Alice')\n\texit()\n\t\nif B > A:\n\tprint('Bob')\n\texit()\n\nif A == B:\n\tprint('Draw')\n\texit()"] | ['Runtime Error', 'Accepted'] | ['s980799779', 's317419508'] | [3060.0, 2940.0] | [18.0, 17.0] | [205, 228] |
p03803 | u559416752 | 2,000 | 262,144 | 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. | ["a, b = map(int, input().split())\nif a == 1 or b == 1:\n if a == b:\n print('Draw')\n elif a == 1:\n print('Alice')\n elif b == 1:\n print('Bob')\nelse:\n if a == b:\n print('Draw')\n elif a == 1:\n print('Alice')\n elif b == 1:\n print('Bob')", "a, b = map(int, input().split())\nif a == 1 or b == 1:\n if a == b:\n print('Draw')\n elif a == 1:\n print('Alice')\n elif b == 1:\n print('Bob')\nelse:\n if a == b:\n print('Draw')\n elif a > b:\n print('Alice')\n elif b > a:\n \tprint('Bob')"] | ['Wrong Answer', 'Accepted'] | ['s926636529', 's741880198'] | [3060.0, 3060.0] | [21.0, 17.0] | [289, 287] |
p03803 | u560988566 | 2,000 | 262,144 | 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. | ['a,b = map(int, input().split())\nif a == 1:\n if b == 1:\n print("Draw")\n exit()\n else:\n \tprint("Alice")\n exit()\nelse:\n if a == b:\n print("Draw")\n exit()\n elif a > b:\n print("Alice")\n exit()\n else:\n print("Bob")\n exit()', 'a,b = map(int, input().split())\nif a == 1:\n if b == 1:\n print("Draw")\n else:\n print("Alice")\nelse:\n if a == b:\n print("Draw")\n elif b == 1:\n print("Bob")\n elif a > b:\n print("Alice")\n else:\n print("Bob")'] | ['Runtime Error', 'Accepted'] | ['s952554312', 's127928860'] | [2940.0, 2940.0] | [17.0, 17.0] | [249, 263] |
p03803 | u581603131 | 2,000 | 262,144 | 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. | ["A, B = map(int, input().split())\nprint('Alice' if A>B or A==1 and B==2 elif A==B 'Draw' else 'Bob')", "A, B = map(int, input().split())\nprint('Alice' if A>B or A==1 and B==2 else 'Draw' if A==B 'Bob')", "A, B = map(int, input().split())\nprint('Alice' if A>B or A==1 and B==2 else 'Draw' if A==B 'Bob')", "A, B = map(int, input().split())\nprint('Alice' if A>B or A==1 and B==2 'Draw' if A==B 'Bob')", "A, B = map(int, input().split()) \nif A==B:\n print('Draw')\nelif A==1:\n print('Alice')\nelif B==1:\n print('Bob')\nelif A>B:\n print('Alice')\nelse:\n print('Bob')"] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s365203193', 's751729629', 's850916108', 's998956082', 's102131474'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [18.0, 17.0, 17.0, 17.0, 17.0] | [99, 97, 97, 92, 170] |
p03803 | u583631641 | 2,000 | 262,144 | 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. | ['n,m = map(int,input().split())\na = [input() for i in range(n)]\nb = [input() for i in range(m)]\n\ndef check(i,j):\n for row in range(m):\n for col in range(m):\n if a[row + i][col + j] == b[row][col]:\n return True\n\n return False\nfor i in range(n-m+1):\n for j in range(n-m+1):\n if check(i,j):\n print("Yes")\n exit()\n\n\nprint("No")\n', 'A,B = map(int,input().split())\n\n\nif A == 1 or B == 1:\n if A == B:\n print("Draw")\n exit()\n elif A == 1 and A < B:\n print("Alice")\n exit()\n elif B == 1 and B < A:\n print("Bob")\n exit()\n\nif A < B :\n print("Bob")\nelif A > B:\n print("Alice")\nelse :\n print("Draw")\n'] | ['Runtime Error', 'Accepted'] | ['s583914906', 's294572579'] | [3060.0, 3060.0] | [17.0, 18.0] | [394, 319] |
p03803 | u583826716 | 2,000 | 262,144 | 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. | ["from itertools import product\n\n\nn, m = [int(i) for i in input().rstrip().split()]\nAA = [[0 if i == '.' else 1 for i in input().rstrip()] for _ in range(n)]\nBB = [[0 if i == '.' else 1 for i in input().rstrip()] for _ in range(m)]\n\nfor i_r, i_c in product(range(n - m + 1), range(n - m + 1)):\n i_r -= 1\n i_c -= 1\n for k_r, k_c in product(range(m), range(m)):\n if AA[i_r + k_r][i_c + k_c] == BB[k_r][k_c]:\n continue\n else:\n break\n else:\n print('Yes')\n break\nelse:\n print('No')", "table = {'2': 0,\n '3': 1,\n '4': 2,\n '5': 3,\n '6': 4,\n '7': 5,\n '8': 6,\n '9': 7,\n '10': 8,\n '11': 9,\n '12': 10,\n '13': 11,\n '1': 12, }\nary = [table[i] for i in input().strip().split()]\nif (ary[1] - ary[0]) > 0:\n print('Bob')\nelif ary[1] == ary[0]:\n print('Draw')\nelse:\n print('Alice')"] | ['Runtime Error', 'Accepted'] | ['s753622582', 's395031653'] | [3064.0, 3064.0] | [17.0, 17.0] | [539, 388] |
p03803 | u586563885 | 2,000 | 262,144 | 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. | ['a,b=map(int,input().split())\nif a==b:\n print("draw")\nelif a=1 or a>b\n print("Alice")\nelif b=1:\n print("Bob")\nelse:\n print("Bob")', "a, b = map(int, input().split())\nif a==b:\n ans = 'Draw'\nelif a==1:\n ans = 'Alice'\nelif b==1:\n ans = 'Bob'\nelif a>b:\n ans = 'Alice'\nelse:\n ans = 'Bob'\nprint(ans)"] | ['Runtime Error', 'Accepted'] | ['s409860474', 's598332521'] | [2940.0, 3060.0] | [17.0, 17.0] | [132, 165] |
p03803 | u588339505 | 2,000 | 262,144 | 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. | ["a, b = int(input().split())\n\nif a == 1: a = 14\nif b == 1: b = 14\n\nif a < b:\n print('Bob')\nelif b < a:\n print('Alice')\nelse:\n print('Draw')", "a, b = [int(i) for i in input().split()]\n\nif a == 1: a = 14\nif b == 1: b = 14\n\nif a < b:\n print('Bob')\nelif b < a:\n print('Alice')\nelse:\n print('Draw')"] | ['Runtime Error', 'Accepted'] | ['s986846457', 's470625307'] | [3060.0, 3060.0] | [18.0, 17.0] | [147, 160] |
p03803 | u589969467 | 2,000 | 262,144 | 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. | ["Alice,Bob = map(int,input().split())\nif Alice = 1:\n ALice = 14\nif Bob = 1:\n Bob = 14\nif Alice>Bob:\n print('Alice')\nelif Alice==Bob:\n print('Draw')\nelse:\n print('Bob')\n", "Alice,Bob = map(int,input().split())\nif Alice == 1:\n Alice = 14\nif Bob == 1:\n Bob = 14\nif Alice>Bob:\n print('Alice')\nelif Alice==Bob:\n print('Draw')\nelse:\n print('Bob')\n"] | ['Runtime Error', 'Accepted'] | ['s689673086', 's026031417'] | [8944.0, 9004.0] | [26.0, 28.0] | [182, 184] |
p03803 | u591764610 | 2,000 | 262,144 | 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. | ["a,b=map(lambda x:14 if int(x)==1 else int(x),input().split())\nif a>b:s='Alice';elif a<b:s='Bob';else:s='Draw';print(s)", "a,b=map(lambda x:14 if int(x)==1 else int(x),input().split())\nif a>b:s='Alice'\nelif a<b:s='Bob'\nelse:s='Draw'\nprint(s)"] | ['Runtime Error', 'Accepted'] | ['s297572414', 's306873177'] | [2940.0, 2940.0] | [17.0, 17.0] | [118, 118] |
p03803 | u594859393 | 2,000 | 262,144 | 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. | ["a, b = [int('14' if x == '1' else x) for x in input().split()\nprint('Alice' if a > b else 'Bob' if b > a else 'Draw')", "a, b = [int('14' if x == '1' else x) for x in input().split()]\nprint('Alice' if a > b else 'Bob' if b > a else 'Draw')"] | ['Runtime Error', 'Accepted'] | ['s174428469', 's660190764'] | [2940.0, 2940.0] | [17.0, 17.0] | [117, 118] |
p03803 | u597455618 | 2,000 | 262,144 | 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. | ['a, b = map(int, input().split())\na = (a + 12) % 13\nb = (b + 12) % 13\nif a > b:\n print("Alice")\nif a < b:\n print("Bob")\nelse:\n print("Draw")', 'a, b = map(int, input().split())\nif a > b:\n print("Alice")\nif a < b:\n print("Bob")\nelse:\n print("Draw")', 'a, b = map(int, input().split())\na = (a + 12) % 14\nb = (b + 12) % 14\nif a > b:\n print("Alice")\nelif a < b:\n print("Bob")\nelse:\n print("Draw")'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s052513974', 's829982610', 's447006361'] | [2940.0, 2940.0, 3060.0] | [17.0, 19.0, 18.0] | [142, 106, 144] |
p03803 | u601393594 | 2,000 | 262,144 | 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. | ['# AtCoder abc054 a\n\n\n\nalice, bob = map(int, input().split())\n\n\nif alice == bob:\n print("Draw")\nelif (alice == 1) or ((bob != 1) and (alice > bob)):\n print("alice")\nelse:\n print("bob")\n', '# AtCoder abc054 a\n\n\n\nalice, bob = map(int, input().split())\n\n\nif alice == bob:\n print("Draw")\nelif (alice == 1) or ((bob != 1) and (alice > bob)):\n print("Alice")\nelse:\n print("Bob")\n'] | ['Wrong Answer', 'Accepted'] | ['s683617469', 's195855832'] | [9076.0, 9128.0] | [25.0, 27.0] | [240, 240] |
p03803 | u609738635 | 2,000 | 262,144 | 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. | ['# -*- coding: utf-8 -*-\n\ndef solve(A, B):\n X = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1]\n if(X.index(A)==X.index(B)):\n print("Draw")\n elif(X.index(A)<X.index(B)):\n print("Bob")\n else:\n print("Ailce")\n \nif __name__ == \'__main__\':\n A, B = map(int, input().split())\n\n solve(A, B)', '# -*- coding: utf-8 -*-\n\ndef solve(A, B):\n X = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1]\n if(X.index(A)>X.index(B)):\n print("Alice")\n elif(X.index(A)<X.index(B)):\n print("Bob")\n else:\n print("Draw")\n \nif __name__ == \'__main__\':\n A, B = map(int, input().split())\n\n solve(A, B)'] | ['Wrong Answer', 'Accepted'] | ['s021241250', 's289358335'] | [3060.0, 3064.0] | [17.0, 17.0] | [324, 323] |
p03803 | u612721349 | 2,000 | 262,144 | 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. | ['a,b=map(int,input().split())\nh=[14]+list(range(2,14))\nifa==b:\n print("Draw")\nelse:\n print("Alice"if h[a]>h[b]else"Bob")', 'a,b=map(int,input().split())\nh=[0,14]+list(range(2,14))\nif a==b:\n print("Draw")\nelse:\n print("Alice"if h[a]>h[b]else"Bob")\n'] | ['Runtime Error', 'Accepted'] | ['s661394781', 's297337003'] | [2940.0, 2940.0] | [17.0, 17.0] | [121, 125] |
p03803 | u624613992 | 2,000 | 262,144 | 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. | ['if a > b :\n if b == 1:\n print("Bob")\n else:\n print("Alice")\n print("Alice")\nelif a <b :\n if a==1:\n print("Alice")\n else:\n print("Bob")\nelse:\n print("Draw")', 'a, b = map(int, input().split())\n\nif a > b :\n if b == 1:\n print("Bob")\n else:\n print("Alice")\nelif a <b :\n if a==1:\n print("Alice")\n else:\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s297881234', 's938301151'] | [2940.0, 3060.0] | [18.0, 18.0] | [201, 216] |
p03803 | u630786674 | 2,000 | 262,144 | 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. | ['n, m = map(int, input().split())\n\nn_list = [input() for _ in range(n)]\nm_list = [input() for _ in range(m)]\n\nfor i in n_list:\n for j in m_list:\n if j not in i:\n print("No")\n quit()\nprint("Yes")', 'a, b = map(int, input().split())\n\nif a == b:\n print("Draw")\nelif a == 1:\n print("Alice")\nelif b == 1:\n print("Bob")\nelif a > b:\n print("Alice")\nelse:\n print("Bob")\n'] | ['Runtime Error', 'Accepted'] | ['s838003391', 's826336064'] | [3056.0, 3064.0] | [17.0, 19.0] | [225, 179] |
p03803 | u642012866 | 2,000 | 262,144 | 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. | ['A, B = map(int, input().split())\nif A == 1:\n A += 100\nif B == 1:\n B +=100\nif A > B:\n print("Bob")\nelif A < B:\n print("Alice")\nelse:\n print("Draw")', 'A, B = map(int, input().split())\nif A == 1:\n A += 100\nif B == 1:\n B += 100\nif A > B:\n print("Alice")\nelif A < B:\n print("Bob")\nelse:\n print("Draw")\n'] | ['Wrong Answer', 'Accepted'] | ['s509499909', 's206692857'] | [9172.0, 9168.0] | [26.0, 25.0] | [151, 153] |
p03803 | u657913472 | 2,000 | 262,144 | 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. | ['a,b=(int(i)+11)%13 for i in input().split()\nprint("Bob" if a<b else "Alice" if a>b else "Draw")', 'a,b=[(int(i)+11)%13 for i in input().split()]\nprint("Bob" if a<b else "Alice" if a>b else "Draw")'] | ['Runtime Error', 'Accepted'] | ['s506315888', 's656215676'] | [2940.0, 2940.0] | [17.0, 17.0] | [95, 97] |
p03803 | u664652300 | 2,000 | 262,144 | 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. | ['a,b=map(int,input())\nif a==b:\n print("Draw")\nelif a==1:\n print("Alice")\nelif b==1:\n print("Bob")\nelif a>b:\n print("Alice")\nelse:\n print("Bob")', 'a,b=map(int,input().split())\nif a==b:\n print("Draw")\nelif a==1:\n print("Alice")\nelif b==1:\n print("Bob")\nelif a>b:\n print("Alice")\nelse:\n print("Bob")'] | ['Runtime Error', 'Accepted'] | ['s443208574', 's638714518'] | [2940.0, 2940.0] | [17.0, 17.0] | [147, 155] |
p03803 | u667084803 | 2,000 | 262,144 | 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. | ['import sys\nN,M=map(int,input().split())\nA=[]\nB=[]\nA+=[str(input()) for i in range(N)]\nB+=[str(input()) for i in range(M)]\nfor i in range(N-M+1):\n for j in range(N-M+1):\n ans=1\n for k in range(M):\n for l in range(M):\n if B[k][l]!=A[i+k][j+l]:\n ans=0\n if ans:\n print("Yes")\n sys.exit()\nprint("No")', 'A,B=map(int, input().split())\nif (A+12)%14 > (B+12)%14:\n print("Alice")\nelif A==B:\n print("Draw")\nelse:\n print("Bob")'] | ['Runtime Error', 'Accepted'] | ['s043962705', 's957881963'] | [3064.0, 2940.0] | [17.0, 17.0] | [336, 120] |
p03803 | u670961163 | 2,000 | 262,144 | 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. | ["a, b = map(int, input())\nif a == b:\n print('Draw')\nelif a > b and b!=1:\n print('Alice')\nelse:\n print('Bob')", "a, b = map(int, input().split())\nif a == b:\n print('Draw')\nelif a > b and b!=1:\n print('Alice')\nelif a==1:\n print('Alice')\nelse:\n print('Bob')\n"] | ['Runtime Error', 'Accepted'] | ['s616876883', 's845118821'] | [9016.0, 9012.0] | [23.0, 28.0] | [110, 147] |
p03803 | u677400065 | 2,000 | 262,144 | 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. | ['a,b = map(int, input())\n\nif a == 1:\n print("Alice")\nelif b == 1:\n print("Bob")\nelif a < b:\n print("Bob")\nelse:\n print("Alice")', 'a,b = map(int, input().split())\n\nif a == b:\n print("Draw")\nelif a == 1:\n print("Alice")\nelif b == 1:\n print("Bob")\nelif a < b:\n print("Bob")\nelse:\n print("Alice")\n'] | ['Runtime Error', 'Accepted'] | ['s247598805', 's633923497'] | [2940.0, 2940.0] | [18.0, 17.0] | [130, 168] |
p03803 | u679089074 | 2,000 | 262,144 | 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. | ['A,B = map(int,input().split())\n\nif A>B:\n print("Alicd")\nelif A<B:\n print("Bob")\nelse:\n print("Draw")', 'A,B = map(int,input().split())\nif A==1 :\n A = 14\nif B == 1:\n B = 14\n\nif A>B:\n print("Alicd")\nelif A<B:\n print("Bob")\nelse:\n print("Draw")', 'A,B = map(int,input().split())\nif A==1 :\n A = 14\nif B == 1:\n B = 14\n\nif A>B:\n print("Alice")\nelif A<B:\n print("Bob")\nelse:\n print("Draw")'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s426813935', 's857416264', 's735556449'] | [9064.0, 9176.0, 9072.0] | [27.0, 26.0, 28.0] | [109, 152, 152] |
p03803 | u703890795 | 2,000 | 262,144 | 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. | ['A = int(input())\nB = int(input())\n\nif A == 1:\n A = 14\nif B == 1:\n B = 14\n\nif A == B:\n print("Draw")\nelif A > B:\n print("Alice")\nelse:\n print("Bob")', 'A, B = map(int,input().split())\n\nif A == 1:\n A = 14\nif B == 1:\n B = 14\n\nif A == B:\n print("Draw")\nelif A > B:\n print("Alice")\nelse:\n print("Bob")'] | ['Runtime Error', 'Accepted'] | ['s713566240', 's310579895'] | [3060.0, 2940.0] | [17.0, 17.0] | [152, 150] |
p03803 | u712187387 | 2,000 | 262,144 | 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. | ['import itertools\nimport numpy as np\nN,Ma,Mb=map(int,input().split())\nyaku=[]\nfor _ in range(N):\n yaku.append(list(map(int,input().split())))\n\n\ncandi_money=[]\n\nfor n in range(N):\n candis=list(itertools.combinations(np.arange(N),n))\n for candi in candis:\n a,b,c=0,0,0\n for num in candi:\n a +=yaku[num][0]\n b +=yaku[num][1]\n c +=yaku[num][2]\n if a/flaot(Ma/Mb)=b:\n candi_money.append(c)\n\n\nif len(candi_money)==0:\n\tprint(-1)\nelse:\n\tprint(min(candi_money))', 'input = input().split()\nA,B=int(input[0]),int(input[1])\n \nif A==1:\n A+=13\nif B==1:\n B+=13\n \nif A==B:\n print("Draw")\nelif A>B:\n print("Alice")\nelse:\n print("Bob")'] | ['Runtime Error', 'Accepted'] | ['s294230405', 's593371031'] | [3064.0, 3064.0] | [22.0, 23.0] | [525, 176] |
p03803 | u714533789 | 2,000 | 262,144 | 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. | ["a, b = map(int, input().split())\nif a<b + (a==1 * b!=1):\n\tprint('Alice')\nelif a<b + (a!=1 * b==1):\n\tprint('Bob')\nelse:\n\tprint('Draw')", "a, b = map(int, input().split())\nif a == b:\n\tprint('Draw')\nelif a>b:\n\tprint(['Alice','Bob'][b==1])\nelse:\n\tprint(['Bob','Alice'][a==1])"] | ['Wrong Answer', 'Accepted'] | ['s572778940', 's690039217'] | [2940.0, 3060.0] | [17.0, 17.0] | [133, 134] |
p03803 | u717626627 | 2,000 | 262,144 | 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. | ["a, b = map(int, input().split())\n\nif:\n print('Draw')\nelif a == 1:\n print('Alice')\nelif b == 1:\n print('Bob')\nelif a < b:\n print('Bob')\nelif a > b:\n print('Alice')\n", "a = int(input())\nb = int(input())\n\nif a < b:\n print('Bob')\nelif a > b:\n print('Alice')\nelse:\n print('Draw')", "a, b = map(int, input().split())\n\nif a == b:\n print('Draw')\nelif a == 1:\n print('Alice')\nelif b == 1:\n print('Bob')\nelif a < b:\n print('Bob')\nelif a > b:\n print('Alice')\n"] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s153320717', 's683559483', 's642756622'] | [3064.0, 2940.0, 2940.0] | [17.0, 18.0, 17.0] | [168, 110, 175] |
p03803 | u732844340 | 2,000 | 262,144 | 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. | ['n = list(map(int, input().split))\n\na = n[0]\nb = n[1]\n\nif a == b:\n print("Draw")\nelif a == 1:\n print("Alice")\nelif b == 1:\n print("Bob")\nelif a > b:\n print("Alice")\nelif b > a:\n print("Bob")', 'n = list(map(int, input().split()))\n\na = n[0]\nb = n[1]\n\nif a == b:\n print("Draw")\nelif a == 1:\n print("Alice")\nelif b == 1:\n print("Bob")\nelif a > b:\n print("Alice")\nelif b > a:\n print("Bob")'] | ['Runtime Error', 'Accepted'] | ['s177778647', 's449085367'] | [3060.0, 3060.0] | [17.0, 17.0] | [204, 206] |
p03803 | u732870425 | 2,000 | 262,144 | 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. | ['A, B = map(int, input().split())\nif A == B:\n print("Draw")\nelif A == 1:\n print("Alice")\nelif B == 1:\n print("Bob")\nelse:\n if A < B:\n print("Alice")\n else:\n print("Bob")', 'A, B = map(int, input().split())\nif A == B:\n print("Draw")\nelif A == 1:\n print("Alice")\nelif B == 1:\n print("Bob")\nelse:\n if B < A:\n print("Alice")\n else:\n print("Bob")'] | ['Wrong Answer', 'Accepted'] | ['s896539009', 's680932788'] | [2940.0, 3060.0] | [17.0, 17.0] | [179, 179] |
p03803 | u732963817 | 2,000 | 262,144 | 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. | ['from itertools import combinations\nN, Ma, Mb = list(map(int, input().split()))\nabc = [list(map(int, input().split())) for _ in range(N)]\nmin_cost = -1\nfor _i in range(1, N+1):\n all_pattern = list(combinations(range(N), _i))\n for _j in all_pattern:\n _a = sum([abc[_k][0] for _k in _j])\n _b = sum([abc[_k][1] for _k in _j])\n _c = sum([abc[_k][2] for _k in _j])\n if _b * Ma == _a * Mb:\n if min_cost == -1 or min_cost > _c:\n min_cost = _c\nprint(min_cost)', 'A, B = list(map(lambda x: x + 13 if x == 1 else x, map(int, input().split())))\n\nprint("Alice" if A > B else "Bob" if A < B else "Draw")'] | ['Runtime Error', 'Accepted'] | ['s243232476', 's411093135'] | [3064.0, 2940.0] | [17.0, 17.0] | [510, 135] |
p03803 | u733321071 | 2,000 | 262,144 | 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. | ['a, b = map(int, input().split())\n if a == b:\n print("Draw")\n elif a == 1:\n print("Alice")\n elif b == 1:\n print("Bob")\n elif a > b:\n print("Alice")\n else:\n print("Bob")', 'def main():\n a, b = map(int, input().split())\n if a == b:\n print("Draw")\n elif a == 1:\n print("Alice")\n elif b == 1:\n print("Bob")\n elif a > b:\n print("Alice")\n else:\n print("Bob")\n\n\nif __name__ == \'__main__\':\n main()\n'] | ['Runtime Error', 'Accepted'] | ['s777581451', 's021642703'] | [2940.0, 2940.0] | [17.0, 17.0] | [217, 274] |
p03803 | u739798900 | 2,000 | 262,144 | 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. | ["cards = input()\ncards_s = cards.split()\n\nporker_list = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1]\n\nalice_str = cards_s[0]\nalice_s = porker_list.index(alice_str)\nalice = int(alice_s)\n\nbob_str = cards_s[1]\nbob_s = porker_list.index(bob_str)\nbob = int(bob_s)\n\nif alice > bob:\n print('Alice')\nelif alice == bob:\n print('Draw')\nelse\n print('Bob')\n", "cards = input()\ncards_s = cards.split()\n\nporker_list = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1]\n\nalice_str = cards_s[0]\nalice_int = int(alice_str)\nalice = porker_list.index(alice_int)\n\nbob_str = cards_s[1]\nbob_int = int(bob_str)\nbob = porker_list.index(bob_int)\n\nif alice > bob:\n print('Alice')\nelif alice == bob:\n print('Draw')\nelse\n print('Bob')", "cards = input()\ncards_s = cards.split()\n\nporker_list = ['2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '1']\n\nalice_str = cards_s[0]\nalice_s = porker_list.index(alice_str)\nalice = int(alice_s)\n\nbob_str = cards_s[1]\nbob_s = porker_list.index(bob_str)\nbob = int(bob_s)\n\nif alice > bob:\n print('Alice')\nelif alice == bob:\n print('Draw')\nelse:\n print('Bob')\n"] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s453950106', 's915826462', 's247484874'] | [3064.0, 3060.0, 3064.0] | [17.0, 17.0, 17.0] | [352, 359, 379] |
p03803 | u739843002 | 2,000 | 262,144 | 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. | ['tmp = input().split(" ")\na = (int(tmp[0]) - 2) % 13\nb = (int(tmp[1]) - 2) % 13\nprint("Alice") if a > b else print("Draw") if a = b else print("Bob")', 'tmp = input().split(" ")\na = (int(tmp[0]) - 2) % 13\nb = (int(tmp[1]) - 2) % 13\nprint("Alice") if a > b else print("Draw") if a == b else print("Bob")'] | ['Runtime Error', 'Accepted'] | ['s132231925', 's889464621'] | [8964.0, 9100.0] | [25.0, 30.0] | [148, 149] |
p03803 | u748135969 | 2,000 | 262,144 | 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. | ["A, B = map(int, input().split())\n\nif A > b:\n print('Alice')\nelif A < B:\n print('Bob')\nelse:\n print('Draw')", "A, B = map(int, input().split())\n\nif A == 1:\n A = 14\nif B == 1:\n B = 14\n \nif A > B:\n print('Alice')\nelif A < B:\n print('Bob')\nelse:\n print('Draw')"] | ['Runtime Error', 'Accepted'] | ['s065968539', 's650107454'] | [2940.0, 3060.0] | [17.0, 17.0] | [109, 151] |
p03803 | u748311048 | 2,000 | 262,144 | 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. | ["A,B=map(int,input().split())\nif A==1 or B==1:\n if A==B:\n print('Draw')\n elif A=1:\n print('Alice')\n else:\n print('Bob')\nelif A>B:\n print('Alice')\nelif A<B:\n print('Bob')\nelse:\n print('Draw')", "A,B=map(int, input().split())\nif A==B:\n print('Draw')\nelif A==1:\n print('Alice')\nelif B==1:\n print('Bob')\nelif A>B:\n print('Alice')\nelse:\n print('Bob')\n"] | ['Runtime Error', 'Accepted'] | ['s782878390', 's692231293'] | [2940.0, 2940.0] | [17.0, 17.0] | [204, 157] |
p03803 | u752898745 | 2,000 | 262,144 | 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. | ['x = list(map(int, input().split()))\nif x[0]==1 and x[1]!=1:\n x[0]=14\nelif x[1]==1 and x[1]!=1:\n x[1]=14\nelif x==[1,1]:\n x = [14,14]\nprint(x)\nprint("Alice" if x[0]>x[1] else "Bob" if x[0]<x[1] else "Draw")', 'x = list(map(int, input().split()))\nif x[0]==1:\n x[0]=14\nif x[1]==1:\n x[1]=14\nprint("Alice" if x[0]>x[1] else "Bob" if x[0]<x[1] else "Draw")'] | ['Wrong Answer', 'Accepted'] | ['s612370000', 's542017123'] | [3064.0, 2940.0] | [17.0, 17.0] | [213, 147] |
p03803 | u754022296 | 2,000 | 262,144 | 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. | ['a, b = map(int, input().split())\nl = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1]\nif l.index(a) > l.index(b):\n print("Alice")\nelif l.index(a) < l,index(a):\n print("Bob")\nelse:\n print("Draw")', 'a, b = map(int, input().split())\nl = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1]\nif l.index(a) > l.index(b):\n print("Alice")\nelif l.index(a) < l.index(b):\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s061730644', 's400100103'] | [2940.0, 3060.0] | [17.0, 17.0] | [192, 192] |
p03803 | u759482921 | 2,000 | 262,144 | 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. | ['import sys\n\ninput_num = input().split()\nN = int(input_num[0])\nM = int(input_num[1])\n\nA = [input() for i in range(0, N-1)]\nB = [input() for n in range(0, M-1)]\n\nif M > N:\n print("No")\nelif M == N:\n for a, b in zip(A, B):\n if b not in a:\n print("No")\n else:\n print("Yes")\nelse:\n diff = N - M\n breaked = False\n for i in range(0, len(A)-1):\n l = i\n while l <= i + diff and l < len(B):\n if A[i] == B[l]:\n breaked = True\n break\n else:\n if breaked:\n print("No")\n sys.exit()\n l += 1\n if breaked:\n print("Yes")\n else:\n print("No")', 'N = input().split()\nA = int(N[0])\nB = int(N[1])\n\nif A > B:\n if B != 1:\n print("Alice")\n else:\n print("Bob")\nelif A == B:\n print("Draw")\nelse:\n if A != 1:\n print("Bob")\n else:\n print("Alice")'] | ['Runtime Error', 'Accepted'] | ['s868107684', 's339144673'] | [3064.0, 3060.0] | [17.0, 17.0] | [718, 233] |
p03803 | u760831084 | 2,000 | 262,144 | 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. | ["if a == 1: a += 13\nif b == 1: b += 13\n\nif a > b:\n print('Alice')\nelif a < b:\n print('Bob')\nelse:\n print('Draw')", "a, b = map(int, input().split())\n\nif a == 1: \n a += 13\nif b == 1: \n b += 13\n\nif a > b:\n print('Alice')\nelif a < b:\n print('Bob')\nelse:\n print('Draw')"] | ['Runtime Error', 'Accepted'] | ['s916993381', 's763437925'] | [2940.0, 3060.0] | [17.0, 17.0] | [120, 164] |
p03803 | u760961723 | 2,000 | 262,144 | 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. | ['Alice,Bob = map(int,input().split())\n\nif Alice == Bob:\n print("Draw")\n if Alice == 1:\n print("Alice")\n elif Bob == 1:\n print("Bob")\n elif Alice > Bob:\n print("Alice")\n else:\n print("Bob")', 'Alice,Bob = map(int,input().split())\n \nif Alice == Bob:\n print("Draw")\nelse:\n if Alice == 1:\n print("Alice")\n elif Bob == 1:\n print("Bob")\n elif Alice > Bob:\n print("Alice")\n else:\n print("Bob")'] | ['Wrong Answer', 'Accepted'] | ['s014957967', 's797217280'] | [2940.0, 3060.0] | [17.0, 17.0] | [204, 211] |
p03803 | u762540523 | 2,000 | 262,144 | 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. | ['a,b=map(int,input()).split())\nprint("Draw" if a==b else "Alice" if a==1 else "Bob"if b==1 else "Alice" if a>b else "Bob")', 'a,b=map(int,input()).split()\nprint("Draw" if a==b else "Alice" if a==1 else "Bob"if b==1 else "Alice" if a>b else "Bob")', 'a,b=map(int,input().split())\nprint("Draw"if a==b else"Alice"if a==1 else"Bob"if b==1 else"Alice"if a>b else"Bob")'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s076908061', 's482613143', 's537787209'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [121, 120, 113] |
p03803 | u762603420 | 2,000 | 262,144 | 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. | ['n = input().split()\n\nar = int(n[0])\nbr = int(n[1])\n\na = []\nb = []\nfor i in range(0, ar):\n a.append(input())\n\nfor j in range(0, br):\n b.append(input())\n\nfind = False\nfor i in range(0, ar - br):\n idx = a[i].find(b[0])\n if idx != -1:\n match = True\n for j in range(1, br):\n idx2 = a[i + j].find(b[j])\n if idx != idx2:\n match = False\n if match:\n find = True\n break\nif find:\n print("Yes")\nelse:\n print("No")', 'c = input().split()\na = int(c[0])\nb = int(c[1])\nif a == 1:\n a = 14\nif b == 1:\n b = 14\n\nif a > b:\n print("Alice")\nelif b > a:\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s049644734', 's536420790'] | [3064.0, 3060.0] | [17.0, 17.0] | [499, 174] |
p03803 | u763963344 | 2,000 | 262,144 | 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. | ['a,b = map(int, input().split())\n\nif a>b and b!=1 or a==1:\n print("Alice")\nelif a==b:\n print("Draw")\nelse\n print("Bob")', 'a,b = map(int, input().split())\n\nif a>b and b!=1 or a==1:\n print("Alice")\nelif a==b:\n print("Draw")\nelse\n print("Bob")', 'a,b = map(int, input().split())\n\nif a>b and b!=1 or a==1:\n print("Alice")\nelif a==b:\n print("Draw")\nelse\n print("Bob")', "A, B = map(int, input().split())\n\nif A == B:\n print('Draw')\nelif B != 1 and A > B or A == 1:\n print('Alice')\nelse:\n print('Bob')"] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s427446339', 's629386186', 's929841544', 's464493894'] | [8908.0, 8908.0, 8888.0, 9104.0] | [21.0, 27.0, 20.0, 25.0] | [127, 127, 127, 137] |
p03803 | u765721093 | 2,000 | 262,144 | 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. | ['a,b=map(int,input().split())\nif a==1:\n a=a+13\nif b==1:\n b=b+13\nprint(a,b)\nprint("Draw" if a==b else "Alice" if a>b else "Bob")', 'a,b=map(int,input().split())\nif a==1:\n a=a+13\nif b==1:\n b=b+13\nprint(a,b)\nprint("Draw" if a==b else "Alice" if a>b else "Bob")', 'a,b=map(int,input().split())\nif a==1:\n a=a+13\nif b==1:\n b=b+13\nprint("Draw" if a==b else "Alice" if a>b else "Bob")'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s655110121', 's886463115', 's954002798'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [132, 132, 121] |
p03803 | u766407523 | 2,000 | 262,144 | 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. | ["A, B = map(int, input())\nif A == 1:\n A = 14\nif B == 1:\n B = 14\n\nif A == B:\n print('Draw')\nelif A > B:\n print('Alice')\nelse:\n print ('Bob')\n", "A, B = map(int, input().split())\nif A == 1:\n A = 14\nif B == 1:\n B = 14\n\nif A == B:\n print('Draw')\nelif A > B:\n print('Alice')\nelse:\n print ('Bob')\n"] | ['Runtime Error', 'Accepted'] | ['s364120435', 's569370786'] | [2940.0, 2940.0] | [18.0, 17.0] | [154, 162] |
p03803 | u766646838 | 2,000 | 262,144 | 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. | ["N,M = map(int,input().split())\na = []\nc = []\nfor i in range(N):\n b = list(input())\n a+=b\nfor i in range(M):\n b = list(input())\n c+=b\n#print(c,a)\nf = False\nfor i in range(N*N):\n if f == True:\n break\n if N*N-i<M*M:\n break\n count=0\n flag = True\n #print(i,c[0],a[i])\n if c[0] == a[i]:\n if N-(i%N)<M:\n continue\n num = i\n for j in range(M):\n for k in range(M):\n #print(c[count],a[num])\n if c[count] == a[num]:\n \n num+=1\n count+=1\n elif c[count]!=a[num]:\n flag =False\n break\n num+=N-M\n if flag == False:\n #print(i)\n break \n if j == M-1:\n f = True\n \n else:\n continue\nif f == False:\n print('No')\nelse:\n print('Yes')\n \n \n ", "M,N = map(int,input().split())\n\nif M == N:\n print('Draw')\nelif (M>N and N!=1) or M==1:\n print('Alice')\nelse:\n print('Bob')"] | ['Runtime Error', 'Accepted'] | ['s545031058', 's651862453'] | [9224.0, 9168.0] | [30.0, 28.0] | [787, 125] |
p03803 | u771167374 | 2,000 | 262,144 | 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. | ["a, b = map(int, input().split())\nif a==1 and b==1:\n print('Draw')\nelif a==1 or b==1:\n print('Alice' if a == 1 else 'Bob')\nelse :\n print('Alce' if a>b else 'Bob' if a<b else 'Draw')", "A,B=map(int,input().split())\nif A==1: A=14\nif B==1: B=14\n\nif A==B:\n print('Draw')\nelif A<B:\n print('Bob')\nelse:\n print('Alice')\n"] | ['Wrong Answer', 'Accepted'] | ['s967702697', 's756933681'] | [2940.0, 2940.0] | [17.0, 17.0] | [189, 137] |
p03803 | u772180901 | 2,000 | 262,144 | 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. | ['if a == b:\n print("Draw")\nelif a > b and b != 1:\n print("Alice")\nelif b == 1 and a > b:\n print("Bob")\nelif a == 1 and b > a:\n print("Alice")\nelse:\n print("Bob")', 'a,b = map(int,input().split())\nif a == 1:\n a = 14\nif b == 1:\n b = 14\nif a == b:\n print("Draw")\nelif a < b:\n print("Bob")\nelse:\n print("Alice")'] | ['Runtime Error', 'Accepted'] | ['s794192108', 's628583971'] | [2940.0, 3060.0] | [17.0, 17.0] | [175, 157] |
p03803 | u772649753 | 2,000 | 262,144 | 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. | ['A,B = map(int,input().split())\nif A > B:\n print("Alice")\nelse if A < B:\n print("Bob")\nelse:\n print("Draw")', 'a,b = map(int, input().split())\nif a == b:\n print("Draw")\nelse:\n if a == 1:\n print("Alice")\n else:\n if b == 1:\n print("Bob")\n else:\n if a > b:\n print("Alice")\n else:\n print("Bob")'] | ['Runtime Error', 'Accepted'] | ['s355675629', 's244625076'] | [2940.0, 2940.0] | [17.0, 17.0] | [109, 220] |
p03803 | u777028980 | 2,000 | 262,144 | 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. | ['a,b=(int,input().split())\n\nif(a==1):\n a=14\nif(b==1):\n b=14\n \nif(a>b):\n print("Alice")\nelif(a<b):\n print("Bob")\nelse:\n print("Drow")', 'a,b=map(int,input().split())\nif(a==1):\n a=14\nif(b==1):\n b=14\n\nif(a>b):\n print("Alice")\nelif(a<b):\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s158423757', 's382274902'] | [2940.0, 3060.0] | [17.0, 17.0] | [137, 137] |
p03803 | u782001565 | 2,000 | 262,144 | 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. | ["\nA, B = map(int,input().split())\n\n\nif A == B:\n print('Draw')\nelif A == 1:\n print('Alice')\nelif B == 1:\n print('Bob')\nelif A > B:\n print('Alice')\nelse:", "\nA, B = map(int,input().split())\n\n\nif A == B:\n print('Draw')\nelif A == 1:\n print('Alice')\nelif B == 1:\n print('Bob')\nelif A > B:\n print('Alice')\nelse:\n print('Bob')"] | ['Runtime Error', 'Accepted'] | ['s643644220', 's887969566'] | [9028.0, 9136.0] | [20.0, 29.0] | [178, 195] |
p03803 | u785205215 | 2,000 | 262,144 | 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. | ['from sys import stdin, setrecursionlimit\nsetrecursionlimit(5000)\ndef readLine_int_list():return list(map(int, stdin.readline().split()))\ndef readAll_int(): return list(list(map(int,i.split())) for i in stdin.read().split("\\n"))\n \n \ndef gcd(a, b):\n while b:\n a, b = b, a % b\n return a\n\ndef ratio(a,b):\n return (a//gcd(a,b), b//gcd(a,b))\n \ndef add_ratio(a,b):\n if a != 0:\n sum_a = sum(a)\n sum_b = sum(b)\n _a = a[0]*sum_b + b[0]*sum_a\n _b = b[1]*sum_a + a[1]*sum_b\n return ratio(_a, _b)\n else:\n return(b)\n \ndef dfs(i, v, r,ans):\n if i == n:\n if r == (Ma,Mb):\n ans.append(v)\n return 0\n\n if dfs(i+1, v, r,ans):\n return 0\n \n if dfs(i+1, v+D[i][2], add_ratio(r,ratio(D[i][0],D[i][1])), ans):\n return 0\n \n return 0\nans = []\nn, Ma, Mb = readLine_int_list()\nD = readAll_int()\ne=0\nfor i in D:\n e += i[2]\n\ndef main():\n dfs(0,0,0,ans)\n if ans:\n print(min(ans))\n else:\n print(-1)\n \nif __name__ == "__main__":\n main()', 'a,b = list(int(i) for i in input().split())\nif a == 1:\n a = 14\nif b == 1:\n b = 14\nif a==b:\n print("Draw")\nelse:\n print("Alice" if a>b else "Bob")'] | ['Runtime Error', 'Accepted'] | ['s592024956', 's801499909'] | [3064.0, 3064.0] | [18.0, 17.0] | [1049, 157] |
p03803 | u785578220 | 2,000 | 262,144 | 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. | ['a ,b= map(int, input().split())\nif a == 1:\n a +=13\nif b == 1:\n b +=13\nif a>b:\n print("Bob")\nelif a == b:\n print("Draw")\nelse:print("Alice")\n', 'a ,b= map(int, input().split())\nif a == 1:\n a +=13\nif b == 1:\n b +=13\nif a<b:\n print("Bob")\nelif a == b:\n print("Draw")\nelse:print("Alice")\n'] | ['Wrong Answer', 'Accepted'] | ['s199659362', 's058990761'] | [2940.0, 2940.0] | [20.0, 18.0] | [152, 152] |
p03803 | u786020649 | 2,000 | 262,144 | 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. | ["import sys\n \nN,M=map(int,input().split())\nA=[sys.stdin.readline().strip() for _ in range(N)]\nB=[sys.stdin.readline().strip() for _ in range(M)]\n \nfor i in range(N-M+1):\n for j in range(N-M+1):\n As=[x[j:j+M] for x in A[j:j+M]]\n if B==As:\n print('Yes')\n sys.exit()\nprint('No')", "A, B=map(int,input())\n\nfunc=lambda x:(x,x+13)[x==1]\n\nif func(A)==func(B):\n print('Draw')\nelif func(A)<func(B):\n print('Bob')\nelse:\n print('Alice')", "A, B=map(int,input().split())\n \nfunc=lambda x:[x,x+13][x==1]\n \nif func(A)==func(B):\n print('Draw')\nelif func(A)<func(B):\n print('Bob')\nelse:\n print('Alice')"] | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s447387272', 's543790180', 's974728891'] | [9004.0, 9176.0, 9052.0] | [25.0, 24.0, 24.0] | [291, 149, 159] |
p03803 | u790048565 | 2,000 | 262,144 | 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. | ["N, M = map(int, input().split())\n\nA = []\nfor _ in range(N):\n a = input()\n A.append(a)\n\nB = []\nfor _ in range(M):\n b = input()\n B.append(b)\n\nexisted = False\nfor i in range(N - M + 1):\n for j in range(N - M + 1):\n match = True\n for mi in range(M):\n for mj in range(M):\n x = i + mi\n y = j + mj\n\n if (A[y][x] != B[mj][mi]):\n match = False\n break\n \n if (match == False):\n break\n\n if (match):\n existed = True\n break\n \n if (existed):\n break\n\nresult = 'Yes' if (existed) else 'No'\nprint(result)\n", "A, B = map(int, input().split())\n\nresult = ''\nif (A == 1 and B != 1):\n result = 'Alice'\nelif (B == 1 and A != 1):\n result = 'Bob'\nelif (A > B):\n result = 'Alice'\nelif (B > A):\n result = 'Bob'\nelif (B == A):\n result = 'Draw'\n\nprint(result)\n"] | ['Runtime Error', 'Accepted'] | ['s914043324', 's606573496'] | [3064.0, 2940.0] | [18.0, 17.0] | [577, 244] |
p03803 | u790812284 | 2,000 | 262,144 | 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. | ['a,b = int(input().split)\n\nif a ==b :\n print("Draw")\nelif a == 1 or a>b:\n print("Alice")\nelse:\n print("Bob")', 'a, b = (int(i) for i in input().split())\n\nif a==1:\n a=14\n\nif b==1:\n b=14\n\nif a==b:\n print("Draw")\nelif a>b:\n print("Alice")\nelse:\n print("Bob")\n'] | ['Runtime Error', 'Accepted'] | ['s760840215', 's576418972'] | [2940.0, 2940.0] | [17.0, 17.0] | [116, 159] |
p03803 | u791838908 | 2,000 | 262,144 | 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. | ['if(A > B):\n print("Alice")\nelif(B > A):\n print("Bob")\nelse:\n print("Draw")\n', 'A = int(input())\nb = int(input())\nif(A > B):\n print("Alice")\nelif(B > A):\n print("Bob")\nelse:\n print("Draw")', '\nA = int(input())\nB = int(input())\nif(A > B):\n print("Alice")\nelif(B > A):\n print("Bob")\nelse:\n print("Draw")', 'A, B = map(int, input().split())\nif(A ==1):\n A += 13\nif(B ==1):\n B += 13\nif(A > B):\n print("Alice")\nelif(B > A):\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s288688883', 's532878045', 's918635515', 's759658190'] | [3064.0, 3064.0, 3064.0, 3064.0] | [22.0, 23.0, 24.0, 23.0] | [78, 111, 112, 152] |
p03803 | u794173881 | 2,000 | 262,144 | 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. | ['a, b =map(int,input().split())\n\nif a ==1 and b ==1:\n print("Draw")\nelif a ==1:\n print("Alice")\nelif b ==1:\n print("Bob")\nelif a < b:\n print("Alice")\nelif a < b:\n print("Bob")\nelse:\n print("Draw")', 'a, b =map(int,input().split())\n\nif a ==1 and b ==1:\n print("Draw")\nelif a ==1:\n print("Alice")\nelif b ==1:\n print("Bob")\nelif a > b:\n print("Alice")\nelif a < b:\n print("Bob")\nelse:\n print("Draw")'] | ['Wrong Answer', 'Accepted'] | ['s693572028', 's916423949'] | [2940.0, 2940.0] | [17.0, 17.0] | [201, 201] |
p03803 | u797016134 | 2,000 | 262,144 | 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. | ['a, b = map(int, input().split())\nif a < b:\n print("Bob")\nif a > b:\n print("Alice")\nif a = b:\n print("Draw")', 'a, b = map(int, input().split())\nif a == 1 and a != b:\n print("Alice")\n exit()\nif b == 1 and a != b:\n print("Bob")\n exit()\nif a < b:\n print("Bob")\n exit()\nif a > b:\n print("Alice")\n exit()\nif a == b:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s893888503', 's839890396'] | [2940.0, 3060.0] | [18.0, 17.0] | [116, 241] |
p03803 | u816631826 | 2,000 | 262,144 | 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. | ['\nn = int(input())\nm = int(input())\n\nif n == 1:\n n = 14\nif m == 1:\n m = 14\n\nif n > m:\n print("Alice")\nelif m > n:\n print("Bob")\nelse:\n print("Draw")\n\n\n', 'l1 = input().split()\na = int(l1[0])\nb = int(l1[1])\nif a == b:\n print("Draw")\n exit()\nif a == 1:\n print("Alice")\n exit()\nif b ==1:\n print("Bob")\n exit()\nif a > b:\n print("Alice")\nif b > a :\n print("Bob")'] | ['Runtime Error', 'Accepted'] | ['s285206408', 's678671558'] | [2940.0, 3064.0] | [17.0, 18.0] | [165, 226] |
p03803 | u819710930 | 2,000 | 262,144 | 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. | ["a,b=map(int,input().split())\nif a==b: print('Draw')\nelif a==1: print('Alice')\nelif b==1: print('Bob')\nelse print('Alice' if a>b else 'Bob')", "a,b=map(int,input().split())\nif a==b: print('Draw')\nelif a==1: print('Alice')\nelif b==1: print('Bob')\nelse: print('Alice' if a>b else 'Bob')"] | ['Runtime Error', 'Accepted'] | ['s058495781', 's852902572'] | [2940.0, 2940.0] | [17.0, 17.0] | [139, 140] |
p03803 | u820357030 | 2,000 | 262,144 | 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. | ["N, M = (int(i) for i in input().split())\na = []\nb = []\nfor i in range(N):\n data = list(input())\n a.append(data)\nfor i in range(M):\n data = list(input())\n b.append(data)\n\n#N=4\n#M=2\n#a=[['a','s','a','s'],['a','a','s','s'],['s','a','a','s'],['s','a','a','a']]\n#b=[['s','a'],['a','s']]\n\nL = N-M\n\ndef check(i,j):\n ans=True\n for line in range(M):\n if (ans==False):\n break\n for row in range(M):\n if (a[i+line][j+row]!=b[line][row]):\n ans=False\n break\n return ans\n\nans=False\nfor i in range(L+1):\n if(ans==True):\n break\n for j in range(L+1):\n ansnow=check(i,j)\n print(ansnow,i,j)\n if(ansnow==True):\n ans=True\n break\nif(ans==True):\n print('Yes')\nelse:\n print('No')\n \n", "N, M = (int(i) for i in input().split())\na = []\nb = []\nfor i in range(N):\n data = list(input())\n a.append(data)\nfor i in range(M):\n data = list(input())\n b.append(data)\n \nL = N-M\n\ndef check(i,j):\n ans=True\n for line in range(L+1):\n for row in range(L+1):\n if (a[i+line][j+row]!=b[line][row]):\n ans=False\n break\n return ans\n\nans=False\nfor i in range(L+1):\n for j in range(L+1):\n ansnow=check(i,j)\n# print(ansnow,i,j)\n if(ansnow==True):\n ans=True\n break\nif(ans==True):\n print('Yes')\nelse:\n print('No')\n ", 'a, b = (int(i) for i in input().split())\n\nif a==1:\n a=14\nif b==1:\n b=14\n\nif a==b:\n print("Draw")\nelif a>b:\n print("Alice")\nelse:\n print("Bob")\n'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s975587124', 's983388109', 's787655513'] | [3064.0, 3064.0, 3064.0] | [24.0, 23.0, 22.0] | [809, 628, 158] |
p03803 | u823044869 | 2,000 | 262,144 | 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. | ['cardArray = list(map(int,input().split()))\n\nif cardArray[0]== carArray[1]:\n print("Draw")\nelif cardArray[0] < cardArray[1]:\n if cardArray[0] == 1:\n print("Alice")\n else:\n print("Bob")\nelse:\n if cardArray[1] == 1:\n print("Bob")\n else:\n print("Alice")\n', 'cardArray = list(map(int,input().split()))\n\nif cardArray[0]== carArray[1]:\n print("Draw")\nelif cardArray[0] < cardArray[1]:\n if cardArray[0] == 1:\n print("Alice")\n else:\n print("Bob")\nelse:\n print("Bob")\n', 'cardArray = list(map(int,input().split()))\n\nif cardArray[0]== carArray[1]:\n print("Draw")\nelif cardArray[0] < cardArray[1]:\n if cardArray[0] == 1:\n print("Alice")\n else:\n print("Bob")\nelse:\n if cardArray[1] == 1:\n print("Bob")\n print("Alice")\n', 'cardArray = list(map(int,input().split()))\n\nif cardArray[0]= carArray[1]:\n print("Draw")\nelif cardArray[0] < cardArray[1]:\n if cardArray[0] == 1:\n print("Alice")\n else:\n print("Bob")\nelse:\n print("Bob")\n', 'cardArray = list(map(int,input().split()))\n\nif cardArray[0]== cardArray[1]:\n print("Draw")\nelif cardArray[0] < cardArray[1]:\n if cardArray[0] == 1:\n print("Alice")\n else:\n print("Bob")\nelse:\n if cardArray[1] == 1:\n print("Bob")\n else:\n print("Alice")\n'] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s086325185', 's135741501', 's185240974', 's492000986', 's830343132'] | [3060.0, 2940.0, 3060.0, 2940.0, 3060.0] | [17.0, 17.0, 18.0, 17.0, 17.0] | [267, 214, 257, 213, 268] |
p03803 | u825343780 | 2,000 | 262,144 | 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. | ['a = list(map(int, input().split()))\nprint("Draw" if a[0] == a[1] else ("Alice" if a[0] < a[1] and a[1] != 1 else "Bob"))', 'a = list(map(int, input().split()))\nprint("Draw" if a[0] == a[1] else ("Alice" if a[0] > a[1] and a[1] != 1 or a[0] == 1 else "Bob"))'] | ['Wrong Answer', 'Accepted'] | ['s373532860', 's679482713'] | [9120.0, 9004.0] | [28.0, 33.0] | [120, 133] |
p03803 | u827141374 | 2,000 | 262,144 | 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. | ["a,b=map(int,input().split())\nif a==b:\n print('Draw')\nelif a==1:\n print('Alice')\nelif b==1 or b>a:\n print('Bob')", "a,b=map(int,input().split())\nif a==b:\n print('Draw')\nelif a==1:\n print('Alice')\nelif b==1 or b>a:\n print('Bob')\nelse:\n print('Alice')"] | ['Wrong Answer', 'Accepted'] | ['s336109909', 's055674839'] | [2940.0, 2940.0] | [18.0, 17.0] | [114, 137] |
p03803 | u842388336 | 2,000 | 262,144 | 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. | ['A,B = map(int,input().split())\nif A==1:\n A=100\nif B==1:\n B=100\n\nif A>B:\n print("Bob")\nelif A<B:\n print("Alice")\nelse:\n print("Draw")', 'A,B = map(int,input().split())\nif A==1:\n A=100\nif B==1:\n B=100\n\nif A>B:\n print("Alice")\nelif A<B:\n print("Bob")\nelse:\n print("Draw")'] | ['Wrong Answer', 'Accepted'] | ['s239910662', 's496494495'] | [3060.0, 3060.0] | [17.0, 19.0] | [137, 137] |
p03803 | u843318346 | 2,000 | 262,144 | 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. | ["a,b = map(int,input().split())\nif a==b:\n print('Draw')\nelif a==1:\n print('Alice')\nelif b==1:\n print('Bob')\nelif a>b:\n print('Alice')\nelse b>a:\n print('Bob')\n\n", "a,b = map(int,input().split())\nif a==b:\n print('Draw')\nelif a==1:\n print('Alice')\nelif b==1:\n print('Bob')\nelif a>b:\n print('Alice')\nelse:\n print('Bob')\n\n"] | ['Runtime Error', 'Accepted'] | ['s705385900', 's711337911'] | [2940.0, 2940.0] | [17.0, 17.0] | [163, 159] |
p03803 | u848647227 | 2,000 | 262,144 | 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. | ['a = list(map(int,input()))\nif a[0] == 1 and a[1] == 1:\n print("Draw")\nelif a[0] == 1:\n print("Alice")\nelif a[1] == 1:\n print("Bob")\nelse:\n if a[0] > a[1]:\n print("Alice")\n elif a[0] == a[1]:\n print("Draw")\n else:\n print("Bob")\n\n \n \n ', 'a = list(map(int,input().split(" ")))\nif a[0] == 1 and a[1] == 1:\n print("Draw")\nelif a[0] == 1:\n print("Alice")\nelif a[1] == 1:\n print("Bob")\nelse:\n if a[0] > a[1]:\n print("Alice")\n elif a[0] == a[1]:\n print("Draw")\n else:\n print("Bob")\n'] | ['Runtime Error', 'Accepted'] | ['s234808660', 's374442375'] | [3064.0, 3060.0] | [17.0, 17.0] | [258, 253] |
p03803 | u873849550 | 2,000 | 262,144 | 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. | ["A,B = map(int, input().split())\nprint('Alice' if cards.index(A) > cards.index(B) else 'Bob' if cards.index(A) < cards.index(B) else 'Draw' )", "cards = (2,3,4,5,6,7,8,9,10,11,12,13,1)\n\nA,B = map(int, input().split())\nif cards.index(A) > cards.index(B):\n print('Alice')\nif cards.index(A) < cards.index(B):\n print('Bob')\nelse:\n print('Draw')", "cards = [2,3,4,5,6,7,8,9,10,11,12,13,1]\n\nA,B = map(int, input().split())\nif cards.index(A) > cards.index(B):\n print('Alice')\nif cards.index(A) < cards.index(B):\n print('Bob')\nelse:\n print('Draw')", "A,B = map(int, input().split())\n\nif A == 1:\n A = 14\nif B == 1:\n B = 14\n\nif A > B:\n print('Alice')\nelif A == B:\n print('Draw')\nelse:\n print('Bob')"] | ['Runtime Error', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s163388668', 's709976520', 's920912203', 's083064088'] | [2940.0, 3060.0, 3060.0, 3060.0] | [17.0, 17.0, 17.0, 17.0] | [140, 204, 204, 160] |
p03803 | u873904588 | 2,000 | 262,144 | 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. | ['N,M = map(int, input().split())\na=[input() for i in range(N)]\nb=[input() for i in range(M)]\n\nans = 0\nfor i in range(N-M+1):\n for j in range(N-M+1):\n t = [k[j:j+M] for k in a[i:i+M]]\n if t==b: ans =1\n\nprint("Yes" if ans else "No")\n', "A,B = map(int, input().split())\nif(A==B):\n print('Draw')\nelif A==1:\n print('Alice')\nelif B==1:\n print('Bob')\nelif A>B:\n print('Alice')\nelif B>A:\n print('Bob')\n"] | ['Runtime Error', 'Accepted'] | ['s282666179', 's587372954'] | [3060.0, 2940.0] | [17.0, 18.0] | [247, 174] |
p03803 | u882200107 | 2,000 | 262,144 | 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. | ['A, B = map(int, input().split(" "))\nif A == 1:\n A = 14\nif B == 1:\n B = 14\nif A > B:\n print("Bob")\nelif B < A:\n print("Alice")\nelse:\n print("Draw")', 'A,B = map(int, input().split())\nif A == 1:\n A = 14\nif B == 1:\n B = 14\n\nif A > B:\n print("Alice")\nelif B > A:\n print("Bob")\nelse:\n print("Draw")'] | ['Wrong Answer', 'Accepted'] | ['s667638502', 's223524157'] | [2940.0, 3060.0] | [17.0, 17.0] | [161, 158] |
p03803 | u886655280 | 2,000 | 262,144 | 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. | ['\n\nimport copy\nimport sys\ninput = sys.stdin.readline\n\n\nN, M = map(int, input().split())\n\n\n\nGraph_list = [[] for i in range(N)]\n\n\nfor i in range(M):\n a, b = map(int, input().split())\n a += -1\n b += -1\n\n \n Graph_list[a].append(b)\n Graph_list[b].append(a)\n\nans_count = 0\nthrowgh_point_list = [-1 for i in range(N)]\n\ndef dfs(i, current, throwgh_point_list, ans_point_list): \n \n if i >= N:\n \n if throwgh_point_list in ans_point_list:\n return\n\n \n \n if set(throwgh_point_list) == set(list(range(N))):\n global ans_count\n ans_count += 1\n ans_point_list.append(copy.copy(throwgh_point_list))\n return\n\n for j in range(len(Graph_list[current])):\n \n throwgh_point_list[i] = current\n\n \n dfs(i + 1, Graph_list[current][j], throwgh_point_list, ans_point_list)\n\ndfs(0, 0, throwgh_point_list, [])\nprint(ans_count)', "\n\nA, B = map(int, input().split())\nAlice = 'Alice'\nBob = 'Bob'\nDraw = 'Draw'\n\nif A == B:\n print(Draw)\nelif A == 1 and B != 1:\n print(Alice)\nelif A != 1 and B == 1:\n print(Bob)\nelif A > B:\n print(Alice)\nelif A < B:\n print(Bob)\n\n"] | ['Runtime Error', 'Accepted'] | ['s518856372', 's157352340'] | [3444.0, 2940.0] | [22.0, 17.0] | [1409, 293] |
p03803 | u888512581 | 2,000 | 262,144 | 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. | ["N, M = map(int, input().split())\nA = [list(input()) for i in range(N)]\nB = [list(input()) for i in range(M)]\nans = 'No'\nfor i in range(N - M +1):\n for j in range(N - M +1):\n count = 0\n for row in range(M):\n for col in range(M):\n if B[row][col] == A[i + row][j + col]:\n count += 1\n if count == M * M:\n ans = 'Yes'\n\nprint(ans)", "a, b = (int(x) for x in input().split())\nif a == b:\n print('Draw')\nelif a == 1:\n print('Alice')\nelif b == 1:\n print('Bob')\nelif a > b:\n print('Alice')\nelif a < b:\n print('Bob')"] | ['Runtime Error', 'Accepted'] | ['s320121449', 's787987154'] | [3064.0, 2940.0] | [18.0, 17.0] | [404, 181] |
p03803 | u897328029 | 2,000 | 262,144 | 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. | ['import itertools\n\nn, m = list(map(int, input().split()))\n\nab_list = []\n\nfor _ in range(0, m):\n a, b = list(map(int, input().split()))\n ab_list.append((a, b))\n ab_list.append((b, a))\n\n\nl = range(1, n+1)\ncount = 0\nroots = [v for v in itertools.permutations(l, n) if v[0] == 1]\n\nfor v in roots:\n is_ok = True\n for i, _ in enumerate(list(v)[:-1]):\n \n target_edge = (list(v)[i], list(v)[i+1])\n if (target_edge not in ab_list):\n is_ok = False\n\n if is_ok:\n count += 1\n\nprint(count)\n', "\n# A - One Card Poker\na, b = list(map(int, input().split()))\n\nif a == 1:\n a = 100\nif b == 1:\n b = 100\n\nif a == b:\n answer = 'Draw'\nelif a < b:\n answer = 'Bob'\nelif a > b:\n answer = 'Alice'\n\nprint(answer)\n"] | ['Runtime Error', 'Accepted'] | ['s650665618', 's441516873'] | [3064.0, 2940.0] | [18.0, 17.0] | [590, 270] |
p03803 | u901598613 | 2,000 | 262,144 | 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. | ['a,b=map(int,input().split())\nif a==b :\n print("Draw")\nelif b==1 or a<b or a!=1 :\n print("Bob")\nelse:\n print("Alice")', 'a,b=map(int,input().split())\nif a==b :\n print("Draw")\nelif b==1 or a!=1 or a<b :\n print("Bob")\nelse:\n print("Alice")', 'a,b=map(int,input().split())\nif a==b :\n print("Draw")\nelif (b==1 or a<b) and a!=1:\n print("Bob")\nelse:\n print("Alice")'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s373776595', 's606786854', 's252593909'] | [2940.0, 2940.0, 2940.0] | [18.0, 18.0, 17.0] | [126, 127, 128] |
p03803 | u902693400 | 2,000 | 262,144 | 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. | ['a,b= int(input().split())\n\nif(a==1):\n a= 14\n\nif(b==1):\n b= 14\n\nif(a-b>0):\n print("Alice")\nelif(a-b< 0):\n print("Bob")\nelse:\n print("Draw")\n ', 'a,b= input().split()\n\nint(a)\nint(b)\n\nif(a==\'1\'):\n a= 14\n\nif(b==\'1\'):\n b= 14\n\nif(int(a)-int(b)>0):\n print("Alice")\nelif(int(a)-int(b)< 0):\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s340333644', 's087018462'] | [2940.0, 3060.0] | [17.0, 17.0] | [146, 177] |
p03803 | u905582793 | 2,000 | 262,144 | 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. | ['A = int(input())\nB = int(input())\nif (A+11)%13 > (B+11)%13:\n print("Alice")\nelif (A+11)%13 < (B+11)%13:\n print("Bob")\nelse:\n print("Draw")', 'A,B=map(int,input().split())\nif (A+11)%13 > (B+11)%13:\n print("Alice")\nelif (A+11)%13 < (B+11)%13:\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s292354246', 's991224833'] | [3060.0, 2940.0] | [17.0, 17.0] | [141, 136] |
p03803 | u912862653 | 2,000 | 262,144 | 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. | ["A, B = int(input())\n\nif A==B:\n\tprint('Draw')\nelif A>B or A==1:\n\tprint('Alice')\nelse:\n\tprint('Bob')", "A, B = list(map(int, input().split()))\n\nif A==1:\n\tif A==B:\n\t\tprint('Draw')\n\telse:\n\t\tprint('Alice')\nelif B==1:\n\tprint('Bob')\nelse:\n\tif A==B:\n\t\tprint('Draw')\n\telif A>B:\n\t\tprint('Alice')\n\telse:\n\t\tprint('Bob')"] | ['Runtime Error', 'Accepted'] | ['s792863349', 's542210901'] | [2940.0, 2940.0] | [17.0, 17.0] | [98, 205] |
p03803 | u917558625 | 2,000 | 262,144 | 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. | ["A,B=map(int,input().split())\nif A>B:\n print('Bob')\nelif A==B:\n print('Draw')\nelse:\n print('Alice')", "A,B=map(int,input().split())\nif A==1 or B==1:\n if A==B:\n print('Draw')\n exit()\n else:\n if A==1:\n print('Alice')\n exit()\n else:\n print('Bob')\n exit()\nif A>B:\n print('Alice')\nelif A==B:\n print('Draw')\nelse:\n print('Bob')"] | ['Wrong Answer', 'Accepted'] | ['s272898212', 's084623211'] | [8928.0, 9180.0] | [29.0, 29.0] | [101, 255] |
p03803 | u923279197 | 2,000 | 262,144 | 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. | ["a.b=map(int,input().split())\nif a==1:\n if b==1:\n print('Draw')\n else:\n print('Alice')\nelse:\n if b==1:\n print('Bob')\n else:\n if a>b:\n print('Alice')\n elif a==b:\n print('Draw')\n else:\n print('Bob')", "a,b=map(int,input().split())\nif a == 1:\n a +=13\nif b == 1:\n b +=13\nif a>b:\n print('Alice')\nelif b>a:\n print('Bob')\nelse:\n print('Draw')"] | ['Runtime Error', 'Accepted'] | ['s047407116', 's100752983'] | [3060.0, 3060.0] | [17.0, 18.0] | [282, 150] |
p03803 | u924308178 | 2,000 | 262,144 | 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. | ['a,b = map(list(map,input().split(" ")))\nif a>b:\n print("Alice")\nelif a<b :\n print("Bob")\nelse:\n print("Draw")', 'a,b = list(map(int,input().split(" ")))\n\nif a==b:\n print("Draw")\n exit()\nelif b==1:\n print("Bob")\n exit()\nelif a==1:\n print("Alice")\n exit()\nif a>b:\n print("Alice")\nelif a<b :\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s464918572', 's181460151'] | [2940.0, 3060.0] | [18.0, 17.0] | [118, 237] |
p03803 | u931489673 | 2,000 | 262,144 | 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. | ['a,b=map(int,input().split())\ndef one_14(num):\n if num==1:\n return 14\na=one_14(a)\nb=one_14(b)\nif a > b:\n print("Alice")\nelif b < a:\n print("Bob")\nelse:\n print("Draw")', 'a,b=map(int,input().split())\ndef one_14(num):\n if num==1:\n return 14\n else:\n return num\na=one_14(a)\nb=one_14(b)\nif a > b:\n print("Alice")\nelif a < b:\n print("Bob")\nelse:\n print("Draw")\n'] | ['Runtime Error', 'Accepted'] | ['s112756942', 's212399411'] | [3060.0, 2940.0] | [17.0, 17.0] | [172, 196] |
p03803 | u932370518 | 2,000 | 262,144 | 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. | ['def main():\n x = input()\n l = x.split(" ")\n A = int(l[0])\n B = int(l[1])\n\n if A == B:\n print("Draw")\n elif A == 1:\n print("Alice")\n elif B == 1:\n print("Bob")\n elif A > B :\n print("Alece")\n elif A < B :\n print("Bob")\n\nif __name__ == \'__main__\':\n main()', 'def main():\n x = input()\n l = x.split(" ")\n A = int(l[0])\n B = int(l[1])\n\n if A == B:\n print("Drow")\n elif A == 1:\n print("Alice")\n elif B == 1:\n print("Bob")\n elif A > B :\n print("Alece")\n elif A < B :\n print("Bob")\n\nif __name__ == \'__main__\':\n main()', 'def main():\n x = input()\n l = x.split(" ")\n A = int(l[0])\n B = int(l[1])\n\n if A == B:\n print("Draw")\n elif A == 1:\n print("Alice")\n elif B == 1:\n print("Bob")\n elif A > B :\n print("Alice")\n elif A < B :\n print("Bob")\n\nif __name__ == \'__main__\':\n main()'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s144367802', 's298190049', 's158206620'] | [3060.0, 3060.0, 3064.0] | [17.0, 18.0, 17.0] | [317, 317, 317] |
p03803 | u932719058 | 2,000 | 262,144 | 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. | ["a, b = map(int, input().split())\nif a != 1 and b != 1 :\n if a > b :\n print('Alice')\n if a < b :\n print('Bob')\n else :\n print('Draw')\nelif a == 1 and b != 1 :\n print('Alice')\nelif a != 1 and b == 1 :\n print('Bob')\nelse :\n print('Draw')", "a, b = map(int, input().split())\nif a != 1 and b != 1 :\n if a > b :\n print('Alice')\n elif a < b :\n print('Bob')\n else :\n print('Draw')\nelif a == 1 and b != 1 :\n print('Alice')\nelif a != 1 and b == 1 :\n print('Bob')\nelse :\n print('Draw')"] | ['Wrong Answer', 'Accepted'] | ['s833222678', 's591186471'] | [3060.0, 3060.0] | [17.0, 17.0] | [249, 251] |
p03803 | u941047297 | 2,000 | 262,144 | 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. | ["a = list(map(int, input().split()))\na = [i for i in a if i != 1 else 14]\nif a[0] > a[1]:\n print('Alice')\nelif a[0] == a[1]:\n print('Draw')\nelse:\n print('Bob')", "a = list(map(int, input().split()))\na = [i if i != 1 else 14 for i in a]\nif a[0] > a[1]:\n print('Alice')\nelif a[0] == a[1]:\n print('Draw')\nelse:\n print('Bob')"] | ['Runtime Error', 'Accepted'] | ['s747177939', 's750649109'] | [2940.0, 3060.0] | [17.0, 17.0] | [167, 167] |
p03803 | u946386741 | 2,000 | 262,144 | 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. | ['A, B = map(int, input().split())\n\nif A == 1:\n A = 14\nif B == 1:\n B = 14\n\nif A > B:\n print("Aliice")\nelif B > A:\n print("Bob")\nelse:\n print("Draw")\n', 'A, B = map(int, input().split())\n\nif A == 1:\n A = 14\nif B == 1:\n B = 14\n\nif A > B:\n print("Alice")\nelif B > A:\n print("Bob")\nelse:\n print("Draw")\n'] | ['Wrong Answer', 'Accepted'] | ['s227001495', 's234252811'] | [2940.0, 2940.0] | [17.0, 17.0] | [162, 161] |
p03803 | u961606648 | 2,000 | 262,144 | 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. | ['A = input("")\nB = input("")\n\nif A > B:\n print("Alice")\nif A == B:\n print("Draw")\nif A < B:\n print("Bob")', 'A = int(input())\nB = int(input())\n\nif A > B:\n print("Alice")\nif A == B:\n print("Draw")\nif A < B:\n print("Bob")', 'A = input()\nB = input()\n\nif A > B:\n print("Alice")\nif A == B:\n print("Draw")\nif A < B:\n print("Bob")', 'l = input().split()\n\nA = int(l[0])\nB = int(l[1])\n\nif A == 1:\n A = 14\nif B == 1:\n B = 14\n \nif A > B:\n print("Alice")\nif A == B:\n print("Draw")\nif A < B:\n print("Bob")'] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s017476950', 's253056390', 's809733671', 's053619764'] | [2940.0, 2940.0, 2940.0, 3060.0] | [17.0, 18.0, 17.0, 17.0] | [113, 119, 109, 183] |
p03803 | u971091945 | 2,000 | 262,144 | 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. | ['a,b=map(int, input().split())\n\nif a>b:\n print(Alice)\nelif a<b:\n print(Bob)\nelse:\n print(Drow)', "a,b=map(int, input().split())\n\nif a==1:\n a+=13\n\nif b==1:\n b+=13\n\nif a>b:\n print('Alice')\nelif a<b:\n print('Bob')\nelse:\n print('Draw')"] | ['Runtime Error', 'Accepted'] | ['s407179307', 's803320226'] | [2940.0, 3060.0] | [17.0, 17.0] | [102, 148] |
p03803 | u977193988 | 2,000 | 262,144 | 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. | ["A,B=map(int,input().split())\nN=[2,3,4,5,6,7,8,9,10,11,12,13,1]\nif N.index(A)<N.index(B):\n print('Bob')\nelif N.index(A)>N.index(B):\n print('Alice')\nelse N.index(A)==N.index(B):\n print('Draw')", "A,B=map(int,input().split())\nN=[2,3,4,5,6,7,8,9,10,11,12,13,1]\na=N.index(A)\nb=N.index(B)\nif a<b:\n print('Bob')\nelif a>b:\n print('Alice')\nelse:\n print('Draw')\n "] | ['Runtime Error', 'Accepted'] | ['s678245595', 's480975605'] | [2940.0, 3060.0] | [17.0, 17.0] | [199, 171] |
p03803 | u982594421 | 2,000 | 262,144 | 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. | ["a, b = map(int, input())\nif a == 1:\n a == 14\nif b == 1:\n b == 14\nif a > b:\n print('Alice')\nelif a == b:\n print('Draw')\nelse:\n print('Bob')", "a, b = map(int, input())\nif a == 1:\n a = 14\nif b == 1:\n b = 14\nif a > b:\n print('Alice')\nelif a == b:\n print('Draw')\nelse:\n print('Bob')", "a, b = map(int, input().split())\nif a == 1:\n a = 14\nif b == 1:\n b = 14\nif a > b:\n print('Alice')\nelif a == b:\n print('Draw')\nelse:\n print('Bob')"] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s081134070', 's615973105', 's795147970'] | [3060.0, 3060.0, 3060.0] | [17.0, 17.0, 17.0] | [143, 141, 149] |
p03803 | u982762220 | 2,000 | 262,144 | 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. | ["A, B = map(int(input().split()))\nif A == B:\n print('Draw')\nelif A == 1:\n print('Alice')\nelif B == 1:\n print('Bob')\nelif A > B:\n print('Alice')\nelse:\n print('Bob')", "A, B = map(int, input().split())\nif A == B:\n print('Draw')\nelif A == 1:\n print('Alice')\nelif B == 1:\n print('Bob')\nelif A > B:\n print('Alice')\nelse:\n print('Bob')"] | ['Runtime Error', 'Accepted'] | ['s000761098', 's115179298'] | [2940.0, 2940.0] | [17.0, 17.0] | [167, 167] |
p03803 | u985443069 | 2,000 | 262,144 | 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. | ['from itertools import permutations\n\ndef f(n, m, uu, vv):\n a = [[0] *n for _ in range(n)]\n for u, v in zip(uu, vv):\n a[u][v] = 1\n a[v][u] = 1\n res = 0\n for p in permutations(range(n)):\n if p[0] != 0:\n break\n ok = True\n for i in range(n - 1):\n if a[p[i]][p[i+1]] == 0:\n ok = False\n break\n if ok:\n res += 1\n return res\n\nn , m = map(int, input().split())\na = []\nb = []\nfor k in range(m):\n _a, _b = map(int, input().split())\n _a -= 1\n _b -= 1\n a.append(_a)\n b.append(_b)\nprint(f(n, m, a, b))\n', "def f(a, b):\n if a == b:\n return 'Draw'\n if a > b:\n return 'Alice'\n if a < b:\n return 'Bob'\n\na, b = map(int, input().split())\nif a == 1:\n a += 100\nif b == 1:\n b += 100\nprint(f(a, b))\n\n"] | ['Runtime Error', 'Accepted'] | ['s865716859', 's286654453'] | [3064.0, 2940.0] | [17.0, 17.0] | [622, 220] |
p03804 | u006425112 | 2,000 | 262,144 | You are given an image A composed of N rows and N columns of pixels, and a template image B composed of M rows and M columns of pixels. A pixel is the smallest element of an image, and in this problem it is a square of size 1×1. Also, the given images are binary images, and the color of each pixel is either white or black. In the input, every pixel is represented by a character: `.` corresponds to a white pixel, and `#` corresponds to a black pixel. The image A is given as N strings A_1,...,A_N. The j-th character in the string A_i corresponds to the pixel at the i-th row and j-th column of the image A (1≦i,j≦N). Similarly, the template image B is given as M strings B_1,...,B_M. The j-th character in the string B_i corresponds to the pixel at the i-th row and j-th column of the template image B (1≦i,j≦M). Determine whether the template image B is contained in the image A when only parallel shifts can be applied to the images. | ['import numpy as np\nimport sys\n\nn,m = map(int, sys.stdin.readline().split())\na = np.array([list(input()) for _ in range(n)])\nb = np.array([list(input()) for _ in range(m)])\n\nflag = False\n\nprint(a)\nprint(b)\n\nfor i in range(n-m+1):\n for j in range(n-m+1):\n if (a[i:i+m,j:j+m] == b).all():\n flag = True\n break\n\nprint("Yes" if flag else "No")', 'import numpy as np\nimport sys\n\nn,m = map(int, sys.stdin.readline().split())\na = np.array([list(input()) for _ in range(n)])\nb = np.array([list(input()) for _ in range(m)])\n\nflag = False\n\nfor i in range(n-m+1):\n for j in range(n-m+1):\n if (a[i:i+m,j:j+m] == b).all():\n flag = True\n break\n\nprint("Yes" if flag else "No")'] | ['Wrong Answer', 'Accepted'] | ['s211867019', 's638892342'] | [14456.0, 12408.0] | [171.0, 169.0] | [369, 350] |
p03804 | u010110540 | 2,000 | 262,144 | You are given an image A composed of N rows and N columns of pixels, and a template image B composed of M rows and M columns of pixels. A pixel is the smallest element of an image, and in this problem it is a square of size 1×1. Also, the given images are binary images, and the color of each pixel is either white or black. In the input, every pixel is represented by a character: `.` corresponds to a white pixel, and `#` corresponds to a black pixel. The image A is given as N strings A_1,...,A_N. The j-th character in the string A_i corresponds to the pixel at the i-th row and j-th column of the image A (1≦i,j≦N). Similarly, the template image B is given as M strings B_1,...,B_M. The j-th character in the string B_i corresponds to the pixel at the i-th row and j-th column of the template image B (1≦i,j≦M). Determine whether the template image B is contained in the image A when only parallel shifts can be applied to the images. | ["N = int(input())\nM = int(input())\n\nA = [list(input()) for _ in range(N)]\nB = [list(input()) for _ in range(M)]\n\nfor i in range(N-M+1):\n for j in range(N-M+1):\n flag = True\n for k in range(M):\n for l in range(M):\n if A[i+k][j+l] != B[k][l]:\n flag = False\n break\n if not flag:\n break\n \n if flag:\n print('Yes')\n exit()\n\nprint('No')", "N, M = map(int, input().split())\n\nA = [list(input()) for _ in range(N)]\nB = [list(input()) for _ in range(M)]\n\nfor i in range(N-M+1):\n for j in range(N-M+1):\n flag = True\n for k in range(M):\n for l in range(M):\n if A[i+k][j+l] != B[k][l]:\n flag = False\n break\n if not flag:\n break\n \n if flag:\n print('Yes')\n exit()\n\nprint('No')"] | ['Runtime Error', 'Accepted'] | ['s737834903', 's687067837'] | [3064.0, 3064.0] | [18.0, 18.0] | [471, 470] |
p03804 | u010437136 | 2,000 | 262,144 | You are given an image A composed of N rows and N columns of pixels, and a template image B composed of M rows and M columns of pixels. A pixel is the smallest element of an image, and in this problem it is a square of size 1×1. Also, the given images are binary images, and the color of each pixel is either white or black. In the input, every pixel is represented by a character: `.` corresponds to a white pixel, and `#` corresponds to a black pixel. The image A is given as N strings A_1,...,A_N. The j-th character in the string A_i corresponds to the pixel at the i-th row and j-th column of the image A (1≦i,j≦N). Similarly, the template image B is given as M strings B_1,...,B_M. The j-th character in the string B_i corresponds to the pixel at the i-th row and j-th column of the template image B (1≦i,j≦M). Determine whether the template image B is contained in the image A when only parallel shifts can be applied to the images. | ['import io\nsys.stdin = io.StringIO("""3 2\n#.#\n.#.\n#.#\n#.\n.#\n""")\nimport sys\ndef main():\n t = sys.stdin.readline()\n t1 = t.rstrip()\n t2 = t1.split(\' \')\n stra = [] \n for i in range(int(t2[0])):\n y = sys.stdin.readline()\n t = y.rstrip()\n stra += [t]\n strb = [] \n for i in range(int(t2[1])):\n y = sys.stdin.readline()\n t = y.rstrip()\n strb += [t]\n\n suma = 0\n for x in strb:\n for y in stra:\n print(x,y)\n if x in y:\n suma +=1 \n if int(t2[0])*int(t2[1])==suma:\n print("yes")\n \n print(stra,strb)\nmain()', '\nimport sys\ndef main():\n t = sys.stdin.readline()\n t1 = t.rstrip()\n t2 = t1.split(\' \')\n stra = [] \n for i in range(int(t2[0])):\n y = sys.stdin.readline()\n t = y.rstrip()\n stra += [t]\n strb = [] \n for i in range(int(t2[1])):\n y = sys.stdin.readline()\n t = y.rstrip()\n strb += [t]\n\n suma = 0\n for x in strb:\n for y in stra:\n print(x,y)\n if x in y:\n suma +=1 \n if int(t2[0])*int(t2[1])==suma:\n print("yes")\n \n print(stra,strb)\nmain()', 'import sys\ndef main():\n t = sys.stdin.readline()\n t1 = t.rstrip()\n t2 = t1.split(\' \')\n stra = [] \n for i in range(int(t2[0])):\n y = sys.stdin.readline()\n t = y.rstrip()\n stra += [t]\n strb = [] \n for i in range(int(t2[1])):\n y = sys.stdin.readline()\n t = y.rstrip()\n strb += [t]\n\n suma = 0\n for x in strb:\n for y in stra:\n if x in y:\n suma +=1 \n if int(t2[0])*int(t2[1])==suma:\n print("yes")\n\nmain()', 'import sys\ndef main():\n t = sys.stdin.readline()\n t1 = t.rstrip()\n t2 = t1.split(\' \')\n stra = [] \n for i in range(int(t2[0])):\n y = sys.stdin.readline()\n t = y.rstrip()\n stra += [t]\n strb = [] \n for i in range(int(t2[1])):\n y = sys.stdin.readline()\n t = y.rstrip()\n strb += [t]\n \n suma = 0\n for x in strb:\n for y in stra:\n if x in y:\n suma +=1 \n if int(t2[0])*int(t2[1])==suma:\n print("Yes")\n else:\n print("No")\nmain()\n'] | ['Runtime Error', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s172801799', 's570567287', 's644980288', 's851837512'] | [3064.0, 3316.0, 3064.0, 3064.0] | [18.0, 20.0, 18.0, 18.0] | [622, 559, 510, 541] |
p03804 | u017810624 | 2,000 | 262,144 | You are given an image A composed of N rows and N columns of pixels, and a template image B composed of M rows and M columns of pixels. A pixel is the smallest element of an image, and in this problem it is a square of size 1×1. Also, the given images are binary images, and the color of each pixel is either white or black. In the input, every pixel is represented by a character: `.` corresponds to a white pixel, and `#` corresponds to a black pixel. The image A is given as N strings A_1,...,A_N. The j-th character in the string A_i corresponds to the pixel at the i-th row and j-th column of the image A (1≦i,j≦N). Similarly, the template image B is given as M strings B_1,...,B_M. The j-th character in the string B_i corresponds to the pixel at the i-th row and j-th column of the template image B (1≦i,j≦M). Determine whether the template image B is contained in the image A when only parallel shifts can be applied to the images. | ["n,m=map(int,input().split())\na=[list(input()) for a in range(n)]\nb=[list(input()) for a in range(m)]\nc=0\nfor p in range(n-m+1):\n for q in range(n-m+1):\n if b[0]==a[p][q:q+m]:\n for r in range(1,m):\n if b[r]!=a[p+r][q:q+m]:break\n c=1\n break\nif c==0:print('No')\nelse:print('Yes')", "n,m=map(int,input().split())\na=[list(input()) for a in range(n)]\nb=[list(input()) for a in range(m)]\nc=0;d=0\nfor p in range(n-m+1):\n for q in range(n-m+1):\n if b[0]==a[p][q:q+m]:\n for r in range(m):\n if b[r]!=a[p+r][q:q+m]:d+=1\n if d==0:c=1\n else:d=0\nif c==0:print('No')\nelse:print('Yes')"] | ['Runtime Error', 'Accepted'] | ['s094703278', 's871595875'] | [3060.0, 3064.0] | [17.0, 18.0] | [304, 314] |
p03804 | u027929618 | 2,000 | 262,144 | You are given an image A composed of N rows and N columns of pixels, and a template image B composed of M rows and M columns of pixels. A pixel is the smallest element of an image, and in this problem it is a square of size 1×1. Also, the given images are binary images, and the color of each pixel is either white or black. In the input, every pixel is represented by a character: `.` corresponds to a white pixel, and `#` corresponds to a black pixel. The image A is given as N strings A_1,...,A_N. The j-th character in the string A_i corresponds to the pixel at the i-th row and j-th column of the image A (1≦i,j≦N). Similarly, the template image B is given as M strings B_1,...,B_M. The j-th character in the string B_i corresponds to the pixel at the i-th row and j-th column of the template image B (1≦i,j≦M). Determine whether the template image B is contained in the image A when only parallel shifts can be applied to the images. | ['N, M = map(int, input().split())\nA = [input() for _ in range(N)]\nB = [input() for _ in range(M)]\n\nfor i in range(N - M + 1):\n for j in range(N - M + 1):\n ok = True\n if A[i + j][j:j + M] != B[k]:\n ok = False\n break\n if ok:\n print("Yes")\n exit()\nprint("No")', 'N, M = map(int, input().split())\nA = [input() for _ in range(N)]\nB = [input() for _ in range(M)]\n\nfor i in range(N - M + 1):\n for j in range(N - M + 1):\n ok = True\n if A[i + k][j:j + M] != B[k]:\n ok = False\n break\n if ok:\n print("Yes")\n exit()\nprint("No")', 'N, M = map(int, input().split())\nA = [input() for _ in range(N)]\nB = [input() for _ in range(M)]\nans = "No"\n\nfor i in range(N - M + 1):\n for j in range(N - M + 1):\n if [a[j:j+M] for a in A[i:i+M]] == B:\n ans = "Yes"\nprint(ans)'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s604573449', 's626190580', 's055700743'] | [3060.0, 3060.0, 3060.0] | [18.0, 17.0, 20.0] | [285, 285, 235] |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.