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 | u178474644 | 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 = input()\n# x = x.replace(1,14)\n\nls_x = x.split()\n\n\n\nfor i in range(len(ls_x)):\n ls_x[i] = int(ls_x[i])\n\nprint(ls_x)\n\nif ls_x[0] == ls_x[1]:\n print("Draw")\n\nif ls_x[0] == 1:\n print("Alice")\n\nelif ls_x[1] == 1:\n print("Bob")\n\nelif ls_x[0] > ls_x[1]:\n print("Alice")\n\nelif ls_x[0] < ls_x[1]:\n print("Bob")', 'x = input()\n# x = x.replace(1,14)\n\nls_x = x.split()\n\n\n\nfor i in range(len(ls_x)):\n ls_x[i] = int(ls_x[i])\n\nif ls_x[0] == ls_x[1]:\n print("Draw")\n\nelif ls_x[0] == 1:\n print("Alice")\n\nelif ls_x[1] == 1:\n print("Bob")\n\nelif ls_x[0] > ls_x[1]:\n print("Alice")\n\nelif ls_x[0] < ls_x[1]:\n print("Bob")'] | ['Wrong Answer', 'Accepted'] | ['s168582857', 's408486903'] | [3064.0, 3060.0] | [17.0, 18.0] | [413, 402] |
p03803 | u181215519 | 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" )\nelseif 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() )\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', 'Wrong Answer', 'Accepted'] | ['s922550528', 's948880410', 's287045895'] | [2940.0, 2940.0, 3060.0] | [17.0, 18.0, 17.0] | [125, 121, 169] |
p03803 | u187205913 | 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 :\n print('Bob')\nelif a>b:\n print('Alice')\nelse:\n print('Bob')", "a,b = map(int,input().split())\ncard = [2,3,4,5,6,7,8,9,10,11,12,13,1]\nif card.index(a)==card.index(b):\n print('Draw')\nelif card.index(a)>card.index(b):\n print('Alice')\nelse:\n print('Bob')"] | ['Runtime Error', 'Accepted'] | ['s056869094', 's314427883'] | [2940.0, 3060.0] | [17.0, 17.0] | [161, 190] |
p03803 | u188138642 | 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())\nab = [[] for _ in range(N)]\n\nfor _ in range(M):\n a, b = map(int,input().split())\n ab[a-1].append(b-1)\n ab[b-1].append(a-1)\n\ncount = 0\n\ndef dfs(i, now, done):\n global count\n if i == N-1:\n count += 1\n return\n\n for j in ab[now]:\n if j not in done:\n dfs(i+1, j, done + [j])\n return\n\ndfs(0, 0, [0])\nprint(count)\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')"] | ['Runtime Error', 'Accepted'] | ['s514861740', 's135902019'] | [9204.0, 9096.0] | [21.0, 25.0] | [393, 169] |
p03803 | u190178779 | 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\nA,B = map(int,input.split())\nif A < 0 or A > 13 or B < 0 or B > 13:\n sys.exit()\n\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")\n sys.exit()\n\nif A > B:\n print("Alice")\nelif B > A:\n print("Bob")\nelse:\n print("Draw")', 'import sys\nA,B = map(int,input().split())\nif A < 0 or A > 13 or B < 0 or B > 13:\n sys.exit()\n\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")\n sys.exit()\n\nif A > B:\n print("Alice")\nelif B > A:\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s700479306', 's713277342'] | [9064.0, 9196.0] | [21.0, 30.0] | [328, 330] |
p03803 | u201082459 | 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 > 13 or a == 1:\n print('Alice')\nelif a < b < 13 or b == 1:\n print('Bob')\nelif a == b:\n print('Draw')", "a,b = map(int,input().split())\nif 1 > a > b > 13 or a == 1:\n print('Alice')\nelif 1 < a < b < 13 or b == 1:\n print('Bob')\nelse:\n print('Draw')", "a,b = map(int,input().split())\nif a > b > 13 or a == 1:\n print('Alice')\nelif a < b < 13 or b == 1:\n print('Bob')\nelse:\n print('Draw')", "a,b = map(int,input().split())\nif a == b:\n print('Draw')\nelif a < b < 13 or b == 1:\n print('Bob')\nelif a > b > 13 or a == 1:\n print('Alice')", "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 a < b:\n print('Bob')\nelse:\n print('Draw')"] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s492096736', 's603304535', 's610617010', 's638100874', 's924307461'] | [2940.0, 2940.0, 2940.0, 2940.0, 3060.0] | [17.0, 17.0, 17.0, 17.0, 17.0] | [143, 144, 136, 143, 148] |
p03803 | u210440747 | 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\nif __name__=="__main__":\n a, b = list(map(int, input().split(" ")))\n if(a == 1):\n\ta = 14\n if(b == 1):\n\tb = 14\n if(a > b):\n sys.stdout.write("Alice")\n elif(a == b):\n sys.stdout.write("Draw")\n else:\n sys.stdout.write("Bob")', 'import numpy as np\n\nif __name__=="__main__":\n inputs_number = lambda : [int(x) for x in input().split()]\n N, Ma, Mb = inputs_number()\n drugs = np.array([inputs_number() for i in range(N)])\n\n inf = 100*N + 1\n dp = np.ones((N,N*10,N*10)) * inf\n dp[0,0,0] = 0\n for i in range(0, N-1):\n\tfor ca in range(N*10):\n for cb in range(N*10):\n\t\tif(dp[i,ca,cb]==inf):\n continue\n\t\tdp[i+1,ca,cb]=np.min([dp[i+1,ca,cb],dp[i,ca,cb]]);\n\t\tdp[i+1,ca+drugs[i,0],cb+drugs[i,1]]=np.min([dp[i+1,ca+drugs[i,0],cb+drugs[i,1]],dp[i,ca,cb]+drugs[i,2]]);\n\n ans = inf\n for i in range(1, N):\n\tfor ca in range(1, N*10):\n for cb in range(1, N*10):\n\t\tif(Ma*cb == Mb*ca and dp[i,ca,cb] < ans):\n ans = dp[i,ca,cb]\n if(ans==inf):\n\tans = -1\n print(int(ans))', 'import sys\nif __name__=="__main__":\n a, b = list(map(int, input().split(" ")))\n if(a > b):\n\tsys.stdout.write("Alice")\n elif(a == b):\n\tsys.stdout.write("Draw")\n else:\n\tsys.stdout.write("Bob")', '#coding: utf-8\n\nif __name__=="__main__":\n a, b = list(map(int, input().replace("\\n","").split(" ")))\n if(a > b):\n\tprint("Alice")\n elif(a == b):\n\tprint("Draw")\n else:\n\tprint("Bob")\n', 'import numpy as np\n\nif __name__=="__main__":\n inputs_number = lambda : [int(x) for x in input().split()]\n N, Ma, Mb = inputs_number()\n drugs = [inputs_number() for i in range(N)]\n inf = 100*N + 1\n dp = np.ones((N+1,N*10+1,N*10+1)) * inf\n dp[0,0,0] = 0.0\n\n for i in range(N):\n\tfor ca in range(N*10+1):\n for cb in range(N*10+1):\n\t\tif(dp[i,ca,cb]==inf):\n continue\n dp[i+1,ca,cb]=np.min([dp[i+1,ca,cb],dp[i,ca,cb]])\n dp[i+1,ca+drugs[i][0],cb+drugs[i][1]]=np.min([dp[i+1,ca+drugs[i][0],cb+drugs[i][1]],dp[i,ca,cb]+drugs[i][2]])', 'if __name__=="__main__":\n a, b = list(map(int, input().split(" ")))\n if(a == 1):\n\ta = 14\n if(b == 1):\n\tb = 14\n if(a > b):\n print("Alice")\n elif(a == b):\n print("Draw")\n else:\n print("Bob")', 'import sys\nif __name__=="__main__":\n a, b = list(map(int, input().replace("\\n","").split(" ")))\n if(a > b):\n\tsys.stdout.write("Alice")\n elif(a == b):\n\tsys.stdout.write("Draw")\n else:\n\tsys.stdout.write("Bob")', 'if __name__=="__main__":\n a, b = list(map(int, input().split(" ")))\n if(a==1):\n a = 14\n if(b==1):\n b = 14\n if(a > b):\n print("Alice")\n elif(a == b):\n print("Draw")\n else:\n print("Bob")'] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s263520752', 's496014485', 's541671240', 's578441122', 's632618821', 's645147603', 's750212605', 's998257896'] | [2940.0, 3064.0, 2940.0, 2940.0, 3064.0, 2940.0, 2940.0, 3060.0] | [17.0, 23.0, 18.0, 17.0, 22.0, 17.0, 17.0, 17.0] | [271, 812, 202, 192, 604, 227, 219, 237] |
p03803 | u214434454 | 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 _ in range(n)]\nb = [input() for _ in range(m)]\n\nfor i in range(n-m+1):\n ans = True\n for j in range(n-m+1):\n for k in range(m):\n if a[i + k][j:j+m] != b[k]:\n ans = False\n if ans == True:\n break\n else:\n continue\n break\n\nif ans == True:\n print("Yes")\nelse:\n print("No")\n', 'a, b = map(int, input().split())\nif a == 1 and b!= 1:\n print("Alice")\nelif b == 1 and a != 1:\n print("Bob")\nelif a > b:\n print("Alice")\nelif b > a:\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s203271076', 's937172891'] | [3064.0, 3060.0] | [17.0, 17.0] | [413, 197] |
p03803 | u220345792 | 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 == 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())\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'] | ['s695429084', 's613682891'] | [2940.0, 2940.0] | [17.0, 17.0] | [161, 170] |
p03803 | u226779434 | 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,B,C ="Alice","Bob",Draw"\nif max(a,b) =="13" and min(a,b) =="1":\n print(A) if a < b else print(B)\nelse:\n print(A) if a > b print(B) if a < b else print(C)\n ', 'a,b =map(int,input().split())\nA,B,C =("Alice","Bob","Draw")\nif max(a,b) ==13 and min(a,b) ==1:\n print(A) if a < b else print(B)\nelse:\n if a > b:\n print(A) \n elif a < b:\n print(B) \n else:\n print(C)'] | ['Runtime Error', 'Accepted'] | ['s847704143', 's686294267'] | [8660.0, 9080.0] | [26.0, 28.0] | [190, 211] |
p03803 | u227082700 | 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());a,b=(a+11)%13,(b+11)%13\nif a>b:print("Alice");else:print("Bob")', ':cross: ', 'a,b=map(int,input().split())\na=(a+11)%13\nb=(b+11)%13\nif a==b:print("Draw")\nelif a>b:print("Alice")\nelse:print("Bob")'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s111791944', 's891465014', 's532196279'] | [2940.0, 2940.0, 3060.0] | [17.0, 18.0, 17.0] | [92, 8, 116] |
p03803 | u228759454 | 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\ndef convert_num(a):\n if a == 1:\n a = 14\n return a\n\na = convert_num(a)\nb = convert_num(b)\nif a > b:\n print('Alice')\nelif a == b:\n print('Draw')\nelse:\n print('Bob')\n ", "a, b = map(int, input().split())\n\ndef convert_num(a):\n if a == 1:\n a = 14\n return a\n\na = convert_num(a)\nb = convert_num(b)\nif a > b:\n print('Alice')\nelif a == b:\n print('Draw')\nelse:\n print('Bob')\n"] | ['Runtime Error', 'Accepted'] | ['s086524285', 's276418058'] | [2940.0, 2940.0] | [17.0, 17.0] | [222, 219] |
p03803 | u230621983 | 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 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)", "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)\n"] | ['Runtime Error', 'Accepted'] | ['s522149318', 's350426860'] | [2940.0, 2940.0] | [17.0, 17.0] | [169, 172] |
p03803 | u231647664 | 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(map, input().split())\nif A <= B:\n if A == 1:\n print('Alice')\n else:\n print('Bob')\nelse:\n if B == 1:\n print('Bob')\n else:\n print('Alice')\n \n", "A, B = int(map, input().split())\nif A <= B:\n if A = 1:\n print('Alice')\n else:\n print('Bob')\nelse:\n if B = 1:\n print('Bob')\n else:\n print('Alice')\n ", "A, B = map(int, input().split())\nif A < B:\n if A == 1:\n print('Alice')\n else:\n print('Bob')\n \nelif B > A:\n if B == 1:\n print('Bob')\n else:\n print('Alice')\n \nelse:\n print('Draw')", "A, B = map(int, input().split())\nif A < B:\n if A == 1:\n print('Alice')\n else:\n print('Bob')\n\nelif A > B:\n if B == 1:\n print('Bob')\n else:\n print('Alice')\nelse:\n print('Draw')"] | ['Runtime Error', 'Runtime Error', 'Wrong Answer', 'Accepted'] | ['s376240123', 's532763482', 's536153214', 's783524244'] | [2940.0, 2940.0, 3060.0, 3060.0] | [18.0, 18.0, 18.0, 18.0] | [167, 164, 200, 191] |
p03803 | u235066013 | 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) for i in input().split()]\nlist=["2","3","4","5","6","7","8","9","10","11","12","13","1"]\nA=list.index(a)\nB=list.index(b)\nif A>B:\n print(\'Alice\')\nelif A==B:\n print(\'Draw\')\nelse:\n print(\'Bob\'', 'a,b=[str(i) for i in input().split()]\nlist=["2","3","4","5","6","7","8","9","10","11","12","13","1"]\nA=list.index(a)\nB=list.index(b)\nif A>B:\n print(\'Alice\')\nelif A==B:\n print(\'Draw\')\nelse:\n print(\'Bob\')'] | ['Runtime Error', 'Accepted'] | ['s025430416', 's554719510'] | [3060.0, 3060.0] | [18.0, 18.0] | [204, 205] |
p03803 | u237634011 | 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 or a = 1:\n print("Alice")\nelif b > a or b = 1:\n print("Bob")', 'a, b = map(int, input().split())\n\nif int(a) == 1 and int(b) != 1:\n print("Alice")\nelif int(a) != 1 and int(b) == 1:\n print("Bob")\nelif int(a) > int(b):\n print("Alice")\nelif int(a) < int(b):\n print("Bob")\nelif int(a) == int(b):\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s896357754', 's239393177'] | [8936.0, 9128.0] | [26.0, 29.0] | [104, 256] |
p03803 | u239342230 | 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().replace(1,14)\nprint('Draw' if a==b else 'Alice' if a>b else 'Bob')", "a,b=map(int,input().split())\nif a>1:\n a=a\nelse:\n a=14\nif b>1:\n b=b\nelse:\n b=14\nprint('Draw' if a==b else 'Alice' if a>b else 'Bob')"] | ['Runtime Error', 'Accepted'] | ['s539877150', 's348645915'] | [2940.0, 2940.0] | [17.0, 18.0] | [94, 143] |
p03803 | u249895018 | 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. | ['!/usr/bin/env python\n # -*- coding: utf-8 -*-\n \n import sys\n \n for line in sys.stdin:\n card = line.split(" ")\n \n if card[0] > card[1]:\n print("Alice")\n elif card[0] < card[1]:\n print("Bob")\n else:\n print("Draw")', 'import sys\n\ncount = 0\nN_list = []\nM_list = []\nfor line in sys.stdin:\n line = line.rstrip("\\n")\n if count == 0:\n line = line.split(" ")\n N = int(line[0])\n M = int(line[1])\n elif count <= N:\n N_list.append(line)\n else:\n M_list.append(line)\n count+=1\n \n \ndef judge_match(N_l, M_l):\n slide_count = len(N_l[0]) - len(M_l[0]) + 1\n count = 0\n for j in range(slide_count):\n count = 0\n for i in range(len(N_l)):\n if N_l[i][j:len(M_l[0])] == M_l[i]:\n count += 1\n if count == len(M_l):\n return count\n return count\n\nm_count = 0\nfor i in range(len(N_list)):\n m_count = judge_match(N_list[i:i+len(M_list)], M_list)\n if m_count == len(M_list):\n print("Yes")\n exit(0)\nprint("No")', 'for line in sys.stdin:\n card = line.split(" ")\n alice = int(card[0])\n bob = int(card[1])\n if alice == 1:\n alice += 13\n if bob == 1:\n bob += 13\n \n if alice > bob:\n print("Alice")\n elif alice < bob:\n print("Bob")\n else:\n print("Draw")', 'import sys\n \nfor line in sys.stdin:\n card = line.split(" ")\n alice = int(card[0])\n bob = int(card[1])\n if alice == 1:\n alice += 13\n if bob == 1:\n bob += 13\n \n if alice > bob:\n print("Alice")\n elif alice < bob:\n print("Bob")\n else:\n print("Draw")'] | ['Runtime Error', 'Wrong Answer', 'Runtime Error', 'Accepted'] | ['s070628076', 's188616131', 's451215159', 's804618930'] | [2940.0, 3064.0, 3060.0, 3060.0] | [16.0, 18.0, 17.0, 17.0] | [246, 825, 298, 311] |
p03803 | u256833330 | 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+13)%15<(b+13)%15 else 'Bob')\n", "a,b=map(int,input().split())\nprint('Draw' if a==b else 'Alice' if (a+13)%15>(b+13)%15 else 'Bob')\n"] | ['Wrong Answer', 'Accepted'] | ['s394654747', 's802333549'] | [2940.0, 2940.0] | [17.0, 17.0] | [98, 98] |
p03803 | u263824932 | 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')\nelse:\n if A==1:\n print('Alice')\n elif B==1:\n print('Bob')\n else:\n if A > B:\n print('Alice')\n else:\n print('Bob')\n", "A,B=map(int,input().split())\nif A==B:\n print('Draw')\nelse:\n if A==1:\n print('Alice')\n elif B==1:\n print('Bob')\n else:\n if A > B:\n print('Alice')\n else:\n print('Bob')\n"] | ['Runtime Error', 'Accepted'] | ['s665143301', 's074662793'] | [2940.0, 2940.0] | [17.0, 17.0] | [220, 228] |
p03803 | u271044469 | 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 and b!=1):\n print('Alice')\nelif (b > a a!=1) and (a!=1 and b==1):\n print('Bob')\nelse:\n print('Draw')\n\n", "a, b = map(int, input().split())\n\nif (a > b and b != 1) or (a==1 and b!=1):\n print('Alice')\nelif (b > a and a!=1) or (a!=1 and b==1):\n print('Bob')\nelse:\n print('Draw')\n\n"] | ['Runtime Error', 'Accepted'] | ['s811639141', 's733680028'] | [2940.0, 3316.0] | [17.0, 21.0] | [176, 179] |
p03803 | u274615057 | 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. | ['\ndef main():\n a, b = map(int, input().split())\n if a-2 < 0:\n a = 14\n\n if b-2 < 0:\n b = 14i\n\n if a-2 > b-2:\n print(\'Alice\')\n elif a-2 < b-2:\n print(\'Bob\')\n else:\n print(\'Draw\')\n\n\nif __name__ == "__main__":\n main()\n\n', '\ndef main():\n a, b = map(int, input().split())\n if a-2 < 0:\n a = 14\n\n if b-2 < 0:\n b = 14\n\n if a-2 > b-2:\n print(\'Alice\')\n elif a-2 < b-2:\n print(\'Bob\')\n else:\n print(\'Draw\')\n\n\nif __name__ == "__main__":\n main()\n\n'] | ['Runtime Error', 'Accepted'] | ['s015120539', 's364853505'] | [8936.0, 9044.0] | [25.0, 25.0] | [270, 269] |
p03803 | u277802731 | 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. | ["#54b\nn,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 t = [k[j:j+m] for k in a[i:i+m]]\n if t==b:\n print('Yes')\n exit()\nprint('No')", "#54a\na,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'] | ['s053679924', 's228208623'] | [3060.0, 2940.0] | [17.0, 17.0] | [259, 174] |
p03803 | u282657760 | 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')\nelse:\n if A == 1:\n print('Alice')\n elif B == 1:\n print('Bob')\n elif A < B:\n print('Bob')\n else B < A:\n print('Alice')", "A, B = map(int, input().split())\nif A == 1 and B != 1:\n print('Alice')\nelif A == 1 and B == 1:\n print('Draw')\nelif A != 1 and B == 1:\n print('Bob')\nelif A < B:\n print('Alice')\nelif B < A:\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 elif B == 1:\n print('Bob')\n elif A < B:\n print('Bob')\n elif B < A:\n print('Alice')"] | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s049094442', 's745842577', 's332424011'] | [2940.0, 3060.0, 2940.0] | [17.0, 17.0, 17.0] | [193, 228, 193] |
p03803 | u288087195 | 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(i) for i in input().split()] \nif a[0] == 1:\n a[0] = a[0] +13\nif a[1] ==1:\n a[1] = a[1] + 13\nif a[0] > a[1]:\n print("Alice")\nelif a[0] < a[1]:\n print("Bob")\nelse\n print("Draw")', 'a = [int(i) for i in input().split()] \nif a[0] == 1:\n a[0] = a[0] + 13\n\nif a[1] == 1:\n a[1] = a[1] + 13\n\n \nif a[0] > a[1]:\n print("Alice")\nelif a[0] < a[1]:\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s372054056', 's704233118'] | [2940.0, 3060.0] | [17.0, 17.0] | [189, 197] |
p03803 | u288948615 | 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')\nif A > B:\n print('Bob')\nelse:\n print('Draw')", "A, B = map(int, input())\n\nif A < B:\n print('Alice')\nif A > B:\n print('Bob')\nelse:\n print('Draw')", "A, B = map(int, input().split())\n\nif A == 1:\n A += 12\nif B == 1:\n B += 12\n\nif A < B:\n print('Alice')\nif A > B:\n print('Bob')\nelse:\n print('Draw')", "A, B = map(int, input().split())\n\nif A == 1:\n A += 12\nif B == 1:\n B += 12\n\nif A > B:\n print('Alice')\nif A < B:\n print('Bob')\nelse:\n print('Draw')", "A, B = map(int, input().split())\n\nif A = 1:\n A += 12\nif B = 1:\n B += 12\n\nif A < B:\n print('Alice')\nif 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')"] | ['Wrong Answer', 'Runtime Error', 'Wrong Answer', 'Wrong Answer', 'Runtime Error', 'Accepted'] | ['s078586858', 's234129696', 's435295702', 's779349158', 's898369925', 's231330687'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0, 3060.0] | [17.0, 17.0, 17.0, 17.0, 17.0, 17.0] | [113, 105, 160, 160, 158, 162] |
p03803 | u294376483 | 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 if B != 1 :\n print("Alice")\n\nif B == 1 and A != 1:\n if A != 1 :\n print("Bob")\n\nif A == 1 and B == 1 :\n print("Draw")\n\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")', 'A, B = map(int,input().split())\n\nif A == 1 :\n if B != 1 :\n print("Alice")\n else :\n print("Draw")\n\nif B == 1 :\n if A != 1 :\n print("Bob")\n else :\n print("Draw")\n\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")', 'A, B = map(int,input().split())\n\nif A == 1 and B != 1:\n if B != 1 :\n print("Alice")\n\nif B == 1 and A != 1:\n if A != 1 :\n print("Bob")\n\nif A == 1 and B == 1 :\n print("Draw")\n\nif A != 1 and B !=1 :\n if A > B :\n print("Alice")\n if A < B :\n print("Bob")\n if A == B :\n print("Draw")'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s419362624', 's459566528', 's964252021'] | [3064.0, 3060.0, 3060.0] | [17.0, 17.0, 17.0] | [325, 330, 330] |
p03803 | u296518383 | 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=14 if a==1 else a\nb=14 if b==1 else b\n\nif a>b:\n print("Alice")\nif a<b:\n print("Bob")\nelse:\n print("Draw")', 'a,b=map(int,input().split())\na=14 if a==1 else a\nb=14 if b==1 else b\n\nif a>b:\n print("Alice")\nelif a<b:\n print("Bob")\nelse:\n print("Draw")'] | ['Wrong Answer', 'Accepted'] | ['s705796243', 's383239631'] | [2940.0, 2940.0] | [17.0, 17.0] | [139, 141] |
p03803 | u302292660 | 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 and b!=1) or (a==1 and b!=1) else "Bob" (if a<b and a!=1) or(a!=1 and b==1) else "Draw")', 'a,b = map(int,input().split())\nprint("Alice" if (a>b and b!=1) or (a==1 and b!=1) else "Bob" if (a<b and a!=1) or(a!=1 and b==1) else "Draw")'] | ['Runtime Error', 'Accepted'] | ['s268722246', 's051705529'] | [2940.0, 2940.0] | [17.0, 17.0] | [141, 141] |
p03803 | u316386814 | 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\nsys.setrecursionlimit(10**7)\nINF = 10 ** 18\nMOD = 10 ** 9 + 7\ndef POW(x, y):\n if y == 0:\n return 1\n elif y == 1:\n return x\n elif y % 2 == 0:\n return POW(x, y // 2) ** 2 % MOD\n else:\n return POW(x, y // 2) ** 2 * x % MOD\ndef mod_factorial(x, y): return x * POW(y, MOD - 2) % MOD\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef II(): return int(sys.stdin.readline())\ndef SI(): return input()\nfrom functools import reduce\n\ndef binomials(n, k):\n ret = [0] * (n + 1)\n ret[k] = 1\n denomi = mod_factorial(1, reduce(lambda x, y: x * y % MOD, range(1, k), 1))\n for i in range(k - 1, n):\n numeri = reduce(lambda x, y: x * y % MOD, range(i - k + 2, i + 1), 1)\n ret[i + 1] = numeri * denomi % MOD\n return ret\n\ndef main():\n if A > B:\n ans = 'Alice'\n elif A == B:\n ans = 'Draw'\n else:\n ans = 'Bob'\n return ans\n\nprint(main())", "import sys\nsys.setrecursionlimit(10**7)\nINF = 10 ** 18\nMOD = 10 ** 9 + 7\ndef POW(x, y):\n if y == 0:\n return 1\n elif y == 1:\n return x\n elif y % 2 == 0:\n return POW(x, y // 2) ** 2 % MOD\n else:\n return POW(x, y // 2) ** 2 * x % MOD\ndef mod_factorial(x, y): return x * POW(y, MOD - 2) % MOD\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef II(): return int(sys.stdin.readline())\ndef SI(): return input()\nfrom functools import reduce\n\ndef main():\n A, B = LI()\n if A == 1:\n A = 14\n if B == 1:\n B = 14\n if A > B:\n ans = 'Alice'\n elif A == B:\n ans = 'Draw'\n else:\n ans = 'Bob'\n return ans\n\nprint(main())"] | ['Runtime Error', 'Accepted'] | ['s954421482', 's339253169'] | [3664.0, 3572.0] | [24.0, 24.0] | [1124, 893] |
p03803 | u320511454 | 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=list(map(int,input().split()))\nif a>b:\n print("Alice")\nelif a=b:\n print("Draw")\nelse:\n print("Bob")', 'a,b=list(map(int,input().split()))\nif a == 1:\n a += 13\nif b == 1:\n b += 13\n\nif a > b:\n print("Alice")\nelif a==b:\n print("Draw")\nelse:\n print("Bob")'] | ['Runtime Error', 'Accepted'] | ['s448829000', 's917881468'] | [2940.0, 3060.0] | [17.0, 17.0] | [106, 152] |
p03803 | u324549724 | 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')\nelse :\n if min(a, b) == 1 : flag = True\n if a < b :\n if flag : print('Alice')\n else : print('Bob')\n else :\n if flag : print('Bob')\n else : print('Alice')\n", "a, b = map(int, input().split())\nif a == b : print('Draw')\nelse :\n if min(a, b) == 1 : flag = TRUE\n if a < b :\n if flag : print('Alice')\n else : print('Bob')\n else :\n if flag : print('Bob')\n else : print('Alice')\n", "a, b = map(int, input().split())\nif a == b : print('Draw')\nelse :\n flag = False\n if min(a, b) == 1 : flag = True\n if a < b :\n if flag : print('Alice')\n else : print('Bob')\n else :\n if flag : print('Bob')\n else : print('Alice')\n"] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s614327136', 's934377804', 's500357959'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [228, 228, 243] |
p03803 | u328755070 | 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 = list(map(int, input().split()))\nif A == B:\n ans = 'Draw'\nelif A == 1:\n ans = 'Alice'\nelif B == 1:\n ans = 'Bob'\nelse:\n ans = 'Alice' if A > B else 'Bob'\n\nprint(ans)\n", "A, B = list(map(int, input().split()))\nif A == B:\n ans = 'Draw'\nelif A == 1:\n ans = 'Alice'\nelif B == 1:\n ans = 'Bob'\nelse:\n ans = 'Alice' if A > B else 'Bob'\n\nprint(ans)\n"] | ['Runtime Error', 'Accepted'] | ['s696609601', 's479952949'] | [2940.0, 2940.0] | [17.0, 17.0] | [183, 183] |
p03803 | u329058683 | 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 or A==1 not B==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==1 or A>B:\n print(""Alice)\nelse:\n print("Bob")', 'A,B=map(int,input().split())\n \nif A==B:\n print("Draw")\nelif B==1:\n print("Bob")\nelif B>1 and A==1 or A>B:\n print("Alice")\nelse:\n print("Bob")'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s041986800', 's704889541', 's793952492'] | [2940.0, 2940.0, 2940.0] | [18.0, 17.0, 17.0] | [124, 119, 145] |
p03803 | u331464808 | 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 or a<b:\n print('Bob')", "a,b=map(int,input().split())\nif a>b:\n print('Alice')\nif a=b:\n print('Draw')\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')", "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:print('Alice')\nelif a<b: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', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s294070791', 's359990142', 's386873642', 's590915675', 's688880988', 's841500833'] | [2940.0, 2940.0, 3064.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0, 17.0, 17.0] | [118, 98, 152, 155, 151, 157] |
p03803 | u334712262 | 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')\nelse:\n print( 'Alice' if A if A != 1 else A+13 > B if B != 1 else B+ 13 else 'Bob')", "A, B = map(int, input().split())\nif A == B:\n print('Draw')\nelse:\n print( 'Alice' if (A if A != 1 else A+13) > (B if B != 1 else B+13) else 'Bob')\n"] | ['Runtime Error', 'Accepted'] | ['s381039726', 's263927486'] | [2940.0, 2940.0] | [17.0, 18.0] | [144, 148] |
p03803 | u339922532 | 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("Draw")\nelif 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")'] | ['Runtime Error', 'Accepted'] | ['s145172872', 's910974399'] | [2940.0, 2940.0] | [17.0, 17.0] | [179, 178] |
p03803 | u348868667 | 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())\ntmp = list(A,B)\nans = ["Alice","Bob"]\nif tmp[0] == tmp[1]:\n print("Draw")\nelif tmp[0] == 1:\n print(ans[0])\nelif tmp[1] == 1:\n print(ans[1])\nelif tmp[0] > tmp[1]:\n print(ans[0])\nelse:\n print(ans[1])', 'A,B = map(int,input().split())\ntmp = [A,B]\nans = ["Alice","Bob"]\nif tmp[0] == tmp[1]:\n print("Draw")\nelif tmp[0] == 1:\n print(ans[0])\nelif tmp[1] == 1:\n print(ans[1])\nelif tmp[0] > tmp[1]:\n print(ans[0])\nelse:\n print(ans[1])'] | ['Runtime Error', 'Accepted'] | ['s422043194', 's843339539'] | [3064.0, 3060.0] | [17.0, 17.0] | [243, 239] |
p03803 | u350093546 | 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')\nelif a<b:\n print('Bob')\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 a<b:\n print('Bob')\n"] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s173186054', 's238116892', 's923827410'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [153, 158, 160] |
p03803 | u363610900 | 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(str, input().split())\nA.replace('1', '14')\nB.replace('1', '14')\nprint('Draw' if A == B else max(A, B))", "A, B = map(int, input().split())\nif A == 1:\n A += 13\nif B == 1:\n B += 13\nprint('Alice' if A > B else 'Draw' if A == B else 'Bob')"] | ['Wrong Answer', 'Accepted'] | ['s089997676', 's772535315'] | [2940.0, 2940.0] | [17.0, 20.0] | [113, 135] |
p03803 | u366644013 | 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 x=="1" else int(x), input().split())\nif a>b:\n print()', 'a, b = map(lambda x: 14 if x=="1" else int(x), input().split())\nif a>b:\n print("Alice")\nelif a<b:\n print("Bob")\nelse:\n print("Draw")'] | ['Wrong Answer', 'Accepted'] | ['s755096821', 's228113720'] | [2940.0, 2940.0] | [17.0, 17.0] | [81, 135] |
p03803 | u366959492 | 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) for x in 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")\n', 'a,b = (int(x) for in 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")', 'a,b = (int(x) for x in 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")\n'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s609713307', 's904569973', 's632055625'] | [2940.0, 2940.0, 2940.0] | [18.0, 17.0, 17.0] | [154, 151, 156] |
p03803 | u367130284 | 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 collections import *\nn,m=map(int,input().split())\nd=defaultdict(list)\nfor s in m*[0]:\n a,b=map(int,input().split())\n d[a].append(b)\n d[b].append(a)\ndef DFS_dict(point,TFlist):\n if all(TFlist):\n return 1\n ans=0\n for i in d[point]:\n if TFlist[i-1]:\n continue\n TFlist[i-1]=True\n ans+=DFS_dict(i,TFlist)\n TFlist[i-1]=False\n return ans\nTFlist=[True]+[False]*(n-1)\nprint(DFS_dict(1,TFlist))', 'a,b=map(int,input().split())\nif a==1:a+=13\nif b==1:b+=13\nif a>b:print("Alice")\nelif b>a:print("Bob")\nelse:print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s850487617', 's869077793'] | [3316.0, 2940.0] | [21.0, 18.0] | [456, 119] |
p03803 | u371409687 | 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())\ni1=[input() for _ in range(n)]\ni2=[input() for _ in range(m)]\nans="No"\nfor i in range(n-m+1):\n for j in range(n-m+1):\n if i1[i][j:m+j]==i2[0] and i1[i+1][j:j+m]==i2[1]:\n ans="Yes"\nprint(ans)', 'a,b=map(int, input().split())\nif a==b:\n print("Draw")\nelif a==1 or (a>b and b!=1):\n print("Alice")\nelse:\n print("Bob")'] | ['Runtime Error', 'Accepted'] | ['s142014923', 's527352177'] | [3060.0, 2940.0] | [18.0, 17.0] | [240, 121] |
p03803 | u374531474 | 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\na = 14 if A == 1 else A\nb = 14 if b == 1 else B\nprint('Alice' if a > b else 'Bob' if a < b else 'Draw')\n", "A, B = map(int, input().split())\n\na = 14 if A == 1 else A\nb = 14 if B == 1 else B\nprint('Alice' if a > b else 'Bob' if a < b else 'Draw')\n"] | ['Runtime Error', 'Accepted'] | ['s307309508', 's565557890'] | [2940.0, 2940.0] | [17.0, 17.0] | [138, 138] |
p03803 | u377989038 | 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 a > b:\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\nif a < b:\n print("Bob")\nelif a > b:\n print("Alice")\nelse:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s546673668', 's189925080'] | [2940.0, 3060.0] | [17.0, 17.0] | [159, 158] |
p03803 | u379959788 | 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. | ['#include <bits/stdc++.h>\nusing namespace std;\nint main(){\n int A, B;\n cin >> A >> B;\n if (A == B) cout << "Draw" << endl;\n else if (A == 1) cout << "Alice" << endl;\n else if (B == 1) cout << "Bob" << endl;\n else if (A > B) cout << "Alice" << endl;\n else cout << "Bob" << endl;\n}', '\na, 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', 'Accepted'] | ['s951121507', 's006690398'] | [2940.0, 3060.0] | [17.0, 17.0] | [299, 169] |
p03803 | u391475811 | 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:\n\nif A==B:\n print("Draw")\nelif A<B:\n print("Bob")\nelse:\n print("Alice")', 'A,B=map(int,input().split())\nif A==1:\n A+=13\nif B==1:\n B+=13\n\nif A==B:\n print("Draw")\nelif A<B:\n print("Bob")\nelse:\n print("Alice")\n'] | ['Runtime Error', 'Accepted'] | ['s953746498', 's673753391'] | [2940.0, 2940.0] | [17.0, 17.0] | [137, 137] |
p03803 | u391819434 | 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\nprint(['ABloibc e'[A<B::2],'Draw'][A==B])", "A,B=map(int,input().split())\nA=(A-2)%13\nB=(B-2)%13\nprint(['Draw','Alice','Bob'][(A>B)-(B>A)])"] | ['Runtime Error', 'Accepted'] | ['s542150203', 's139958570'] | [2940.0, 9164.0] | [17.0, 27.0] | [104, 93] |
p03803 | u401183062 | 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\n\nif b == 1:\n b = 14\n\nprint(a, b)\n\nif a < b:\n print("Bob")\nelif b < a:\n print("Alice")\nelse:\n print("Draw")\n', 'a, b = map(int, input().split())\n\nif a == 1:\n a = 14\n\nif b == 1:\n b = 14\n\n\n\nif a < b:\n print("Bob")\nelif b < a:\n print("Alice")\nelse:\n print("Draw")\n'] | ['Wrong Answer', 'Accepted'] | ['s064268287', 's167159521'] | [8952.0, 9104.0] | [25.0, 26.0] | [175, 164] |
p03803 | u403986473 | 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(B != 1 and (A == 1 or A > B)):\n print('Alice')\nelif(A != 1 and (B == 1 or B > A)):\n print('Bob')", "A, B = map(int,input().split())\nif(A == B):\n print('Draw')\nelif(B != 1 and (A == 1 or A > B)):\n print('Alice')\nelif(A != 1 and (B == 1 or B > A)):\n print('Bob')"] | ['Runtime Error', 'Accepted'] | ['s954380544', 's282982177'] | [2940.0, 3064.0] | [17.0, 18.0] | [161, 169] |
p03803 | u411544692 | 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 result = 'Draw'\nelif (A < B and A!=1) or B==1:\n result = 'Bob'\nelse:\n result ='Alice'", "A,B = map(int,input().split())\n\nif A==B:\n result = 'Draw'\nelif (A < B and A!=1) or B==1:\n result = 'Bob'\nelse:\n result ='Alice'\nprint(result)"] | ['Wrong Answer', 'Accepted'] | ['s428022024', 's240386512'] | [2940.0, 2940.0] | [17.0, 17.0] | [130, 144] |
p03803 | u416011173 | 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# A - One Card Poker\n\nA,B = list(map(int, input().split()))\n\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("Alica")\nelse:\n print("Bob")', '# -*- coding: utf-8 -*-\n# A - One Card Poker\n\nA,B = list(map(int, input().split()))\n\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")'] | ['Wrong Answer', 'Accepted'] | ['s533145761', 's556466179'] | [3060.0, 3060.0] | [17.0, 17.0] | [286, 286] |
p03803 | u416773418 | 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 a<b:\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\nif a<b:\n print('Bob')\nelif a>b:\n print('Alice')\nelse:\n print('Draw')"] | ['Wrong Answer', 'Accepted'] | ['s007615356', 's368057881'] | [2940.0, 3060.0] | [17.0, 17.0] | [142, 142] |
p03803 | u419963262 | 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%13\nb=B%13\nif A>B:\n print("Alice")\nelif B>A:\n print("Bob")\nelse:\n print("Draw")\n \n', 'A,B=map(int,input().split())\na=14 if A==1 else A\nb=14 if B==1 else B\nif a>b:\n print("Alice")\nelif b>a:\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s423706958', 's279190219'] | [2940.0, 3060.0] | [17.0, 17.0] | [118, 140] |
p03803 | u425762225 | 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\ndef judge(a,b):\n if a > b:\n return "Alice"\n elif a = b:\n return "Draw"\n else:\n return "Bob"\n \nprint(judge(A,B))', 'A,B=map(int,input().split())\n\ndef judge(a,b):\n if a > b > 1 or (a == 1 and b != 1):\n return "Alice"\n elif a == b:\n return "Draw"\n else:\n return "Bob"\n \nprint(judge(A,B))\n'] | ['Runtime Error', 'Accepted'] | ['s915536131', 's981787719'] | [2940.0, 2940.0] | [17.0, 17.0] | [154, 183] |
p03803 | u426108351 | 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\nelif B == 1:\n B = 14\nif A > B:\n print("Alice")\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\nif A > B:\n print("Alice")\nelif A < B:\n print("Bob")\nelse:\n print("Draw")\n'] | ['Runtime Error', 'Accepted'] | ['s009153743', 's979361992'] | [3060.0, 2940.0] | [17.0, 17.0] | [160, 159] |
p03803 | u429029348 | 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. | ['w,h=map(int,input().split())\nif w/h==4/3:\n ans="4:3"\nelse:\n ans="16:9"\nprint(ans)', 'a,b=map(int,input().split())\nif a==1:\n a=14\nif b==1:\n b=14\nif a==b:\n ans="Draw"\nelif a<=b:\n ans="Bob"\nelse:\n ans="Alice"\nprint(ans)'] | ['Wrong Answer', 'Accepted'] | ['s985044086', 's246008068'] | [2940.0, 3060.0] | [17.0, 17.0] | [87, 146] |
p03803 | u432805419 | 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(input().split())\na.replace("1","99")\nif int(a[0]) > int(a[1]):\n print("Bob")\nelif int(a[0]) == int(a[1]):\n print("Draw")\nelse:\n print("Alice")\n', 'a = list(map(int,input().split()))\nif a > b:\n print("Bob")\nelif a == b:\n print("Draw")\nelse:\n print("Alice")', 'a = list(map(int,input().split()))\na.replace(1,99)\nif a[0] > a[1]:\n print("Bob")\nelif a[0] == a[1]:\n print("Draw")\nelse:\n print("Alice")', 'a = list(map(int,input().split()))\nif a[0] > a[1]:\n print("Bob")\nelif a[0] == a[1]:\n print("Draw")\nelse:\n print("Alice")\n', 'a = list(map(int,input().split()))\nif a[0] == a[1]:\n print("Draw")\nelif (a[0] == 1 or a[0] >= a[1]) and a[1] !=1:\n print("Alice")\nelse:\n print("Bob")'] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Wrong Answer', 'Accepted'] | ['s247504887', 's468605147', 's612458428', 's795347452', 's543534951'] | [2940.0, 3060.0, 3060.0, 2940.0, 3060.0] | [17.0, 17.0, 17.0, 18.0, 17.0] | [155, 111, 139, 124, 152] |
p03803 | u438396676 | 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. | ['lis=input().split()\na=int(lis[0])\nb=int(lis[1])\nif a=1:\n if b=1:\n print(Draw)\n else :\n print(Alice)\nelif b=1:\n print(Bob)\nelse :\n if a>b:\n print(Alice)\n elif a=b:\n print(Draw)\n else :\n print(Bob)', 'lis=input().split()\na=int(lis[0])\nb=int(lis[1])\nif a==1:\n if b==1:\n print("Draw")\n else :\n print("Alice")\nelif b==1:\n print("Bob")\nelse :\n if a>b:\n print("Alice")\n elif a==b:\n print("Draw")\n else :\n print("Bob")'] | ['Runtime Error', 'Accepted'] | ['s032188974', 's928893969'] | [2940.0, 3064.0] | [17.0, 17.0] | [248, 264] |
p03803 | u440478998 | 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\na = 14 if a == 1 else a\nb = 14 if b == 1 else b\n\nif a > b:\n print("Alice")\nelif a < b:\n print("Bob")\nelse:\n print("Draw")', 'a,b = map(int,input().split())\n\na = 14 if a == 1 else a\nb = 14 if b == 1 else b\n\nif a > b:\n print("Alice")\nelif a < b:\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Accepted'] | ['s382751171', 's974592663'] | [9020.0, 9072.0] | [20.0, 30.0] | [163, 162] |
p03803 | u442948527 | 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")\nelif a=b:\n print("Draw")\nelse:\n print("Bob")', 'a=(int(input())-2)%13\nb=(int(input())-2)%13\nprint(["Draw","Bob","Alice"][((a==b)+1)*((a<b)-(b<a))])', 'a,b=map(int,input().split())\na=(a-2)%13\nb=(b-2)%13\nprint(["Draw","Bob","Alice"][(a==b+1)*(a<b-b<a)])', 'a,b=map(int,input().split())\na=(a%13+11)%13\nb=(b%13+11)%13\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:a=14\nif b==1:b=14\nif a<b:\n print("Alice")\nelif a==b:\n print("Draw")\nelse:\n print("Bob")', 'a,b=map(int,input().split())\na=(a-2)%13\nb=(b-2)%13\nprint([["Alice","Draw"][a==b],"Bob"][a<b])'] | ['Runtime Error', 'Runtime Error', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s075834047', 's214114142', 's235318708', 's258612952', 's614889113', 's593041543'] | [8956.0, 9024.0, 8996.0, 9084.0, 9060.0, 9056.0] | [26.0, 26.0, 28.0, 27.0, 24.0, 28.0] | [106, 99, 100, 137, 133, 93] |
p03803 | u445509700 | 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. | ['i = [int(s) for s in input().split()]\nalice = i[0]\nbob = i[1]\n\nif alice == bob:\n print("draw")\nelif alice == 1:\n print("alice")\nelif bob == 1:\n print("bob")\nelif alice < bob:\n print("bob")\nelse:\n print("alice")\n', 'i = [int(s) for s in input().split()]\nalice = i[0]\nbob = i[1]\n\nif alice == bob:\n print("Draw")\nelif alice == 1:\n print("Alice")\nelif bob == 1:\n print("Bob")\nelif bob < alice:\n print("Alice")\nelse:\n print("Bob")\n'] | ['Wrong Answer', 'Accepted'] | ['s304642929', 's162702412'] | [2940.0, 2940.0] | [17.0, 17.0] | [226, 226] |
p03803 | u446711904 | 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. | ["p=[2,3,4,5,6,7,8,9,10,11,12,13,1]\na,b=map(int,input().split())\nprint('ABloibc e'[p.index(a)<p.idex(b)::2] if a!=b else 'Draw') ", "p=[2,3,4,5,6,7,8,9,10,11,12,13,1]\na,b=map(int,input().split())\nprint('ABloibc e'[p.index(a)<p.index(b)::2] if a!=b else 'Draw') "] | ['Runtime Error', 'Accepted'] | ['s061365523', 's983254543'] | [2940.0, 3060.0] | [17.0, 17.0] | [127, 128] |
p03803 | u448655578 | 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\tif A > B:\n \t print("Alice")\n\telif B > A:\n \t print("Bob")\n\telif A == B:\n print("Draw")\nelse:\n if A == 1:\n print("Alice")\n else:\n \tprint("Bob")', 'A, B = map(int, input().split())\nif A != 1 and B != 1 and A > B:\n \tprint("Alice")\nelif A != 1 and B != 1 and B > A:\n print("Bob")\nelif A == B:\n print("Draw")\nelif A == 1:\n print("Alice")\nelse:\n print("Bob")'] | ['Runtime Error', 'Accepted'] | ['s365250681', 's617337236'] | [2940.0, 3060.0] | [17.0, 18.0] | [212, 220] |
p03803 | u449555432 | 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())+13)%15;print('Alice' if a>b else 'Bob' if a<b else 'Draw)", "a,b=(map(int,input().split())+13)%15;print('Alice' if a>b else 'Bob' if a<b else 'Draw')", "a=(int(input())+13)%15;b=(int(input())+13)%15;print('Alice' if a>b else 'Bob' if a<b else 'Draw')", "a = (int(input())+13) % 15\nb = (int(input())+13) % 15\n\nprint('Alice' if a > b else 'Bob' if a < b else 'Draw')\n", "x,y=map(int,input().split())\na = (x + 13) % 15\nb = (y + 13) % 15\nprint('Alice' if a > b else 'Bob' if a < b else 'Draw')\n"] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s085539435', 's530549653', 's541469714', 's654183337', 's083234360'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 18.0, 18.0, 18.0] | [87, 88, 97, 111, 121] |
p03803 | u453500284 | 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:(int(x) + 13) % 15, input().split())\nif a > b: print("Alice")\n if a < b: print("Bob")\n else: print("Draw")', 'a, b = map(lambda x:(int(x) + 13) % 15, input().split())\nif a > b: print("Alice")\nelif a < b: print("Bob")\nelse: print("Draw")\n'] | ['Runtime Error', 'Accepted'] | ['s242417000', 's913451810'] | [2940.0, 2940.0] | [17.0, 17.0] | [130, 127] |
p03803 | u454557108 | 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\n\nif b == 1:\n b = 14\n\nprint(a,b)\n \nif a > b:\n print('Alice')\nelif b > a:\n print('Bob')\nelse:\n print('Draw')", "a,b = map(int, input().split())\n \nif a == 1:\n a = 14\n\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'] | ['s746343709', 's462039796'] | [3060.0, 2940.0] | [18.0, 17.0] | [176, 165] |
p03803 | u457957084 | 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("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")\nelse:\n print("Bob")', 'a , b = map(int(input().split())\n\nif a == b:\n print("Draw")\nelif a == 1 B != 1:\n print("Alice")\nelif a != 1 B == 1:\n print("Bob")\nelif a < b:\n print("Alice")\nelse:\n print("Bob")\n ', 'a, b = map(int,input().split())\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")\nelse:\n print("Bob")\n ', 'a, b = map(int,input().split())\n\nif a == b:\n print("Draw")\nelif a == 1 B != 1:\n print("Alice")\nelif a != 1 B == 1:\n print("Bob")\nelif a < b:\n print("Alice")\nelse:\n print("Bob")', 'a, b = map(int,input().split())\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")\nelse:\n print("Bob")', 'a, b = map(int,input().split())\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("Bob")\nelse:\n print("Alice")\n '] | ['Wrong Answer', 'Runtime Error', 'Wrong Answer', 'Runtime Error', 'Wrong Answer', 'Accepted'] | ['s066736947', 's555126870', 's755199859', 's850685717', 's905693161', 's164381913'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0, 17.0, 19.0] | [231, 231, 236, 223, 231, 236] |
p03803 | u461636820 | 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 cards = [2,3,4,5,6,7,8,9,10,11,12,13,1]\n A, B = map(int, input().split())\n if cards.index(A) > cards.index(B):\n print('Alice')\n elif cards.index(A) < cards.index(B):\n print('Bob')\n else:\n print('Draw')", "a, b = map(int(input().split()))\nif a == b:\n\tprint('Draw')\nelif a == 1:\n\tprint('Alice')\nelif b == 1:\n\tprint('Bob')\nelif a > b:\n\tprint('Alice')\nelse:\n\tprint('Bob')", "# -*- coding: utf-8 -*-\ndef main():\n cards = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1]\n A, B = map(int, input().split())\n if cards.index(A) > cards.index(B):\n print('Alice')\n elif cards.index(A) < cards.index(B):\n print('Bob')\n else:\n print('Draw')\n\nif __name__ == '__main__':\n main()"] | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s341911364', 's646714639', 's645014962'] | [2940.0, 2940.0, 3064.0] | [17.0, 17.0, 18.0] | [250, 162, 325] |
p03803 | u462538484 | 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 = input().split()\na, b = int(a), int(b)\nprint("Draw" if a == b elif a < b "Bob" else "Alice")', 'a, b = input().split()\na, b = int(a), int(b)\nif a == 1:\n a += 13\nif b == 1:\n b += 13\nprint("Alice" if a > b else "Draw" if a == b else "Bob")'] | ['Runtime Error', 'Accepted'] | ['s635595499', 's180496950'] | [2940.0, 2940.0] | [17.0, 17.0] | [98, 143] |
p03803 | u463775490 | 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)\nelif b == 1:\n print(Bob)\nelse:\n if a == b:\n print(Draw)\n elif a < b:\n print(Alice)\n else:\n print(Bob)', "a,b = map(int,input().split())\nif a == 1:\n if b == 1:\n print('Draw')\n else:\n print('Alice')\nelif b == 1:\n print('Bob')\nelse:\n if a == b:\n print('Draw')\n elif a < b:\n print('Alice')\n else:\n print('Bob')", "a,b = map(int,input().split())\nif a == 1:\n if b == 1:\n print('Draw')\n else:\n print('Alice')\nelif b == 1:\n print('Bob')\nelse:\n if a == b:\n print('Draw')\n elif a > b:\n print('Alice')\n else:\n print('Bob')"] | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s125247562', 's893364667', 's915706024'] | [3060.0, 3060.0, 3060.0] | [17.0, 17.0, 17.0] | [210, 222, 222] |
p03803 | u464912173 | 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\nprint('Draw' if a=b elif 'Alice' a>b else 'Bob') ", "a, b = map(int, input().split())\n\nif a == 1:\n a = 14\nif b == 1:\n b = 14\n\n\nprint('Draw' if a==b else 'Alice' if a>b else 'Bob') "] | ['Runtime Error', 'Accepted'] | ['s149678917', 's487426020'] | [2940.0, 2940.0] | [17.0, 17.0] | [128, 133] |
p03803 | u466826467 | 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 re\n\nfirst_line = input().split()\nn = int(first_line[0])\nm = int(first_line[1])\n\nn_list = []\nfor i in range(n):\n n_list.append(input())\nm_list = []\nfor i in range(m):\n m_list.append(input())\n\nmatch_flg = False\nfor i in range(0, n - m + 1):\n matchOb = re.match(m_list[0], n_list[i])\n if matchOb:\n start_pos = matchOb.start()\n end_pos = matchOb.end()\n for j in range(0, m):\n if n_list[i + j][start_pos:end_pos] == m_list[j] and j == m - 1:\n match_flg = True\n elif n_list[i + j][start_pos:end_pos] != m_list[j]:\n break\n\nif match_flg:\n print("Yes")\nelse:\n print("No")\n', 'cards = input().split()\nalice = int(cards[0])\nbob = int(cards[1])\n\nif alice == bob:\n print("Draw")\nelif alice == 1:\n print("Alice")\nelif bob == 1:\n print("Bob")\nelif alice < bob:\n print("Bob")\nelse :\n print("Alice")'] | ['Runtime Error', 'Accepted'] | ['s862364008', 's020386173'] | [3316.0, 2940.0] | [25.0, 18.0] | [661, 230] |
p03803 | u468972478 | 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 >= 2:\n print("Alice")\nelif b == 1 or b > a >= 2:\n print("Bob")', 'a, b = map(int, input().split()\nif a == b:\n print("Draw")\nelif a == 1 or a > b:\n print("Alice")\nelse:\n print("Bob")', 'a, b = map(int, input().split()\nif a == b:\n print("Draw")\nelif a == 1 or (a > b >= 2):\n print("Alice")\nelse:\n print("Bob")', 'n, m = map(int, input().split())\na = [input() for i in range(n)]\nb = [input() for i in range(m)]\nfor i in a:\n for j in b:\n if j not in i:\n print("No")\n exit()\nprint("Yes")\n', 'a, b = map(int, input().split()\nif a == b:\n print("Draw")\nelif a == 1 or a > b >= 2:\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("Alice")\nelif a < b:\n print("Bob")\nelse:\n print("Draw")'] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s068498048', 's330126618', 's497945932', 's557983104', 's563720829', 's679079138'] | [8904.0, 9004.0, 8944.0, 9056.0, 8748.0, 9172.0] | [24.0, 24.0, 31.0, 25.0, 26.0, 24.0] | [148, 122, 129, 186, 127, 148] |
p03803 | u474270503 | 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 _ 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 t=[k[j:j*m] for k in a[i:i+m]]\n if t==B:\n print('Yes')\n exit()\nprint('No')\n", "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')\n"] | ['Runtime Error', 'Accepted'] | ['s112329526', 's449596569'] | [3060.0, 2940.0] | [17.0, 17.0] | [253, 145] |
p03803 | u474925961 | 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\nif sys.platform ==\'ios\':\n sys.stdin=open(\'input_file.txt\')\n \na,b=map(int,input().split())\n\nif a==1:\n\ta+=13\nif b==1:\n\tb+=13\n\nif a<b:\n\tprint("Alice")\n\t\nelif b<a:\n\tprint("Bob")\n\t\nelse:\n\tprint("Draw")', 'import sys\n\nif sys.platform ==\'ios\':\n sys.stdin=open(\'input_file.txt\')\n \na,b=map(int,input().split())\n\nif a==1:\n\ta+=13\nif b==1:\n\tb+=13\n\nif a>b:\n\tprint("Alice")\n\t\nelif b>a:\n\tprint("Bob")\n\t\nelse:\n\tprint("Draw")'] | ['Wrong Answer', 'Accepted'] | ['s587995975', 's448672415'] | [3060.0, 3060.0] | [17.0, 17.0] | [213, 213] |
p03803 | u475675023 | 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\nprint(["Alice" if A>B else "Draw","Bob"][A>=B])', 'A,B=map(int,input().split())\nif A==1:\n A+=13\nif B==1:\n B+=13\nprint(["Alice" if A>B else "Draw","Bob"][A<B])'] | ['Wrong Answer', 'Accepted'] | ['s505607853', 's946549798'] | [2940.0, 2940.0] | [17.0, 18.0] | [110, 109] |
p03803 | u475966842 | 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>B or A:\n print("Alice")\nelse:\n print("Bob")', 'A,B=map(int,input().split())\nif A==B:\n print("Draw")\nelif or(A>B,A==1):\n print("Alice")\nelse:\n print("Bob")', 's = [i for i in range(2,14)] + [1]\na, b = map(int, input().split())\nc=s.index(a)\nd=s.index(b)\nprint(\'Draw\' if c==d else ["Bob","Alice"][c > d])'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s290375441', 's967197876', 's243034940'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [113, 116, 143] |
p03803 | u479060428 | 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())\nelif A==B==1 :\n print("Draw")\nif A==1:\n print("Alice")\nelif B==1 :\n print("Bob")\nelif A<B:\n print("Bob")\nelif A>B:\n print("Alice")\nelif A==B:\n print("Draw")', 'A,B=map(int,input().split())\nif A==1:\n print(Alice)\nelif B==1 :\n print(Bob)\nelif A==B==1 :\n print(Draw)\nelif A<B:\n print(Bob)\nelif A>B:\n print(Alice)\nelif A==B:\n print(Draw)', 'A,B=map(int,input().split())\nif A==B==1 :\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")\nelif A==B:\n print("Draw")'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s355350228', 's513175535', 's536425026'] | [2940.0, 2940.0, 3060.0] | [17.0, 17.0, 17.0] | [203, 191, 203] |
p03803 | u483151310 | 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())\ncards = [num for num in range(2, 14)]\ncards.append(1)\n\nfor i in reversed(cards):\n if i == A and i == B:\n print("Draw")\n elif i == A and i != B:\n print("Alice")\n break\n else:\n print("Bob")\n break', 'A, B = map(int, input().split())\ncards = [num for num in range(2, 14)]\ncards.append(1)\n\nfor i in reversed(cards):\n if i == A and i == B:\n print("Draw")\n elif i == A and i != B:\n print("Alice")\n break\n elif i == B and i != A:\n print("Bob")\n break'] | ['Wrong Answer', 'Accepted'] | ['s518787792', 's655465689'] | [3060.0, 3060.0] | [18.0, 17.0] | [271, 289] |
p03803 | u486990800 | 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 & 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")\nelse :\n print("Draw")', 'A, B= map(int, input().split())\n\nif A==1:\n A = 14\n\nif B==1:\n B=14\n\nif A > B:\n print("Alicce")\nelif B < A:\n print("Bob")\nelse :\n print("Draw")', 'A, B= map(int, input().split())\n\nif A==1:\n A = 14\n\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', 'Wrong Answer', 'Accepted'] | ['s433461281', 's761172380', 's650426287'] | [2940.0, 2940.0, 3060.0] | [17.0, 17.0, 18.0] | [209, 156, 157] |
p03803 | u487288850 | 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 or a>b:\n print('Alice')\nelif b==1 and a!=1 or b>a:\n print('Bob')\nelse:\n print('Draw')", "a,b = map(int,input().split())\nif a==b:\n print('Draw')\nelif a==1 or b!=1 and a>b:\n print('Alice')\nelse:\n print('Bob')\n"] | ['Runtime Error', 'Accepted'] | ['s644361601', 's608164940'] | [8796.0, 9152.0] | [21.0, 28.0] | [138, 121] |
p03803 | u488127128 | 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+13)%15>(a+13)%15 else 'Bob')", "a,b = map(int, input().split())\nprint('Draw' if a==b else 'Alice' if (a+12)%14>(a+12)%14 else 'Bob')", "a,b = map(int, input().split())\nprint('Draw' if a==b else 'Alice' if (a+13)%15>(b+13)%15 else 'Bob')"] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s566566134', 's979056914', 's184204440'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [100, 100, 100] |
p03803 | u496340257 | 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. | ["#!/usr/bin/env python3\n\nAlice, Bob = map(int, input())\nif Alice == 1:\n Alice = 14\nif Bob == 1:\n Bob = 14\n\nif Alice > Bob:\n print('Alice')\nelif Bob > Alice:\n print('Bob')\nelse:\n print('Draw')", "#!/usr/bin/env python3\n\nAlice, Bob = map(int, input().split())\nif Alice == 1:\n Alice = 14\nif Bob == 1:\n Bob = 14\n\nif Alice > Bob:\n print('Alice')\nelif Bob > Alice:\n print('Bob')\nelse:\n print('Draw')\n"] | ['Runtime Error', 'Accepted'] | ['s993641596', 's838180270'] | [3060.0, 2940.0] | [17.0, 18.0] | [205, 214] |
p03803 | u496687522 | 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("Draw")\nelif A>B or A==1:\n print("Alice")\nelif\u3000A<B or B==1:\n print("Bob")', 'A, B = map(int, input().split())\n\nif A==B:\n print("Draw")\nelif A>B or A==1:\n print("Alice")\nelif:\u3000A<B or B==1:\n print("Bob")', 'A, B = map(int, input().split())\n\nif A==B:\n print("Draw")\nelif (A>B and B != 1) or A==1:\n print("Alice")\nelse:\n print(\'Bob\')'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s434070356', 's778914580', 's331490511'] | [2940.0, 2940.0, 3060.0] | [17.0, 17.0, 17.0] | [134, 135, 133] |
p03803 | u499259667 | 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("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())\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'] | ['s898979842', 's188969528'] | [2940.0, 2940.0] | [17.0, 17.0] | [155, 161] |
p03803 | u500297289 | 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 """\n\nA, 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")\n', '""" AtCoder """\n\nA, 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")\n'] | ['Runtime Error', 'Accepted'] | ['s211031058', 's095421738'] | [2940.0, 2940.0] | [18.0, 21.0] | [180, 179] |
p03803 | u502149531 | 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. | [", 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('Bob')\nelse :\n print('Draw')", "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('Bob')\nelse :\n print('Draw')"] | ['Runtime Error', 'Accepted'] | ['s040861229', 's331185250'] | [2940.0, 2940.0] | [17.0, 17.0] | [163, 164] |
p03803 | u506549878 | 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\nN,M = map(int,input().split())\nL=[]\nfor i in range(M):\n a,b=map(int,input().split())\n L.append([a,b])\n \nnumber=[]\nfor i in range(1,N+1):\n number.append(i)\n \nans=0\n \nfor v in itertools.permutations(number,N):\n a=0\n v=list(v)\n for j in range(N-1):\n if ([v[j],v[j+1]] not in L ) and ([v[j+1],v[j]] not in L):\n a=1\n if a==0 and v[0]==1:\n ans+=1\n \nprint(ans)', "alice, bob = map(int, input().split())\nif alice == 1 and bob != 1:\n print('Alice')\nelif alice != 1 and bob == 1:\n print('Bob')\nelif alice == bob:\n print('Draw')\nelse:\n if alice < bob:\n print('Bob')\n else:\n print('Alice')"] | ['Runtime Error', 'Accepted'] | ['s197767510', 's139260315'] | [8952.0, 9028.0] | [27.0, 27.0] | [419, 249] |
p03803 | u506858457 | 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')\nelse if A=='1':\n print('Alice')\nelse if B=='1':\n print('Bob')\nelse if 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'] | ['s072189398', 's530190883'] | [2940.0, 2940.0] | [17.0, 17.0] | [168, 155] |
p03803 | u507116804 | 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\nelse:\n a=a+0\nif b==1:\n b=14\nelse:\n b=b+0\n \nif a>b:\n print("Alice")\nelif a==b:\n print("Draw")\nelse a<b:\n print("Bob")', 'a,b=map(int, input().split())\n\nif a==1:\n k=14\nelse:\n k=a\nif b==1:\n m=14\nelse:\n m=b\n \nif k>m:\n print("Alice")\nelif k==m:\n print("Draw")\nelse k<m:\n print("Bob")', 'a,b=map(int, input().split())\n\nif a==1:\n a=14\nelse:\n a=a\nif b==1:\n b=14\nelse:\n b=b\n \nif a>b:\n print("Alice")\nelif a=b:\n print("Draw")\nelse a<b:\n print("Bob")\n', 'a , b =(map(int , input().split()))\n\nif a==1:\n a=a+13\n\nif b==1:\n b=b+13\n \nif a>b :\n print("Alice")\n\nelif a<b:\n print("Bob")\n\nelse:\n print("Draw")\n '] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s011117553', 's014645617', 's078694477', 's920369834'] | [2940.0, 2940.0, 2940.0, 3064.0] | [17.0, 20.0, 18.0, 18.0] | [170, 166, 166, 154] |
p03803 | u518556834 | 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())\nif a == 1:\n a += 13\nif b == 1:\n b += 13\nif a > b:\n print("Alice")\nif a < b:\n print("Bob")\nif a == b:\n print("Drow")', 'a,b = map(int,input().split())\nif a == 1:\n a += 13\nif b == 1:\n b += 13\nif a > b:\n print("Alice")\nif a < b:\n print("Bob")\nif a == b:\n print("Draw")\n'] | ['Runtime Error', 'Accepted'] | ['s291433758', 's921045164'] | [2940.0, 2940.0] | [17.0, 17.0] | [139, 152] |
p03803 | u524747996 | 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("A")\nelif A < B:\n print("B")\nelse:\n print("Draw")', 'A, B = map(int, input().split())\nC = [2,3,4,5,6,7,8,9,10,11,12,13,1]\n\nif C.index(A) > C.index(B):\n print("Alice")\nelif C.index(A) < C.index(B):\n print("Bob")\nelse:\n print("Draw")'] | ['Wrong Answer', 'Accepted'] | ['s176532323', 's139581145'] | [2940.0, 3060.0] | [17.0, 17.0] | [109, 187] |
p03803 | u528720841 | 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 (b != 1 and A>B):\n print("Alice")\nelse:\n print("Bob");\n', 'A,B = map(int, input().split())\nif A==B:\n print("draw")\nelif A == 1 or (b != 1 and A>B):\n print("Alice")\nelse:\n print("Bob")\n', 'A,B = map(int, input().split())\nif A==B:\n print("Draw")\nelif A == 1 or (B != 1 and A>B):\n print("Alice")\nelse:\n print("Bob")'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s348405359', 's678712240', 's124540675'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [129, 128, 127] |
p03803 | u532099150 | 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("Draw")\nelif a > b:\n if b == 1:\n print("Bob")\n break\n print("Alice")\nelse:\n print("Bob")', 'a,b=map(int, input().split())\n\nif a == b:\n print("Draw")\nelif a > b:\n if b == 1:\n print("Bob")\n else:\n print("Alice")\nelse:\n if a == 1:\n print("Alice")\n else:\n print("Bob") \n '] | ['Runtime Error', 'Accepted'] | ['s984974465', 's837304308'] | [2940.0, 2940.0] | [17.0, 17.0] | [163, 222] |
p03803 | u532966492 | 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-2)%13 < (b-2)%13:\n print("Alice")\nelif a == b:\n print("Draw")\nelse:\n print("Bob")', 'a,b=map(int,input().split())\nif (a-2)%13 > (b-2)%13:\n print("Alice")\nelif a == b:\n print("Draw")\nelse:\n print("Bob")'] | ['Wrong Answer', 'Accepted'] | ['s811619683', 's173776871'] | [2940.0, 2940.0] | [17.0, 18.0] | [119, 119] |
p03803 | u536177854 | 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 and B!=1):\n print('Alice')\nelse:\n print('Bob')", "a,b=map(int,input().split())\nif a==b:\n print('Draw')\nelif a==1 or (a>b and b!=1):\n print('Alice')\nelse:\n print('Bob')"] | ['Runtime Error', 'Accepted'] | ['s376997573', 's040243674'] | [2940.0, 2940.0] | [17.0, 17.0] | [120, 120] |
p03803 | u543954314 | 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. | ['s = [int(i) for i in input().split()]\nfor i in range(2):\n if s[i] == 1:\n s[i] += 13\nprint(s)\nif s[0] > s[1]:\n print("Alice")\nelif s[0] < s[1]:\n print("Bob")\nelse:\n print("Draw")', 's = [int(i) for i in input().split()]\nfor i in range(2):\n if s[i] == 1:\n s[i] += 13\nif s[0] > s[1]:\n print("Alice")\nelif s[0] < s[1]:\n print("Bob")\nelse:\n print("Draw")'] | ['Wrong Answer', 'Accepted'] | ['s693743350', 's831411210'] | [3060.0, 3060.0] | [18.0, 17.0] | [184, 175] |
p03803 | u553070631 | 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()))\ns=[2,3,4,5,6,7,8,9,10,11,12,13,1]\nif a.index=b.index:\n print('Draw')\nelif a.index>b.index:\n print('Alice')\nelse:\n print('Bob')", "a,b=map(int(input().split()))\ns=[2,3,4,5,6,7,8,9,10,11,12,13,1]\nif s.index(a)==s.index(b):\n print('Draw')\nelif s.index(a)>s.index(b):\n print('Alice')\nelse:\n print('Bob')", "a,b=map(int,input().split())\ns=[2,3,4,5,6,7,8,9,10,11,12,13,1]\nif s.index(a)==s.index(b):\n print('Draw')\nelif s.index(a)>s.index(b):\n print('Alice')\nelse:\n print('Bob')"] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s191665084', 's378346198', 's917324878'] | [2940.0, 3060.0, 3060.0] | [17.0, 18.0, 17.0] | [165, 178, 177] |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.