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

if A>B:
    print("Alicd")
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("Alicd")
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: Wrong Answer

Wrong Answer

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

Submission attempts (in order):
A = int(input())
B = int(input())

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

if A == B:
  print("Draw")
elif A > B:
  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("Draw")
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 itertools
import numpy as np
N,Ma,Mb=map(int,input().split())
yaku=[]
for _ in range(N):
    yaku.append(list(map(int,input().split())))


candi_money=[]

for n in range(N):
    candis=list(itertools.combinations(np.arange(N),n))
    for candi in candis:
        a,b,c=0,0,0
        for num in candi:
            a +=yaku[num][0]
            b +=yaku[num][1]
            c +=yaku[num][2]
        if a/flaot(Ma/Mb)=b:
            candi_money.append(c)


if len(candi_money)==0:
	print(-1)
else:
	print(min(candi_money))

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

Verdicts: Runtime Error

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

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

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

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


a = int(input())
b = int(input())

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


Verdicts: Runtime Error

Runtime Error

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

Submission attempts (in order):
n = list(map(int, input().split))

a = n[0]
b = n[1]

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

n = list(map(int, input().split()))

a = n[0]
b = n[1]

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

Verdicts: Runtime Error

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

Submission attempts (in order):
A, B = map(int, input().split())
if A == B:
  print("Draw")
elif 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")
elif A == 1:
  print("Alice")
elif B == 1:
  print("Bob")
else:
  if B < A:
    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):
from itertools import combinations
N, Ma, Mb = list(map(int, input().split()))
abc = [list(map(int, input().split())) for _ in range(N)]
min_cost = -1
for _i in range(1, N+1):
    all_pattern = list(combinations(range(N), _i))
    for _j in all_pattern:
        _a = sum([abc[_k][0] for _k in _j])
        _b = sum([abc[_k][1] for _k in _j])
        _c = sum([abc[_k][2] for _k in _j])
        if _b * Ma == _a * Mb:
            if min_cost == -1 or min_cost > _c:
                min_cost = _c
print(min_cost)

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

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

Verdicts: Runtime Error

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

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

def main():
    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")


if __name__ == '__main__':
    main()


Verdicts: Runtime Error

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

Submission attempts (in order):
cards = input()
cards_s = cards.split()

porker_list = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1]

alice_str = cards_s[0]
alice_s = porker_list.index(alice_str)
alice = int(alice_s)

bob_str = cards_s[1]
bob_s = porker_list.index(bob_str)
bob = int(bob_s)

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


cards = input()
cards_s = cards.split()

porker_list = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1]

alice_str = cards_s[0]
alice_int = int(alice_str)
alice = porker_list.index(alice_int)

bob_str = cards_s[1]
bob_int = int(bob_str)
bob = porker_list.index(bob_int)

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

cards = input()
cards_s = cards.split()

porker_list = ['2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '1']

alice_str = cards_s[0]
alice_s = porker_list.index(alice_str)
alice = int(alice_s)

bob_str = cards_s[1]
bob_s = porker_list.index(bob_str)
bob = int(bob_s)

if alice > bob:
    print('Alice')
elif alice == bob:
    print('Draw')
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):
tmp = input().split(" ")
a = (int(tmp[0]) - 2) % 13
b = (int(tmp[1]) - 2) % 13
print("Alice") if a > b else print("Draw") if a = b else print("Bob")

tmp = input().split(" ")
a = (int(tmp[0]) - 2) % 13
b = (int(tmp[1]) - 2) % 13
print("Alice") if a > b else print("Draw") if a == b 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('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):
A,B=map(int,input().split())
if A==1 or B==1:
  if A==B:
    print('Draw')
  elif A=1:
    print('Alice')
  else:
    print('Bob')
elif A>B:
  print('Alice')
elif A<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')


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 = list(map(int, input().split()))
if x[0]==1 and x[1]!=1:
    x[0]=14
elif x[1]==1 and x[1]!=1:
    x[1]=14
elif x==[1,1]:
    x = [14,14]
print(x)
print("Alice" if x[0]>x[1] else "Bob" if x[0]<x[1] else "Draw")

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

a, b = map(int, input().split())
l = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1]
if l.index(a) > l.index(b):
  print("Alice")
elif l.index(a) < l.index(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):
import sys

input_num = input().split()
N = int(input_num[0])
M = int(input_num[1])

A = [input() for i in range(0, N-1)]
B = [input() for n in range(0, M-1)]

if M > N:
    print("No")
elif M == N:
    for a, b in zip(A, B):
        if b not in a:
            print("No")
    else:
        print("Yes")
else:
    diff = N - M
    breaked = False
    for i in range(0, len(A)-1):
        l = i
        while l <= i + diff and l < len(B):
            if A[i] == B[l]:
                breaked = True
                break
            else:
                if breaked:
                    print("No")
                    sys.exit()
                l += 1
    if breaked:
        print("Yes")
    else:
        print("No")

