TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
a, b, c, d = map(int, input().split())
if a // d + 1 > (c // b):
    print("Yes")
else:
    print("No")

a, b, c, d = map(int, input().split())
m = c // b
if c%b == 0:
    m += 0
else:
    m += 1
n = a // d
if a%d == 0:
    n += 0
else:
    n += 1
if m <= n:
    print('Yes')
else:
    print('No')


Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):





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

while a > 0 and c > 0:
    c -= b
    if c <= 0:
        print("Yes")

    a -= d
    if d <= 0:
        print("No")






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

while a > 0 and c > 0:
    c -= b
    if c <= 0:
        print("Yes")
        break

    a -= d
    if d <= 0:
        print("No")
        break
        






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

while a > 0 and c > 0:
    c -= b
    if c <= 0:
        print("Yes")
        break

    a -= d
    if a <= 0:
        print("No")
        break

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
Taka_T,Taka_A,Aoki_T,Aoki_A= map(int, input("高橋体力_高橋攻撃_青木体力_青木攻撃 > ").split())

while True:
    Aoki_T = Aoki_T - Taka_A
    Taka_T = Taka_T - Aoki_A
    if Aoki_T <= 0:
        print("Yes")
        break
    elif Taka_T <= 0:
        print("No")
        break


Taka_T,Taka_A,Aoki_T,Aoki_A= map(int, input().split())

while True:
    Aoki_T = Aoki_T - Taka_A
    Taka_T = Taka_T - Aoki_A
    if Aoki_T <= 0:
        print("Yes")
        break
    elif Taka_T <= 0:
        print("No")
        break


Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

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

while a < 0 or c < 0:
  if a > 0:
    a = a - d
  if c > 0:
    c = c - b
if c < 0:
  print("Yes")
elif a < 0:
  print("No")

a, b, c, d = map(int,input().split())
 
