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):
from itertools import permutations
n, m = map(int, input().split())
ab = [[] for i in range(n)]
for i in range(m):
    a, b = map(lambda x: int(x) - 1, input().split())
    ab[a].append(b)
    ab[b].append(a)
cnt = 0
if n == 2:
    if 1 in ab[0]:
        print(1)
    else:
        print(0)
    exit()
for p in permutations(range(1, n)):
    if p[0] in ab[0]:
        flag = True
        for i in range(n - 2):
            if p[i + 1] not in ab[p[i]]:
                flag = False
                break
        if flag:
            cnt += 1
print(cnt)

a, b = map(int, input().split())
if a == b:
    print('Draw')
elif (a > b and not b == 1) or 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):
# import math
# import statistics
#a=input()
#b,c=int(input()),int(input())
# c=[]

#    c.append(i)
e1,e2 = map(int,input().split())
#K = input()
# f = list(map(int,input().split()))
#g = [input() for _ in range(a)]
a=[2,3,4,5,6,7,8,9,10,11,12,13,1]
if e1==e2:
	print('Draw')
elif a.index(e1)<a.index(e2):
	print('Alice')
else:
	print('Bob')

# import math
# import statistics
#a=input()
#b,c=int(input()),int(input())
# c=[]

#    c.append(i)
e1,e2 = map(int,input().split())
#K = input()
# f = list(map(int,input().split()))
#g = [input() for _ in range(a)]
a=[2,3,4,5,6,7,8,9,10,11,12,13,1]
if e1==e2:
	print('Draw')
elif a.index(e1)>a.index(e2):
	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):
lst = map(int,input().split())

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



lst = [14 if x == 1 else x for x in map(int,input().split())]
if lst[1] != 1 and lst[0] > lst[1] :
    print('Alice')
elif lst[0] != 1 and lst[0] < lst[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 = list(map(int, input().split()))
cards = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1]
if cards.index(A) > cards.index(B) :
  print("Alice")
if cards.index(B) > cards.index(A) :
  print("Bob")
else :
  print("Draw")

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


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

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


a,b=map(int,input().split())
if a==1:
    a=100
if b==1:
    b=100
if a>b:
    print('Alice')
elif a==b:
    print('Draw')
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):
# ACB054C
n, m = map(int, input().split())
L = [[] for i in range(n)]

for i in range(m):
    a, b = map(int, input().split())
    L[a-1].append(b-1)
    L[b-1].append(a-1)

ans = 0
def f(t, history):
    history[t] += 1
    his = history[:]
    global ans
    if sum(his) == n:
        ans += 1
    else:
        
        for i in L[t]:
            if his[i] == 0:
                f(i, his)
            
f(0, [0]*n)
print(ans)


# ACB054A
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=1 and B!=1):
    print("Alice")
    
   




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


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

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




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


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

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




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


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

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




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


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


a, b = list(map(int, input().split()))
if a == 1:
  a = 14
else:
  a = a
if b == 1:
  b = 14
else:
  b = b
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):
x = input()
# x = x.replace(1,14)

ls_x = x.split()



for i in range(len(ls_x)):
    ls_x[i] = int(ls_x[i])

print(ls_x)

if ls_x[0] == ls_x[1]:
    print("Draw")

if ls_x[0] == 1:
    print("Alice")

elif ls_x[1] == 1:
    print("Bob")

elif ls_x[0] > ls_x[1]:
    print("Alice")

elif ls_x[0] < ls_x[1]:
    print("Bob")

x = input()
# x = x.replace(1,14)

ls_x = x.split()



for i in range(len(ls_x)):
    ls_x[i] = int(ls_x[i])

if ls_x[0] == ls_x[1]:
    print("Draw")

elif ls_x[0] == 1:
    print("Alice")

elif ls_x[1] == 1:
    print("Bob")

elif ls_x[0] > ls_x[1]:
    print("Alice")

elif ls_x[0] < ls_x[1]:
    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 > B :
   print( "Alice" )
elseif A < B :
   print( "Bob" )
else : 
   print( "Draw" )

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

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:
  print('Alice')
elif b==1 or :
  print('Bob')
elif a>b:
  print('Alice')
else:
  print('Bob')

a,b = map(int,input().split())
card = [2,3,4,5,6,7,8,9,10,11,12,13,1]
if card.index(a)==card.index(b):
  print('Draw')
elif card.index(a)>card.index(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):
N, M = map(int, input().split())
ab = [[] for _ in range(N)]

for _ in range(M):
    a, b = map(int,input().split())
    ab[a-1].append(b-1)
    ab[b-1].append(a-1)

count = 0

def dfs(i, now, done):
    global count
    if i == N-1:
        count += 1
        return

    for j in ab[now]:
        if j not in done:
            dfs(i+1, j, done + [j])
    return

dfs(0, 0, [0])
print(count)


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):
import sys
A,B = map(int,input.split())
if A < 0 or A > 13 or B < 0 or B > 13:
    sys.exit()