N = input().split()
A = int(N[0])
B = int(N[1])

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

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

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

if a == 1: 
    a += 13
if b == 1: 
    b += 13

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

Verdicts: 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):
Alice,Bob = map(int,input().split())

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

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

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

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

ar = int(n[0])
br = int(n[1])

a = []
b = []
for i in range(0, ar):
    a.append(input())

for j in range(0, br):
    b.append(input())

find = False
for i in range(0, ar - br):
    idx = a[i].find(b[0])
    if idx != -1:
        match = True
        for j in range(1, br):
            idx2 = a[i + j].find(b[j])
            if idx != idx2:
                match = False
        if match:
            find = True
            break
if find:
    print("Yes")
else:
    print("No")

c = input().split()
a = int(c[0])
b = int(c[1])
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

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

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

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

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

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

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

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

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

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

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

if A == B:
    print('Draw')
elif A > B:
    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('Draw')
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):
N,M = map(int,input().split())
a = []
c = []
for i in range(N):
    b = list(input())
    a+=b
for i in range(M):
  b = list(input())
  c+=b
#print(c,a)
f = False
for i in range(N*N):
  if f == True:
    break
  if N*N-i<M*M:
    break
  count=0
  flag = True
  #print(i,c[0],a[i])
  if c[0] == a[i]:
    if N-(i%N)<M:
      continue
    num = i
    for j in range(M):
      for k in range(M):
        #print(c[count],a[num])
        if c[count] == a[num]:
          
          num+=1
          count+=1
        elif c[count]!=a[num]:
          flag =False
          break
      num+=N-M
      if flag == False:
        #print(i)
        break  
      if j == M-1:
        f = True
            
  else:
    continue
if f == False:
  print('No')
else:
  print('Yes')
           
    
    

M,N = map(int,input().split())

if M == N:
  print('Draw')
elif (M>N and N!=1) or M==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())
if a==1 and b==1:
    print('Draw')
elif a==1 or b==1:
    print('Alice' if a == 1 else 'Bob')
else :
    print('Alce' if a>b else 'Bob' if a<b else 'Draw')

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

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


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

Verdicts: Runtime Error

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

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

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

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

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:


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):
from sys import stdin, setrecursionlimit
setrecursionlimit(5000)
def readLine_int_list():return list(map(int, stdin.readline().split()))
def readAll_int(): return list(list(map(int,i.split())) for i in stdin.read().split("\n"))
 
 
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

def ratio(a,b):
    return (a//gcd(a,b), b//gcd(a,b))
 
def add_ratio(a,b):
    if a != 0:
        sum_a = sum(a)
        sum_b = sum(b)
        _a = a[0]*sum_b + b[0]*sum_a
        _b = b[1]*sum_a + a[1]*sum_b
        return ratio(_a, _b)
    else:
        return(b)
 
def dfs(i, v, r,ans):
    if i == n:
        if r == (Ma,Mb):
            ans.append(v)
        return 0

    if dfs(i+1, v, r,ans):
        return 0
    
    if dfs(i+1, v+D[i][2], add_ratio(r,ratio(D[i][0],D[i][1])), ans):
        return 0
 
    return 0
ans = []
n, Ma, Mb = readLine_int_list()
D = readAll_int()
e=0
for i in D:
    e += i[2]

def main():
    dfs(0,0,0,ans)
    if ans:
        print(min(ans))
    else:
        print(-1)
 
if __name__ == "__main__":
    main()

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


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


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):
import sys
 
N,M=map(int,input().split())
A=[sys.stdin.readline().strip() for _ in range(N)]
B=[sys.stdin.readline().strip() for _ in range(M)]
 
for i in range(N-M+1):
  for j in range(N-M+1):
    As=[x[j:j+M] for x in A[j:j+M]]
    if B==As:
      print('Yes')
      sys.exit()
print('No')

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

func=lambda x:(x,x+13)[x==1]

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

A, B=map(int,input().split())
 
func=lambda x:[x,x+13][x==1]
 
if func(A)==func(B):
  print('Draw')
elif func(A)<func(B):
  print('Bob')
else:
  print('Alice')

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

A = []
for _ in range(N):
  a = input()
  A.append(a)

B = []
for _ in range(M):
  b = input()
  B.append(b)

existed = False
for i in range(N - M + 1):
  for j in range(N - M + 1):
    match = True
    for mi in range(M):
      for mj in range(M):
        x = i + mi
        y = j + mj

        if (A[y][x] != B[mj][mi]):
          match = False
          break
      
      if (match == False):
        break

    if (match):
      existed = True
      break
  
  if (existed):
    break

result = 'Yes' if (existed) else 'No'
print(result)


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

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

print(result)


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().split)

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

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

if a==1:
    a=14

if b==1:
    b=14

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


Verdicts: Runtime Error

Accepted