while a > 0 and c > 0:
  if c > 0:
    c = c - b
    if 0 >= c:
      print("Yes")
      exit()
    if a > 0:
      a = a - d
      if 0>= a:
        print("No")   

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
a, b, c, d = [int(i) for i in input().split()]
if (a//d)>=(c//b):
    print('Yes')
else:
    print('No')

a, b, c, d = [int(i) for i in input().split()]
import math
if math.ceil(c/b) <= math.ceil(a/d):
    print('Yes')
else:
    print('No')

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
A,B,C,D = map(int,input().split())
while True:
    A = A - D
    C = C - B
    if C-B <= 0:
        print('Yes')
        break
    
    if A-D <= 0:
        print('No')
        
    

A,B,C,D = map(int,input().split())
while True:
    A = A - D
    C = C - B
    if C <= 0:
        print('Yes')
        break
    
    if A <= 0:
        print('No')
        
    


A,B,C,D = map(int,input().split())
while True:
    A = A - D
    C = C - B
    if C <= 0:
        print('Yes')
        break
    
    if A <= 0:
        print('No')
        break
    


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
import math
A,B,C,D=map(int,input().split())
A/=D
B/=C
E=math.ceil(A)
F=math.ceil(B)
if A>=B:
    print("Yes")
else:
    print("No")


import math
A,B,C,D=map(int,input().split())
E=math.ceil(A/D)
F=math.ceil(B/C)
if A>=B:
    print("Yes")
else:
    print("No")


import math
A,B,C,D=map(int,input().split())
E=math.ceil(A/D)
F=math.ceil(C/B)
if A>=B:
    print("Yes")
else:
    print("No")


import math
A,B,C,D=map(int,input().split())
E=math.ceil(A/D)
F=math.ceil(C/B)
if E>=F:
    print("Yes")
else:
    print("No")


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
A,B,C,D = map(int,input().split())
aok_attack = -(-A//D) 
tkhs_attack = -(-C//B)
print(tkhs_attack)
print(aok_attack)
if tkhs_attack > aok_attack:
    print('No')
else:
    print('Yes')

A,B,C,D = map(int,input().split())
aok_attack = -(-A//D) 
tkhs_attack = -(-C//B)
#print(tkhs_attack)

if tkhs_attack > aok_attack:
    print('No')
else:
    print('Yes')

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
while C > 0 and A > 0:
    C -= B
    A -= D
    if C <= 0:
        print("Yes")
    elif A <= 0:
        print("No")
    else:
        pass

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

while C > 0 and A > 0:
    C -= B
    A -= D
    if C <= 0:
        print("Yes")
    elif A <= 0:
        print("No")
    else:
        pass

Verdicts: Runtime Error

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
ad,ao,bd,bo=map(int,input().split())
aTurn=int(float(ad)/bo)*2+1
bTurn=int(float(bd)/ao)*2
if aTurn>bTurn:
  print("Yes")
else:
  print("No")

ad,ao,bd,bo=map(float,input().split())
aTurn=int(ad/bo)+0.5
bTurn=int(bd/ao)
if ad%bo==0:
  aTurn -= 1
if bd%ao==0:
  bTurn -= 1
  
if aTurn>bTurn:
  print("Yes")
else:
  print("No")

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
import sys

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

while True:
    d = d - a
    if d <= 0:
        print("Yes")
        sys.exit()
    else:
        b = b - c
    if b <= 0:
        print("No")
        sys.exit()

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

while b<=0 or d<=0:
    d = d - a
    if d <= 0:
        print("Yes")
    else:
        b = b - c
    if b <= 0:
        print("No")

import sys

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

while True:
    c = c - b
    if c <= 0:
        print("Yes")
        sys.exit()
    else:
        a = a - d
    if a <= 0:
        print("No")
        sys.exit()

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

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

n = A // D
m = C // A
if n >= m:
    print("Yes")
else:
    print("No")

import math
A, B, C, D = list(map(int, input().split()))



n = math.ceil(A / D)
m = math.ceil(C / A)
if n >= m:
    print("Yes")
else:
    print("No")

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

n = A / D
m = C / A
if n >= m:
    print("Yes")
else:
    print("No")

import math
A, B, C, D = list(map(int, input().split()))



n = math.ceil(A / D)
m = math.ceil(C / B)
if n >= m:
    print("Yes")
else:
    print("No")

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

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

t_hp = a
a_hp = c
while a_hp >= 0 or t_hp >= 0:
a_hp -= b
t_hp -= d

if a_hp <= t_hp:
  print("Yes")
else:
  print("No")


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

t_hp = a
a_hp = c
while a_hp > 0 or t_hp > 0:
	a_hp -= b
	t_hp -= d
	if a_hp <= 0:
      print("Yes")
      exit()
    elif t_hp <= 0:
      print("No")
      exit()

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

t_hp = a
a_hp = c
while a_hp > 0 or t_hp > 0:
	a_hp -= b
	t_hp -= d
    if a_hp <= 0:
         print("Yes")
         exit()
    elif t_hp <= 0:
         print("No")
         exit()

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

t_hp = a
a_hp = c
while a_hp > 0 or t_hp > 0:
	a_hp -= b
	t_hp -= d

if a_hp <= 0:
	print("Yes")
else:
	print("No")

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

t_hp = a
a_hp = c
while a_hp > 0 or t_hp > 0:
    a_hp -= b
    t_hp -= d
    if a_hp <= 0:
         print("Yes")
         exit()
    elif t_hp <= 0:
         print("No")
         exit()

Verdicts: Runtime Error

Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
import math
A, B, C, D = input().split()
 
if math.ceil(int(C)*1.0/(int(B)*1.0)) >= math.ceil(int(A)*1.0/(int(D)*1.0)):
  print("Yes")
else:
  print("No")

import math
A, B, C, D = input().split()
 
if math.ceil(int(C)*1.0/(int(B)*1.0)) <= math.ceil(int(A)*1.0/(int(D)*1.0)):
  print("Yes")
else:
  print("No")

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
ta_AT,ta_HP,ao_AT,ao_HP = map(int,input().split())

while True:
    ao_HP -= ta_AT
    if ao_HP <= 0:
        print('Yes')
        break
    ta_HP -= ao_AT
    if ta_HP <= 0:
        print('No')
        break

ta_HP,ta_AT,ao_HP,ao_AT = map(int,input().split())

while True:
    ao_HP -= ta_AT
    if ao_HP <= 0:
        print('Yes')
        break
    ta_HP -= ao_AT
    if ta_HP <= 0:
        print('No')
        break

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
import math
a,b,c,d = map(int,input().split())
tcnt = math.ceil(c/b)
acnt = math.ceil(a/d)
if(tcnt > acnt):
    print("Yes")
else:
    print("No")


import math
a,b,c,d = map(int,input().split())
tcnt = math.ceil(c/b)
acnt = math.ceil(a/d)
if(tcnt > acnt):
    print("Yes")
else:
    print("No")


import sys
 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
a, b, c, d = map(int, read().split())
 
def main(a, b, c, d):
    while True:
        if c <= b:
            return 'Yes'
        c -= b
        if a <= d:
            return 'No'
        a -= d
 
print(main(a, b, c, d))


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
a,b,c,d=46,4,40,5
if int(a/d)<int(c/b):
    print('Yes')
elif int(a/d)==int(c/b):
    if a%d==0 and c%b==0:
        print('Yes')
    elif a%d>0:
        print('Yes')
    else:
        print('No')
else:
    print('No')

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

while True:
    c=c-b
    if c<=0:
        print('Yes')
        break
    a=a-d
    if a<=0:
        print('No')
        break

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
import math
A, B, C, D = map(int,input().split())
hpa = math.ceil(A / D)
hhb = math.ceil(C / B)
if (hpa >= hpb):
    print('Yes')
else:
    print('No')


A, B, C, D = map(int,input().split())
hpa = A
hhb = C
while(1):
    hpb -= B
    if(hpb <= 0):
        print('Yes')
        break
    hpa -= D
    if(hpa <= 0):
        print('No')
        break  


import math
A, B, C, D = map(int,input().split())
hpa = math.ceil(A / D)
hpb = math.ceil(C / B)
if (hpa >= hpb):
    print('Yes')
else:
    print('No')


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
from math import ceil
A, B, C, D = map(int, input().split())
Takahashi = ceil(A/D)
Aoki = ceil(C/D)
if Takahashi >= Aoki:
  print("Yes")
else:
  print("No")

from math import ceil
A, B, C, D = map(int, input().split())
Takahashi = ceil(A/D)
Aoki = ceil(C/B)
if Takahashi >= Aoki:
  print("Yes")
else:
  print("No")

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
# coding: utf-8
# Your code here!
import sys
readline = sys.stdin.readline
read = sys.stdin.read

a,b,c,d = [int(i) for i in input().split()]


t = c//b
s = a//d
if t <= s:
    print("Yes")
else:
    print("No")
    

# coding: utf-8
# Your code here!
import sys
readline = sys.stdin.readline
read = sys.stdin.read

a,b,c,d = [int(i) for i in read().split()]

while True:
    c -= b
    if c <= 0:
        print("Yes")
        break
    a -= d
    if a <= 0:
        print("No")
        break

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
A, B, C, D = map(int, input().split())
if C//B >= A//D:
  print('Yes')
else:
  print('No')

import math
A, B, C, D = map(int, input().split())
if math.ceil(C/B) <= math.ceil(A/D):
  print('Yes')
else:
  print('No')

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

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

    while A>0 and B>0 :
        C -= B  # Aoki health
        A -= D  
        print(C, A)

    if C > A:
        print('No')
    else:
        print('Yes')


if __name__ == '__main__':
    main()

def main():
    A, B, C, D = map(int, input().split())

    while A>0 and B<0 :
        C -= B  # Aoki health
        A -= D  

    if C > A:
        print('No')
    else:
        print('Yes')


if __name__ == '__main__':
    main()

def main():
    A, B, C, D = map(int, input().split())

    while True:
        Aoki_health = C-B
        Take_health = A-D
        if Take_health < 1 < Aoki_health:
            print('No')
            break
        else:
            print('Yes')
            break


if __name__ == '__main__':
    main()

import math


def main():
    A, B, C, D = map(int, input().split())

    Takeshi = math.ceil(C/B)
    Aoki = math.ceil(A/D)

    print('Yes' if Takeshi<= Aoki else 'No')


if __name__ == '__main__':
    main()

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
def checkWin(T_hp, A_hp):
    if (T_hp <= 0):
        print('No')
    if (A_hp <= 0):
        print('Yes')

T_hp, T_at, A_hp, A_at = list(map(int, input().split()))

while (T_hp > 0 and A_hp > 0):
    A_hp = A_hp - T_at
    checkWin(T_hp, A_hp)
    T_hp = T_hp - A_at
    checkWin(T_at, A_at)

    

def checkWin(T_hp, A_hp):
    if (T_hp <= 0):
        print('No')
    if (A_hp <= 0):
        print('Yes')

T_hp, T_at, A_hp, A_at = list(map(int, input().split()))

while (T_hp > 0 and A_hp > 0):
    A_hp = A_hp - T_at
    T_hp = T_hp - A_at

    if (A_hp <= 0):
        print('Yes')
        break

    if (T_hp <= 0):
        print('No')
        break



    

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
heart_taka, power_taka, heart_aoki, power_aoki = map(int, input().split())

aliveTaka = True
aliveAoki = True
while (aliveTaka) or (aliveAoki):
    heart_aoki -= power_taka
    heart_taka -= power_aoki
    if heart_aoki <= 0:
        aliveAoki = False
    if heart_taka <= 0:
        aliveTaka = False

if aliveAoki == False:
    return "Yes"
return "No"

heart_taka, power_taka, heart_aoki, power_aoki = map(int, input().split())

aliveTaka = True
aliveAoki = True
while (aliveTaka) and (aliveAoki):
    heart_aoki -= power_taka
    heart_taka -= power_aoki
    if heart_aoki <= 0:
        aliveAoki = False
    if heart_taka <= 0:
        aliveTaka = False

if aliveAoki == False:
    print("Yes")
else:
    print("No")


Verdicts: Runtime Error

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
a,b,c,d = [int(i) for i in input().split(" ")]
attack_round_a = c // b if c % b != 0 else c // b + 1
attack_round_b = a // d if a % d != 0 else a // d + 1
print('Yes' if attack_round_a <= b else 'No')


a,b,c,d = [int(i) for i in input().split(" ")]
attack_round_a = c // b if c % b == 0 else c // b + 1
attack_round_b = a // d if a % d == 0 else a // d + 1
print('Yes' if attack_round_a <= attack_round_b else 'No')

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):

a,b,c,d = map(int, input().split())
cnta = 0
cntc = 0
while a <= 0:
    a -= d
    cnta += 1

while c <= 0:
    c -= b
    cntc += 1
    
if cnta >= cntc:
    print("Yes")
else:
    print("No")
    


a,b,c,d = map(int, input().split())
cnta = 0
cntc = 0
while a > 0:
    a -= d
    cnta += 1

while c > 0:
    c -= b
    cntc += 1

# print(cnta, cntc)

if cnta >= cntc:
    print("Yes")
else:
    print("No")
    

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
import math 
A,B,C,D=map(int,input().split())
print("Yes" if math.ceil(A/D) >= math.ceil(B/C) else "No")

import math 
A,B,C,D=map(int,input().split())
print("Yes" if math.ceil(A/D) >= math.ceil(C/B) else "No")

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
import math
a,b,c,d = map(int,input().split())
if math.floor(c/b)>=math.floor(a/d):
    print("Yes")
else:
    print("No")

print("Yes")

import math
a,b,c,d = map(int,input().split())

def death_time(hp,atack):
    if hp%atack == 0:
        return hp/atack
    else:
        return hp//atack + 1

takahashi_death = death_time(a,d)
aoki_death = death_time(c,b)

if aoki_death<=takahashi_death:
    print("Yes")
else:
    print("No")

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

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

i = int(C / B) + 1 
j = int(A / D) + 1 

if i <= j:
  print("Yes")
else:
  print("No")

import math

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

i = math.ceil(C / B) 
j = math.ceil(A / D) 

if i <= j:
  print("Yes")
else:
  print("No")

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

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

x = a//d
y = c//b

if x >= y:
  print("Yes")
else:
  print("No")

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

while a<=0 or b <= 0:
  a = a - d
  b = b - c

if a <= 0:
  print("No")
else:
  print("Yes")

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

while a<=0 or c <= 0:
  a = a - d
  c = c - b

if a <= 0:
  print("No")
else:
  print("Yes")

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

while a<=0 or b <= 0:
  a = a - d
  c = c - b

if a <= 0:
  print("No")
else:
  print("Yes")

a, b, c, d = map(int, input().split())
 
x = a / d
y = c / b
 
if x > y-1:
  print("Yes")
else:
  print("No")

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

while True:
    c -= b
    a -= d
    if c <= 0:
        print("Yes")
        break
    elif a <= 0:
        print("No")
        break

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
B = input().split()

while True:
    B[2] = int(B[2]) - int(B[1])
    B[0] = int(B[0]) - int(B[3])
    print(B[2])
    print(B[0])
    if int(B[2]) <= 0:
        print("Yes")
        break
    elif int(B[0]) <= 0:
        print("No")
        break

B = input().split()

while True:
    B[2] = int(B[2]) - int(B[1])
    B[0] = int(B[0]) - int(B[3])
    if int(B[2]) <= 0:
        print("Yes")
        break
    elif int(B[0]) <= 0:
        print("No")
        break

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
def func(a,b,c,d):
    while True:
        c-=b
        if c<0:
            return "Yes"
        a-=d
        if a<0:
            return "No"
print(func(*list(map(int,input().split()))))

def func(a,b,c,d):
    while True:
        c-=b
        if c<=0:
            return "Yes"
        a-=d
        if a<=0:
            return "No"
print(func(*list(map(int,input().split()))))


Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
A = int(input())
B = int(input())
C = int(input())
D = int(input())
while True:
	C = C - B
	if C <= 0 : 
		print("Yse")
		break
	A = A - D
	if A <= 0 : 
		print("No")
		break

A,B,C,D=map(int,input().split())
 
while True:
    C=C-B
    if C<=0:
        break
    A=A-D
    if A<=0:
        break
 
if C<=0:
    print('Yes')
else:
    print('No')

Verdicts: Runtime Error

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
a, b, c, d = map(int, input().split())
takahashi = [a, b] if a>b else [b, a]
aoki = [c, d] if c>d else [d, c]
attackers = [takahashi, aoki]
attacker = 0

while 0 not in takahashi and 0 not in aoki:
  attackers[attacker^1][1] = max(0, attackers[attacker^1][1]-attackers[attacker][0])
  attackers[attacker^1].sort(reversed=True)
  attacker = attacker^1

if 0 in attackers[0]:
  print('No')
else:
  print('Yes')

a, b, c, d = map(int, input().split())
takahashi = [a, b]
aoki = [c, d]
attackers = [takahashi, aoki]
attacker = 0

while attackers[0][0]!=0 and attackers[1][0]!=0:
  attackers[attacker^1][0] = max(0, attackers[attacker^1][0]-attackers[attacker][1])
  attacker = attacker^1

if attackers[0][0]==0:
  print('No')
else:
  print('Yes')

Verdicts: Runtime Error

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
th,ts,ah,ae=map(int,input().split())
while(th>0 && ah>0):
  ah=ah-ts
  if(ah<=0):
    break
  else:
    th=th-ae
if(th>0):
  print("Yes")
else:
  print("No")

th,ts,ah,ae=map(int,input().split())
while(th>0 and ah>0):
  ah=ah-ts
  if(ah<=0):
    break
  else:
    th=th-ae
if(th>0):
  print("Yes")
else:
  print("No")

Verdicts: Runtime Error

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

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

if math.ceil(C/B) >= math.ceil(D/A):
    print('Yes')
else:
    print('No')

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

if C//B >= D//B:
    print('Yes')
else:
    print('No')

import math
A,B,C,D = map(int,input().split())

if math.ceil(A/D) >= math.ceil(C/B):
    print('Yes')
else:
    print('No')

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
t_hp,t_at,a_hp,a_at=input().split()
while(int(t_hp) > 0 and int(a_hp) > 0):
  int(a_hp) -= int(t_at)
  if int(a_hp) <= 0:
    print("Yes")
    break
  int(t_hp) -= int(a_at)
  if int(t_hp <= 0:
         print("No")
         break

t_hp,t_at,a_hp,a_at=map(int,input().split())
while(t_hp > 0 and a_hp > 0):
  a_hp -= t_at
  if a_hp <= 0:
    print("Yes")
    break
  t_hp -= a_at
  if t_hp <= 0:
         print("No")
         break

Verdicts: Runtime Error

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

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

taka = a // d
ao = c // b

print("Yes") if ao >= taka else print("No")

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

while True:
    c -= b
    a -= d
    if c <= 0:
        print("Yes")
        break
    if a <= 0:
        print("No")
        break

Verdicts: Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

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

while 1:
	C -= B
	if C<=0
		print("Yes")
		break
	A -= D 
	if A<=0
		print("No")
		break

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

while 1:
	C -= B
	if C<=0:
		print("Yes")
		break
	A -= D 
	if A<=0:
		print("No")
		break

Verdicts: Runtime Error

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
s=list(map(int,input().split()))
a=s[0]
b=s[2]
c=0
for i in range():
  if a<=0 or b<=0:
    break
  if c==0:
    b=b-s[1]
    c=1
  else:
    a=a-s[3]
if a<=0:
  print('No')
else:
  print('Yes')

s=list(map(int,input().split()))
a=s[0]
b=s[2]
for i in range(200):
  if a<=0:
    break
  if b<=0:
    break
  b=b-s[1]
  a=a-s[3]
if a<=0:
  if b<=0:
    print('Yes')
  else:
    print('No')
else:
  print('Yes')

Verdicts: Runtime Error

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
A,B,C,D = map(int, input().split())
while True:
    C = C - B

    if C <= 0:
        print("YES")
        exit()
    A = A - D

    if A <= 0:
        print("NO")
        exit()

A,B,C,D = map(int, input().split())
while True:

    A = A - D
    
    if A <= 0:
        print("NO")
        exit()
    C = C - B
  
    if C <= 0:
        print("YES")
        exit()

A,B,C,D = map(int, input().split())
while True:
    C = C - B

    if C <= 0:
        print("Yes")
        exit()
    A = A - D

    if A <= 0:
        print("No")
        exit()

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ... Here, an attack decreases the opponent's health by the value equal to the attacker's strength. The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print `Yes`; if he will lose, print `No`.

Submission attempts (in order):
a,b,c,d = map(int,input().split())
import math
print("yes" if math.ceil(a/d) >= math.ceil(c/b) else "no")

a,b,c,d = map(int,input().split())
import math
print("Yes" if math.ceil(a/d) >= math.ceil(c/b) else "No")

Verdicts: Wrong Answer

Accepted