TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):

def main():
    a, b = map(int, input().split())
    if a-2 < 0:
        a = 14

    if b-2 < 0:
        b = 14i

    if a-2 > b-2:
        print('Alice')
    elif a-2 < b-2:
        print('Bob')
    else:
        print('Draw')


if __name__ == "__main__":
    main()




def main():
    a, b = map(int, input().split())
    if a-2 < 0:
        a = 14

    if b-2 < 0:
        b = 14

    if a-2 > b-2:
        print('Alice')
    elif a-2 < b-2:
        print('Bob')
    else:
        print('Draw')


if __name__ == "__main__":
    main()



Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
#54b
n,m =map(int,input().split())
a=[input() for _ in range(n)]
b=[input() for _ in range(m)]

for i in range(n-m+1):
    for j in range(n-m+1):
        t = [k[j:j+m] for k in a[i:i+m]]
        if t==b:
            print('Yes')
            exit()
print('No')

#54a
a,b =map(int,input().split())
if a==b:
    print('Draw')
elif a==1 :
    print('Alice')
elif b==1:
    print('Bob') 
elif a>b:
    print('Alice')
else :
    print('Bob')

Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A, B = map(int, input().split())
if A == B:
  print('Draw')
else:
  if A == 1:
    print('Alice')
  elif B == 1:
    print('Bob')
  elif A < B:
    print('Bob')
  else B < A:
    print('Alice')

A, B = map(int, input().split())
if A == 1 and B != 1:
  print('Alice')
elif A == 1 and B == 1:
  print('Draw')
elif A != 1 and B == 1:
  print('Bob')
elif A < B:
  print('Alice')
elif B < A:
  print('Bob')
else:
  print('Draw')

A, B = map(int, input().split())
if A == B:
  print('Draw')
else:
  if A == 1:
    print('Alice')
  elif B == 1:
    print('Bob')
  elif A < B:
    print('Bob')
  elif B < A:
    print('Alice')

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
a = [int(i) for i in input().split()] 
if a[0] == 1:
  a[0] = a[0] +13
if a[1] ==1:
  a[1] = a[1] + 13
if a[0] > a[1]:
  print("Alice")
elif a[0] < a[1]:
  print("Bob")
else
  print("Draw")

a = [int(i) for i in input().split()] 
if a[0] == 1:
  a[0] = a[0] + 13

if a[1] == 1:
  a[1] = a[1] + 13

  
if a[0] > a[1]:
  print("Alice")
elif a[0] < a[1]:
  print("Bob")
else:
  print("Draw")

Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A, B = map(int, input().split())

if A < B:
    print('Alice')
if A > B:
    print('Bob')
else:
    print('Draw')

A, B = map(int, input())

if A < B:
    print('Alice')
if A > B:
    print('Bob')
else:
    print('Draw')

A, B = map(int, input().split())

if A == 1:
    A += 12
if B == 1:
    B += 12

if A < B:
    print('Alice')
if A > B:
    print('Bob')
else:
    print('Draw')

A, B = map(int, input().split())

if A == 1:
    A += 12
if B == 1:
    B += 12

if A > B:
    print('Alice')
if A < B:
    print('Bob')
else:
    print('Draw')

A, B = map(int, input().split())

if A = 1:
    A += 12
if B = 1:
    B += 12

if A < B:
    print('Alice')
if A > B:
    print('Bob')
else:
    print('Draw')

A, B = map(int, input().split())

if A == 1:
    A += 13
if B == 1:
    B += 13

if A > B:
    print('Alice')
elif A < B:
    print('Bob')
else:
    print('Draw')

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Wrong Answer

Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A, B = map(int,input().split())

if A == 1 and B != 1:
    if B != 1 :
        print("Alice")

if B == 1 and A != 1:
    if A != 1 :
        print("Bob")

if A == 1 and B == 1 :
    print("Draw")

if A != 1 and B !=1 :
    if A > B :
        print("Alice")
    if A < B :
        print("Bob")
    else :
        print("Draw")

A, B = map(int,input().split())