if A == 1 or B == 1:
    if A == B:
        print("Draw")
    elif A == 1:
        print("Alice")
    elif B == 1:
        print("Bob")
    sys.exit()

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

import sys
A,B = map(int,input().split())
if A < 0 or A > 13 or B < 0 or B > 13:
    sys.exit()

if A == 1 or B == 1:
    if A == B:
        print("Draw")
    elif A == 1:
        print("Alice")
    elif B == 1:
        print("Bob")
    sys.exit()

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

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

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

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

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

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):
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):
    ans = True
    for j in range(n-m+1):
        for k in range(m):
            if a[i + k][j:j+m] != b[k]:
                ans = False
        if ans == True:
            break
    else:
        continue
    break

if ans == True:
    print("Yes")
else:
    print("No")


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

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):
a,b =map(int,input().split())
A,B,C ="Alice","Bob",Draw"
if max(a,b) =="13" and min(a,b) =="1":
  print(A) if a < b else print(B)
else:
  print(A) if a > b print(B) if a < b else print(C)
  

a,b =map(int,input().split())
A,B,C =("Alice","Bob","Draw")
if max(a,b) ==13 and min(a,b) ==1:
  print(A) if a < b else print(B)
else:
  if a > b:
    print(A)  
  elif a < b:
    print(B)  
  else:
    print(C)

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,b=(a+11)%13,(b+11)%13
if a>b:print("Alice");else:print("Bob")

:cross: 

a,b=map(int,input().split())
a=(a+11)%13
b=(b+11)%13
if a==b:print("Draw")
elif 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())

def convert_num(a):
    if a == 1:
        a = 14
    return a

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

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

def convert_num(a):
    if a == 1:
        a = 14
    return a

a = convert_num(a)
b = convert_num(b)
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:
  ans = 'Draw'
elif a == 1:
  ans = 'Alice'
elif b == 1:
  ans = 'Bob'
elif a > b:
  ans = 'Alice'
else:
  ans = 'Bob'
print(ans)

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


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

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

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

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

Verdicts: 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):
a,b=[int(i) for i in input().split()]
list=["2","3","4","5","6","7","8","9","10","11","12","13","1"]
A=list.index(a)
B=list.index(b)
if A>B:
  print('Alice')
elif A==B:
  print('Draw')
else:
  print('Bob'

a,b=[str(i) for i in input().split()]
list=["2","3","4","5","6","7","8","9","10","11","12","13","1"]
A=list.index(a)
B=list.index(b)
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 or a = 1:
  print("Alice")
elif b > a or b = 1:
  print("Bob")

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

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

a,b=map(int,input().split())
if a>1:
    a=a
else:
    a=14
if b>1:
    b=b
else:
    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):
!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
 import sys
 
 for line in sys.stdin:
     card = line.split(" ")
 
     if card[0] > card[1]:
        print("Alice")
    elif card[0] < card[1]:
        print("Bob")
    else:
        print("Draw")

import sys

count = 0
N_list = []
M_list = []
for line in sys.stdin:
    line = line.rstrip("\n")
    if count == 0:
        line = line.split(" ")
        N = int(line[0])
        M = int(line[1])
    elif count <= N:
        N_list.append(line)
    else:
        M_list.append(line)
    count+=1
    
    
def judge_match(N_l, M_l):
    slide_count = len(N_l[0]) - len(M_l[0]) + 1
    count = 0
    for j in range(slide_count):
        count = 0
        for i in range(len(N_l)):
            if N_l[i][j:len(M_l[0])] == M_l[i]:
                count += 1
                if count == len(M_l):
                    return count
    return count

m_count = 0
for i in range(len(N_list)):
    m_count = judge_match(N_list[i:i+len(M_list)], M_list)
    if m_count == len(M_list):
        print("Yes")
        exit(0)
print("No")

for line in sys.stdin:
    card = line.split(" ")
    alice = int(card[0])
    bob = int(card[1])
    if alice == 1:
        alice += 13
    if bob == 1:
        bob += 13
        
    if alice > bob:
        print("Alice")
    elif alice < bob:
        print("Bob")
    else:
        print("Draw")

import sys
 
for line in sys.stdin:
    card = line.split(" ")
    alice = int(card[0])
    bob = int(card[1])
    if alice == 1:
        alice += 13
    if bob == 1:
        bob += 13
        
    if alice > bob:
        print("Alice")
    elif alice < bob:
        print("Bob")
    else:
        print("Draw")

Verdicts: Runtime Error

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())
print('Draw' if a==b else 'Alice' if (a+13)%15<(b+13)%15 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

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')
    else:
        if A > B:
        print('Alice')
        else:
        print('Bob')


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



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

if (a > b and b != 1) or (a==1 and b!=1):
    print('Alice')
elif (b > a and a!=1) or (a!=1 and b==1):
    print('Bob')
else:
    print('Draw')



Verdicts: Runtime Error

Accepted