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):
A,B=map(int,input().split())

def judge(a,b):
  if a > b:
    return "Alice"
  elif a = b:
    return "Draw"
  else:
    return "Bob"
  
print(judge(A,B))

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

def judge(a,b):
  if a > b > 1 or (a == 1 and b != 1):
    return "Alice"
  elif a == b:
    return "Draw"
  else:
    return "Bob"
  
print(judge(A,B))


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
elif B == 1:
    B = 14
if A > B:
    print("Alice")
elif A < B:
    print("Bob")
else:
    print("Draw")

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("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):
w,h=map(int,input().split())
if w/h==4/3:
    ans="4:3"
else:
    ans="16:9"
print(ans)

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

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 = list(input().split())
a.replace("1","99")
if int(a[0]) > int(a[1]):
  print("Bob")
elif int(a[0]) == int(a[1]):
  print("Draw")
else:
  print("Alice")


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

a = list(map(int,input().split()))
a.replace(1,99)
if a[0] > a[1]:
  print("Bob")
elif a[0] == a[1]:
  print("Draw")
else:
  print("Alice")

a = list(map(int,input().split()))
if a[0] > a[1]:
  print("Bob")
elif a[0] == a[1]:
  print("Draw")
else:
  print("Alice")


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

Verdicts: Runtime Error

Runtime Error

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):
lis=input().split()
a=int(lis[0])
b=int(lis[1])
if a=1:
    if b=1:
        print(Draw)
    else :
        print(Alice)
elif b=1:
    print(Bob)
else :
    if a>b:
        print(Alice)
    elif a=b:
        print(Draw)
    else :
        print(Bob)

lis=input().split()
a=int(lis[0])
b=int(lis[1])
if a==1:
    if b==1:
        print("Draw")
    else :
        print("Alice")
elif b==1:
    print("Bob")
else :
    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()))

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")

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: 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")
elif a=b:
    print("Draw")
else:
    print("Bob")

a=(int(input())-2)%13
b=(int(input())-2)%13
print(["Draw","Bob","Alice"][((a==b)+1)*((a<b)-(b<a))])

a,b=map(int,input().split())
a=(a-2)%13
b=(b-2)%13
print(["Draw","Bob","Alice"][(a==b+1)*(a<b-b<a)])

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

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")

a,b=map(int,input().split())
a=(a-2)%13
b=(b-2)%13
print([["Alice","Draw"][a==b],"Bob"][a<b])

Verdicts: Runtime Error

Runtime Error

Wrong Answer

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):
i = [int(s) for s in input().split()]
alice = i[0]
bob = i[1]

if alice == bob:
    print("draw")
elif alice == 1:
    print("alice")
elif bob == 1:
    print("bob")
elif alice < bob:
    print("bob")
else:
    print("alice")


i = [int(s) for s in input().split()]
alice = i[0]
bob = i[1]

if alice == bob:
    print("Draw")
elif alice == 1:
    print("Alice")
elif bob == 1:
    print("Bob")
elif bob < alice:
    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):
p=[2,3,4,5,6,7,8,9,10,11,12,13,1]
a,b=map(int,input().split())
print('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]
a,b=map(int,input().split())
print('ABloibc e'[p.index(a)<p.index(b)::2] 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 and B != 1:
	if A > B:
  	  print("Alice")
	elif B > A:
  	  print("Bob")
	elif A == B:
      print("Draw")
else:
  if A == 1:
    print("Alice")
  else:
   	print("Bob")

A, B = map(int, input().split())
if A != 1 and B != 1 and A > B:
  	print("Alice")
elif  A != 1 and B != 1 and B > A:
    print("Bob")
elif A == B:
    print("Draw")
elif A == 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())+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
b = (int(input())+13) % 15

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


x,y=map(int,input().split())
a = (x + 13) % 15
b = (y + 13) % 15
print('Alice' if a > b else 'Bob' if a < b else 'Draw')


Verdicts: 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(lambda x:(int(x) + 13) % 15, input().split())
if a > b: print("Alice")
  if a < b: print("Bob")
    else: print("Draw")

a, b = map(lambda x:(int(x) + 13) % 15, input().split())
if a > b: print("Alice")
elif a < b: 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 == 1:
    a = 14

if b == 1:
    b = 14

print(a,b)
    
if a > b:
    print('Alice')
elif b > a:
    print('Bob')
else:
    print('Draw')

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

if b == 1:
    b = 14
    
if a > b:
    print('Alice')
elif b > a:
    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())

if a == b:
    print("Draw")
elif a == 1 and b != 1:
            print("Alice")
elif a != 1 and 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 B != 1:
            print("Alice")
elif a != 1 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 and b != 1:
            print("Alice")
elif a != 1 and 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 B != 1:
            print("Alice")
elif a != 1 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 and b != 1:
            print("Alice")
elif a != 1 and 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 and b != 1:
            print("Alice")
elif a != 1 and b == 1:
            print("Bob")
elif a < b:
            print("Bob")
else:
            print("Alice")
    

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

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):
def main():
    cards = [2,3,4,5,6,7,8,9,10,11,12,13,1]
    A, B = map(int, input().split())
    if cards.index(A) > cards.index(B):
        print('Alice')
    elif cards.index(A) < cards.index(B):
        print('Bob')
    else:
        print('Draw')

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')

# -*- coding: utf-8 -*-
def main():
    cards = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1]
    A, B = map(int, input().split())
    if cards.index(A) > cards.index(B):
        print('Alice')
    elif cards.index(A) < cards.index(B):
        print('Bob')
    else:
        print('Draw')