if A == 1 :
    if B != 1 :
        print("Alice")
    else  :
        print("Draw")

if B == 1 :
    if A != 1 :
        print("Bob")
    else :
        print("Draw")

if A != 1 and B !=1 :
    if A > B :
        print("Alice")
    if A < B :
        print("Bob")
    else :
        print("Draw")

A, B = map(int,input().split())

if A == 1 and B != 1:
    if B != 1 :
        print("Alice")

if B == 1 and A != 1:
    if A != 1 :
        print("Bob")

if A == 1 and B == 1 :
    print("Draw")

if A != 1 and B !=1 :
    if A > B :
        print("Alice")
    if A < B :
        print("Bob")
    if A == B :
        print("Draw")

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
a,b=map(int,input().split())
a=14 if a==1 else a
b=14 if b==1 else b

if a>b:
  print("Alice")
if a<b:
  print("Bob")
else:
  print("Draw")

a,b=map(int,input().split())
a=14 if a==1 else a
b=14 if b==1 else b

if a>b:
  print("Alice")
elif a<b:
  print("Bob")
else:
  print("Draw")

Verdicts: Wrong Answer

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
a,b = map(int,input().split())
print("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())
print("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")

Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def POW(x, y):
    if y == 0:
        return 1
    elif y == 1:
        return x
    elif y % 2 == 0:
        return POW(x, y // 2) ** 2 % MOD
    else:
        return POW(x, y // 2) ** 2 * x % MOD
def mod_factorial(x, y): return x * POW(y, MOD - 2) % MOD
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()
from functools import reduce

def binomials(n, k):
    ret = [0] * (n + 1)
    ret[k] = 1
    denomi = mod_factorial(1, reduce(lambda x, y: x * y % MOD, range(1, k), 1))
    for i in range(k - 1, n):
        numeri = reduce(lambda x, y: x * y % MOD, range(i - k + 2, i + 1), 1)
        ret[i + 1] = numeri * denomi % MOD
    return ret

def main():
    if A > B:
        ans = 'Alice'
    elif A == B:
        ans = 'Draw'
    else:
        ans = 'Bob'
    return ans

print(main())

import sys
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def POW(x, y):
    if y == 0:
        return 1
    elif y == 1:
        return x
    elif y % 2 == 0:
        return POW(x, y // 2) ** 2 % MOD
    else:
        return POW(x, y // 2) ** 2 * x % MOD
def mod_factorial(x, y): return x * POW(y, MOD - 2) % MOD
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return input()
from functools import reduce

def main():
    A, B = LI()
    if A == 1:
        A = 14
    if B == 1:
        B = 14
    if A > B:
        ans = 'Alice'
    elif A == B:
        ans = 'Draw'
    else:
        ans = 'Bob'
    return ans

print(main())

Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
a,b=list(map(int,input().split()))
if a>b:
  print("Alice")
elif a=b:
  print("Draw")
else:
  print("Bob")

a,b=list(map(int,input().split()))
if a == 1:
  a += 13
if b == 1:
  b += 13

if a > b:
  print("Alice")
elif a==b:
  print("Draw")
else:
  print("Bob")

Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
a, b = map(int, input().split())
if a == b : print('Draw')
else :
  if min(a, b) == 1 : flag = True
  if a < b :
    if flag : print('Alice')
    else : print('Bob')
  else :
    if flag : print('Bob')
    else : print('Alice')


a, b = map(int, input().split())
if a == b : print('Draw')
else :
  if min(a, b) == 1 : flag = TRUE
  if a < b :
    if flag : print('Alice')
    else : print('Bob')
  else :
    if flag : print('Bob')
    else : print('Alice')


a, b = map(int, input().split())
if a == b : print('Draw')
else :
  flag = False
  if min(a, b) == 1 : flag = True
  if a < b :
    if flag : print('Alice')
    else : print('Bob')
  else :
    if flag : print('Bob')
    else : print('Alice')


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A. B = list(map(int, input().split()))
if A == B:
    ans = 'Draw'
elif A == 1:
    ans = 'Alice'
elif B == 1:
    ans = 'Bob'
else:
    ans = 'Alice' if A > B else 'Bob'

print(ans)


A, B = list(map(int, input().split()))
if A == B:
    ans = 'Draw'
elif A == 1:
    ans = 'Alice'
elif B == 1:
    ans = 'Bob'
else:
    ans = 'Alice' if A > B else 'Bob'

print(ans)


Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A,B=map(int,input().split())
 
if A>B or A==1 not B==1:
  print("Alice")
elif A==B:
  print("Draw")
else:    
  print("Bob")

A,B=map(int,input().split())
 
if A==B:
  print("Draw")
elif B>1 and A==1 or A>B:
  print(""Alice)
else:
  print("Bob")

A,B=map(int,input().split())
 
if A==B:
  print("Draw")
elif B==1:
  print("Bob")
elif B>1 and A==1 or A>B:
  print("Alice")
else:
  print("Bob")

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
a,b=map(int,input().split())
if a=b:
  print('Draw')
elif a=1 or a>b:
  print('Alice')
elif b=1 or a<b:
  print('Bob')

a,b=map(int,input().split())
if a>b:
  print('Alice')
if a=b:
  print('Draw')
else:
  print('Bob')

a,b=map(int,input().split())
if a=b:
  print('Draw')
elif a=1:
  print('Alice')
elif b=1:
  print('Bob')
elif a>b:
  print('Alice')
else:
  print('Bob')

a,b=map(int,input().split())
if a==b:
  print('Draw')
elif a==1
  print('Alice')
elif b==1
  print('Bob')
elif a > b:
  print('Alice')
else:
  print('Bob')

a,b=map(int,input().split())
if a==b:
  print('Draw')
elif a==1
  print('Alice')
elif b==1
  print('Bob')
elif a>b:print('Alice')
elif a<b:print('Bob')

a,b=map(int,input().split())
if a==b:
  print('Draw')
elif a==1:
  print('Alice')
elif b==1:
  print('Bob')
elif a > b:
  print('Alice')
else:
  print('Bob')

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A, B = map(int, input().split())
if A == B:
  print('Draw')
else:
  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())
if A == B:
  print('Draw')
else:
  print( 'Alice' if (A if A != 1 else A+13) > (B if B != 1 else B+13) else 'Bob')


Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
a, b = map(int, input().split())

if a == b:
    print("Draw")
elif a == 1:
    print("Alice"):
elif b == 1:
    print("Bob")
elif a < b:
    print("Bob")
else:
    print("Alice")

a, b = map(int, input().split())

if a == b:
    print("Draw")
elif a == 1:
    print("Alice")
elif b == 1:
    print("Bob")
elif a < b:
    print("Bob")
else:
    print("Alice")

Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A,B = map(int,input().split())
tmp = list(A,B)
ans = ["Alice","Bob"]
if tmp[0] == tmp[1]:
    print("Draw")
elif tmp[0] == 1:
    print(ans[0])
elif tmp[1] == 1:
    print(ans[1])
elif tmp[0] > tmp[1]:
    print(ans[0])
else:
    print(ans[1])

A,B = map(int,input().split())
tmp = [A,B]
ans = ["Alice","Bob"]
if tmp[0] == tmp[1]:
    print("Draw")
elif tmp[0] == 1:
    print(ans[0])
elif tmp[1] == 1:
    print(ans[1])
elif tmp[0] > tmp[1]:
    print(ans[0])
else:
    print(ans[1])

Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
a,b=map(int,input.split())
if a==b:
  print('Draw')
elif a==1:
  print('Alice')
elif b==1:
  print('Bob')
elif a>b:
  print('Alice')
else:
  print('Bob')

a,b=map(int,input.split())
if a==b:
  print('Draw')
elif a==1:
  print('Alice')
elif b==1:
  print('Bob')
elif a>b:
  print('Alice')
elif a<b:
  print('Bob')


a,b=map(int,input().split())
if a==b:
  print('Draw')
elif a==1:
  print('Alice')
elif b==1:
  print('Bob')
elif a>b:
  print('Alice')
elif a<b:
  print('Bob')


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A, B = map(str, input().split())
A.replace('1', '14')
B.replace('1', '14')
print('Draw' if A == B else max(A, B))

A, B = map(int, input().split())
if A == 1:
    A += 13
if B == 1:
    B += 13
print('Alice' if A > B else 'Draw' if A == B else 'Bob')

Verdicts: Wrong Answer

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
a, b = map(lambda x: 14 if x=="1" else int(x), input().split())
if a>b:
  print()

a, b = map(lambda x: 14 if x=="1" else int(x), input().split())
if a>b:
  print("Alice")
elif a<b:
  print("Bob")
else:
  print("Draw")

Verdicts: Wrong Answer

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
a,b = (int(x) for x in input.split())

if a==1:
    a=14
if b==1:
    b=14

if a>b:
    print("Alice")
elif a<b:
    print("Bob")
else:
    print("Draw")


a,b = (int(x) for in input.split())

if a==1:
    a=14
if b==1:
    b=14

if a>b:
    print("Alice")
elif a<b:
    print("Bob")
else:
    print("Draw")

a,b = (int(x) for x in input().split())

if a==1:
    a=14
if b==1:
    b=14

if a>b:
    print("Alice")
elif a<b:
    print("Bob")
else:
    print("Draw")


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
from collections import *
n,m=map(int,input().split())
d=defaultdict(list)
for s in m*[0]:
    a,b=map(int,input().split())
    d[a].append(b)
    d[b].append(a)
def DFS_dict(point,TFlist):
    if all(TFlist):
        return 1
    ans=0
    for i in d[point]:
        if TFlist[i-1]:
            continue
        TFlist[i-1]=True
        ans+=DFS_dict(i,TFlist)
        TFlist[i-1]=False
    return ans
TFlist=[True]+[False]*(n-1)
print(DFS_dict(1,TFlist))

a,b=map(int,input().split())
if a==1:a+=13
if b==1:b+=13
if a>b:print("Alice")
elif b>a:print("Bob")
else:print("Draw")

Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
n,m=map(int,input().split())
i1=[input() for _ in range(n)]
i2=[input() for _ in range(m)]
ans="No"
for i in range(n-m+1):
    for j in range(n-m+1):
        if i1[i][j:m+j]==i2[0] and i1[i+1][j:j+m]==i2[1]:
            ans="Yes"
print(ans)

a,b=map(int, input().split())
if a==b:
  print("Draw")
elif a==1 or (a>b and b!=1):
  print("Alice")
else:
  print("Bob")

Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A, B = map(int, input().split())

a = 14 if A == 1 else A
b = 14 if b == 1 else B
print('Alice' if a > b else 'Bob' if a < b else 'Draw')


A, B = map(int, input().split())

a = 14 if A == 1 else A
b = 14 if B == 1 else B
print('Alice' if a > b else 'Bob' if a < b else 'Draw')


Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
a, b = map(int, input().split())
if a == 1:
    a = 14
if: b == 1:
    b = 14
if a < b:
    print("Bob")
elif a > b:
    print("Alice")
else:
    print("Draw")

a, b = map(int, input().split())
if a == 1:
    a = 14
if b == 1:
    b = 14
if a < b:
    print("Bob")
elif a > b:
    print("Alice")
else:
    print("Draw")

Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
#include <bits/stdc++.h>
using namespace std;
int main(){
    int A, B;
    cin >> A >> B;
    if (A == B) cout << "Draw" << endl;
    else if (A == 1) cout << "Alice" << endl;
    else if (B == 1) cout << "Bob" << endl;
    else if (A > B) cout << "Alice" << endl;
    else cout << "Bob" << endl;
}


a, b = map(int, input().split())
if a == 1:
    a = 14
if b == 1:
    b = 14
if a > b:
    print("Alice")
elif a == b:
    print("Draw")
else:
    print("Bob")

Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A,B=map(int,input().split())
if A==1:
  A+=13
if B==1:
  B+=13:

if A==B:
  print("Draw")
elif A<B:
  print("Bob")
else:
  print("Alice")

A,B=map(int,input().split())
if A==1:
  A+=13
if B==1:
  B+=13

if A==B:
  print("Draw")
elif A<B:
  print("Bob")
else:
  print("Alice")


Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A,B=map(int,input().split())
if A=1:
    A=14
if B=1:
    B=14
print(['ABloibc e'[A<B::2],'Draw'][A==B])

A,B=map(int,input().split())
A=(A-2)%13
B=(B-2)%13
print(['Draw','Alice','Bob'][(A>B)-(B>A)])

Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
a, b = map(int, input().split())

if a == 1:
    a = 14

if b == 1:
    b = 14

print(a, b)

if a < b:
    print("Bob")
elif b < a:
    print("Alice")
else:
    print("Draw")


a, b = map(int, input().split())

if a == 1:
    a = 14

if b == 1:
    b = 14



if a < b:
    print("Bob")
elif b < a:
    print("Alice")
else:
    print("Draw")


Verdicts: Wrong Answer

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A, B = map(int,input())
if(A == B):
    print('Draw')
elif(B != 1 and (A == 1 or A > B)):
    print('Alice')
elif(A != 1 and (B == 1 or B > A)):
    print('Bob')

A, B = map(int,input().split())
if(A == B):
    print('Draw')
elif(B != 1 and (A == 1 or A > B)):
    print('Alice')
elif(A != 1 and (B == 1 or B > A)):
    print('Bob')

Verdicts: Runtime Error

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A,B = map(int,input().split())

if A==B:
  result = 'Draw'
elif (A < B and A!=1) or B==1:
  result = 'Bob'
else:
  result ='Alice'

A,B = map(int,input().split())

if A==B:
  result = 'Draw'
elif (A < B and A!=1) or B==1:
  result = 'Bob'
else:
  result ='Alice'
print(result)

Verdicts: Wrong Answer

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
# -*- coding: utf-8 -*-
# A - One Card Poker

A,B = list(map(int, input().split()))


if A == 1:
    A = 14
if B == 1:
    B = 14

if A == B:
    print("Draw")
elif A > B:
    print("Alica")
else:
    print("Bob")

# -*- coding: utf-8 -*-
# A - One Card Poker

A,B = list(map(int, input().split()))


if A == 1:
    A = 14
if B == 1:
    B = 14

if A == B:
    print("Draw")
elif A > B:
    print("Alice")
else:
    print("Bob")

Verdicts: Wrong Answer

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
a,b=map(int,input().split())
if a==1:
    a=14
if b==1:
    b=14
if a<b:
    print('Bob')
elif a<b:
    print('Alice')
else:
    print('Draw')

a,b=map(int,input().split())
if a==1:
    a=14
if b==1:
    b=14
if a<b:
    print('Bob')
elif a>b:
    print('Alice')
else:
    print('Draw')

Verdicts: Wrong Answer

Accepted
Problem: Alice and Bob are playing _One Card Poker_.   One Card Poker is a two-player game using playing cards.  Each card in this game shows an integer between `1` and `13`, inclusive.   The _strength_ of a card is determined by the number written on it, as follows:  Weak `2` < `3` < `4` < `5` < `6` < `7` < `8` < `9` < `10` < `11` < `12` < `13` < `1` Strong  One Card Poker is played as follows:    1. Each player picks one card from the deck. The chosen card becomes the player's hand.   2. The players reveal their hands to each other. The player with the stronger card wins the game.   If their cards are equally strong, the game is drawn.  You are watching Alice and Bob playing the game, and can see their hands.   The number written on Alice's card is A, and the number written on Bob's card is B.   Write a program to determine the outcome of the game.

Submission attempts (in order):
A,B=map(int,input(),split())
a=A%13
b=B%13
if A>B:
  print("Alice")
elif B>A:
  print("Bob")
else:
  print("Draw")
  


A,B=map(int,input().split())
a=14 if A==1 else A
b=14 if B==1 else B
if a>b:
  print("Alice")
elif b>a:
  print("Bob")
else:
  print("Draw")

Verdicts: Runtime Error

Accepted