if __name__ == '__main__':
    main()

Verdicts: 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 = input().split()
a, b = int(a), int(b)
print("Draw" if a == b elif a < b "Bob" else "Alice")

a, b = input().split()
a, b = int(a), int(b)
if a == 1:
  a += 13
if b == 1:
  b += 13
print("Alice" if a > b else "Draw" if a == b 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 == 1:
  if b == 1:
    print(Draw)
  else:
    print(Alice)
elif b == 1:
  print(Bob)
else:
  if a == b:
    print(Draw)
  elif a < b:
    print(Alice)
  else:
    print(Bob)

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

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

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, b = map(int, input().split())

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

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

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

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


print('Draw' if a==b else 'Alice' if a>b 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):
import re

first_line = input().split()
n = int(first_line[0])
m = int(first_line[1])

n_list = []
for i in range(n):
    n_list.append(input())
m_list = []
for i in range(m):
    m_list.append(input())

match_flg = False
for i in range(0, n - m + 1):
    matchOb = re.match(m_list[0], n_list[i])
    if matchOb:
        start_pos = matchOb.start()
        end_pos = matchOb.end()
        for j in range(0, m):
            if n_list[i + j][start_pos:end_pos] == m_list[j] and j == m - 1:
                match_flg = True
            elif n_list[i + j][start_pos:end_pos] != m_list[j]:
                break

if match_flg:
    print("Yes")
else:
    print("No")


cards = input().split()
alice = int(cards[0])
bob = int(cards[1])

if alice == bob:
    print("Draw")
elif alice == 1:
    print("Alice")
elif bob == 1:
    print("Bob")
elif alice < bob:
    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 == b:
  print("Draw")
elif a == 1 or a > b >= 2:
    print("Alice")
elif b == 1 or b > a >= 2:
    print("Bob")

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

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

n, m = map(int, input().split())
a = [input() for i in range(n)]
b = [input() for i in range(m)]
for i in a:
  for j in b:
    if j not in i:
      print("No")
      exit()
print("Yes")


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

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("Bob")
else:
  print("Draw")

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):
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')


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):
import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
   
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")

import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
   
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: 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+=13
if B==1:
  B+=13
print(["Alice" if A>B else "Draw","Bob"][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","Bob"][A<B])

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==B:
    print("Draw")
elif (A>B or A:
    print("Alice")
else:
    print("Bob")

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

s = [i for i in range(2,14)] + [1]
a, b = map(int, input().split())
c=s.index(a)
d=s.index(b)
print('Draw' if c==d else ["Bob","Alice"][c > d])

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())
elif A==B==1 :
    print("Draw")
if A==1:
    print("Alice")
elif B==1 :
    print("Bob")
elif A<B:
    print("Bob")
elif A>B:
    print("Alice")
elif A==B:
    print("Draw")

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

A,B=map(int,input().split())
if A==B==1 :
    print("Draw")
elif A==1:
    print("Alice")
elif B==1 :
    print("Bob")
elif A<B:
    print("Bob")
elif A>B:
    print("Alice")
elif A==B:
    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):
A, B = map(int, input().split())
cards = [num for num in range(2, 14)]
cards.append(1)

for i in reversed(cards):
    if i == A and i == B:
        print("Draw")
    elif i == A and i != B:
        print("Alice")
        break
    else:
        print("Bob")
        break

A, B = map(int, input().split())
cards = [num for num in range(2, 14)]
cards.append(1)

for i in reversed(cards):
    if i == A and i == B:
        print("Draw")
    elif i == A and i != B:
        print("Alice")
        break
    elif i == B and i != A:
        print("Bob")
        break

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 & B==!:
    print("Draw")
elif A==1 :
    print("Alice")
elif 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==1:
    A = 14

if B==1:
    B=14

if A > B:
    print("Alicce")
elif B < A:
    print("Bob")
else :
    print("Draw")

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

if A==1:
    A = 14

if B==1:
    B = 14

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

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,b = = map(int,input().split())
if a==1 and b!=1 or a>b:
  print('Alice')
elif b==1 and a!=1 or b>a:
  print('Bob')
else:
  print('Draw')

a,b = map(int,input().split())
if a==b:
  print('Draw')
elif a==1 or b!=1 and 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())
print('Draw' if a==b else 'Alice' if (a+13)%15>(a+13)%15 else 'Bob')

a,b = map(int, input().split())
print('Draw' if a==b else 'Alice' if (a+12)%14>(a+12)%14 else 'Bob')

a,b = map(int, input().split())
print('Draw' if a==b else 'Alice' if (a+13)%15>(b+13)%15 else 'Bob')

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):
#!/usr/bin/env python3

Alice, Bob = map(int, input())
if Alice == 1:
    Alice = 14
if Bob == 1:
    Bob = 14

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

#!/usr/bin/env python3

Alice, Bob = map(int, input().split())
if Alice == 1:
    Alice = 14
if Bob == 1:
    Bob = 14

if Alice > Bob:
    print('Alice')
elif Bob > Alice:
    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("Draw")
elif A>B or A==1:
    print("Alice")
elif　A<B or B==1:
    print("Bob")

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

if A==B:
    print("Draw")
elif A>B or A==1:
    print("Alice")
elif:　A<B or B==1:
    print("Bob")

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

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

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:
  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")

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):
""" AtCoder """

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")


""" AtCoder """

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):
, b = map(int, 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 = map(int, 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

Accepted