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

if A // D <= C // B:
    print('yes')
else:
    print('no')



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

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


import math
A, B, C, D = list(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):
A, B, C, D = map(int, input().split())
while A*C > 0:
  C = C - B
  A = A - D
print("Yes" A>0 else "No")

A, B, C, D = map(int, input().split())
Tcount = 0
Acount = 0
while C > 0:
  C = C -B
  Acount = Acount + 1
while A > 0:
  A = A - D
  Tcount = Tcount + 1
print("Yes" if Tcount >= Acount else "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())
while True:
    c -=b
    if c <= b:
        print("Yes")
        break
    a -=d
    if a <= d:
        print("No")
        break

a,b,c,d =map(int, input().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):
h1_init,a_t,h2_init,a_a = list(map(int, input().split()))
h1=h1_init
h2=h2_init

while h1>=0 or h2>=0:
  h2=h2-a_t
  if h2<=0:
    print("yes")
    break
    
  h1=h1-a_a
  if h1<=0 :
    print("no")
    break

h1_init,a_t,h2_init,a_a = list(map(int, input().split()))
h1=h1_init
h2=h2_init

while h1>=0 or h2>=0:
  h2=h2-a_t
  if h2<=0:
    print("Yes")
    break
    
  h1=h1-a_a
  if h1<=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):
t_hp_str,t_atack_str,a_hp_str,a_atack_str= input().split()
t_hp = int(t_hp_str)
t_atack = int(t_atack_str)
a_hp=int(a_hp_str)
a_atack = int(a_atack_str)

while True:
  if num%2 == 0:
    a_hp = a_hp - t_atack
    if a_hp <= 0:
      print("Yes")
      break
  else:
    t_hp = t_hp - a_atack
    if t_hp <= 0:
      print("No")
      break



t_hp_str,t_atack_str,a_hp_str,a_atack_str= input().split()
t_hp = int(t_hp_str)
t_atack = int(t_atack_str)
a_hp=int(a_hp_str)
a_atack = int(a_atack_str)

while t_hp <= 0 or a_hp <= 0:
  if num%2 == 0:
    a_hp = a_hp - t_atack
    
  else:
    t_hp = t_hp - a_atack

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



t_hp_str,t_atack_str,a_hp_str,a_atack_str= input().split()
t_hp = int(t_hp_str)
t_atack = int(t_atack_str)
a_hp=int(a_hp_str)
a_atack = int(a_atack_str)

num = 0
while t_hp <= 0 or a_hp <= 0:
  if num%2 == 0:
    a_hp = a_hp - t_atack
    
  else:
    t_hp = t_hp - a_atack
num += num
    
if t_hp <= 0:
  print("No")
else:
  print("Yes")



t_hp_str,t_atack_str,a_hp_str,a_atack_str= input().split()
t_hp = int(t_hp_str)
t_atack = int(t_atack_str)
a_hp=int(a_hp_str)
a_atack = int(a_atack_str)

for num in range(300):
  if num%2 == 0:
    a_hp = a_hp - t_atack
    if a_hp <= 0:
      print("Yes")
      break
  else:
    t_hp = t_hp - a_atack
    if t_hp <= 0:
      print("No")
      break



Verdicts: Runtime Error

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_life, taka_at, aoki_life, aoki_at = list(map(int, input().split())) 
num=1
for i in range(10000):
  if num % 2 != 0:
    aoki_life -= taka_at
  elif num % 2 == 0:
    taka_life -= aoki_at
    
  if taka_life <= 0:
    print("No")
    break
  elif aoki_life <= 0:
    print("Yes")
    break

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

print("Yes" if int((c+b-1)/b) >= int((c+b-1)/b) else "No")

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

taka_life, taka_at, aoki_life, aoki_at = list(map(int, input().split())) 
num=1
while(True):
  if num % 2 != 0:
    aoki_life -= taka_at
  elif num % 2 == 0:
    taka_life -= aoki_at
    
  if taka_life <= 0:
    print("No")
    break
  elif aoki_life <= 0:
    print("Yes")
    break

taka_life, taka_at, aoki_life, aoki_at = list(map(int, input().split())) 

a = int(taka_life/aoki_at)
b = int(aoki_life/taka_at)

if a > b:
  print("Yes")
elif b > a:
  print("No")

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

taka_life, taka_at, aoki_life, aoki_at = list(map(int, input().split())) 
num=1
for i in range(100000):
  if num % 2 != 0:
    aoki_life -= taka_at
  elif num % 2 == 0:
    taka_life -= aoki_at
    
  if taka_life <= 0:
    print("No")
    break
  elif aoki_life <= 0:
    print("Yes")
    break

taka_life, taka_at, aoki_life, aoki_at = list(map(int, input().split())) 
num=1
while(True):
  if num % 2 != 0:
    aoki_life -= taka_at
  elif num % 2 == 0:
    taka_life -= aoki_at
    
  if taka_life <= 0:
    print("No")
    break
  elif aoki_life <= 0:
    print("Yes")
    break
    

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



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

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

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):
class Monster:
    def __init__(self, atk, hp):
        self.atk = atk
        self.hp = hp

    def atk_to(self, other):
        other.hp -= self.atk

    def is_dead(self):
        return self.hp <= 0


def main(a, b, c, d):
    tkhs = Monster(a, b)
    aok = Monster(c, d)
    monsters = (tkhs, aok)
    for i in range(1000):
        if i % 2 == 0:
            atk = monsters[0]
            dfd = monsters[1]
        else:
            atk = monsters[1]
            dfd = monsters[0]
        atk.atk_to(dfd)
        if dfd.is_dead():
            break

    if aok.is_dead():
        return 'Yes'
    else:
        return 'No'


if __name__ == '__main__':
    A, B, C, D = map(int, input().split(' '))
    print(main(A, B, C, D))


import math


def main(a, b, c, d):
    tkhs = math.ceil(a / d)
    aok = math.ceil(c / b)

    if tkhs >= aok:
        return 'Yes'
    else:
        return 'No'


if __name__ == '__main__':
    A, B, C, D = map(int, input().split(' '))
    print(main(A, B, C, D))


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

E = math.ceil(A//D)
F = math.ceil(C//B)

if E >= F:
    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

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 -= D
  C -= B
  if A < 0:
    print("No"):
    break
  if C < 0:
    print("Yes")
    break

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

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

Verdicts: 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 sys

input = sys.stdin.readline


def solve():
    t_stamina, t_attack, a_stamina, a_attack = map(int, input().split())
    t_num_attack_to_be_beaten = - (-t_stamina // a_attack)
    a_num_attack_to_be_beaten = - (-a_stamina // t_attack)

    if t_num_attack_to_be_beaten >= a_num_attack_to_be_beaten:
        return 'yes'
    else:
        return 'no'


if __name__ == '__main__':
    answer = solve()
    print(answer)


import sys

input = sys.stdin.readline


def solve():
    t_stamina, t_attack, a_stamina, a_attack = map(int, input().split())
    t_num_attack_to_be_beaten = - (-t_stamina // a_attack)
    a_num_attack_to_be_beaten = - (-a_stamina // t_attack)

    if t_num_attack_to_be_beaten >= a_num_attack_to_be_beaten:
        return 'Yes'
    else:
        return 'No'


if __name__ == '__main__':
    answer = solve()
    print(answer)


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 | C//B <= 1:
	print("Yes")
else:    
	print("No")

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

A, B, C, D = map(int, input().split())
if C/B <= A/D || C/B <= 1:
	print("Yes")
else:    
	print("No")

A, B, C, D = map(int, input().split())
if C/B <= A/D || C/B <= 1:
	print("Yes")
else:    
	print("No")

A, B, C, D = map(int, input().split())
print("Yes" if (A+D-1)//D >= (C+B-1)//B else "No")

Verdicts: Wrong Answer

Wrong Answer

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):
import math
a,b,c,d = map(int,input().split())

x = math.floor(a/c)
y = math.floor(c/d)
if x > y:
    print('No')
else:
    print('Yes')

a,b,c,d = map(int,input().split())
for i in range(1000):
    
    c = c-b
    if c>0:
        pass
    else:
        print('Yes')
        break
    a = a-d
    if a>0:
        pass
    else:
        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 and C > 0:
    C = C - B
    A = A - D
    print(C, A)

if A <= 0 and C <= 0:
    ans = 'Yes'
elif C <= 0:
    ans = 'Yes'
else:
    ans = 'No'
print(ans)



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

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

if A <= 0 and C <= 0:
    ans = 'Yes'
elif C <= 0:
    ans = 'Yes'
else:
    ans = 'No'
print(ans)


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

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

a,b,c,d = map(int,input().split())
if -(-c//b) <= -(-a//d):
  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())

takahashi = A // D
if A % D != 0:
    takahashi += 1
aoki = C // B
if C % B != 0:
    aoki += 1
    
if takahashi <= aoki:
    print('Yes')
else:
    print('No')

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

bool = True
while A > 0 and C > 0:
    C -= B
    if C <= 0:
        bool = True
        break
    A -= D
    if A <= 0:
        bool = False
        break

if bool:
    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):
string = input()
array = string.split()
hp_t = int(array[0])
attack_t = int(array[1])
hp_a = int(array[2])
attack_a = int(array[3])

for i in range(100):
    hp_a -= attack_t
    print(hp_a)
    if hp_a <= 0:
        print('Yes')
        break
    hp_t -= attack_a
    print(hp_t)
    if hp_t <= 0:
        print('No')
        break
    

string = input()
array = string.split()
hp_t = int(array[0])
attack_t = int(array[1])
hp_a = int(array[2])
attack_a = int(array[3])

for i in range(100):
    hp_a -= attack_t
    if hp_a <= 0:
        print('Yes')
        break
    hp_t -= attack_a
    if hp_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())
t = C - B
a = A - D
while True:
    t -= B
    if t <= 0:
        print('Yes')
        break
    a -= D
    if a <= 0:
        print('No')
        break

a,b,c,d = map(int, input().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())
if(A/D<C/B):
  print('No')
else:
  print('Yes')


A,B,C,D=map(int,input().split())
atA=0
atC=0
while(A>0):
    A-=D 
    atA+=1 
while(C>0):
    C-=B 
    atC+=1
#print(atA,atC)
if(atA>=atC):
    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())
#a = Takahashi's HP,b = T's ATK, c = Aoki's HP, d = A's ATK
#T -> A -> T -> A...
print("Yes" if (a//d)+1 >= (c//b) else "No") 

a,b,c,d = map(int,input().split())
#a = Takahashi's HP,b = T's ATK, c = Aoki's HP, d = A's ATK
#T -> A -> T -> A...
print("Yes" if (a//d) <= (c//b) else "No") 

a,b,c,d = map(int,input().split())
#a = Takahashi's HP,b = T's ATK, c = Aoki's HP, d = A's ATK
#T -> A -> T -> A...
print("YES" if (a/d) >= (c/b) else "NO") 

a,b,c,d = map(int,input().split())
#a = Takahashi's HP,b = T's ATK, c = Aoki's HP, d = A's ATK
#T -> A -> T -> A...
print("Yes" if -(-a//d) >= -(-c//b) else "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())
import math
tempt=math.floor(a/d)
tempa=math.floor(c/b)
if tempa>=tempt:
  print("Yes")
else:
  print("No")

a,b,c,d=map(int,input().split())
import math
tempt=math.ceil(a/d)
tempa=math.ceil(c/b)
if tempa<=tempt:
  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 C-B<=0:
  C=C-B
  A=A-D
else:
  if A>=0:
    print("Yes")
  elif A<=0:
    print("No")

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



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

A, B, C, D = map(int, input().split())
while A>0 and C>0:
  C=C-B
  A=A-D
else:
  if C-B<=0:
    print("Yes")
  else:
    print("No")

A, B, C, D = map(int, input().split())
while A>1 :
  C=C-B
  A=A-D
else:
  if C>0 and A<=0:
    print("No")
  elif C<0 or C-B<=0:
    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())
while True:
    c-=b
    if c<1:
        print('Yes')
        break
    a-=d
    if a<1:
        print('No')

a,b,c,d=map(int,input().split())
while True:
    c-=b
    if c<1:
        print('Yes')
        break
    a-=d
    if a<1:
        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 max(a,c)==a and max(b,d)==b:
  print('Yes')
elif max(a,c)==c and max(b,d)==d:
  print('No')
i=0
j=0
while True:
  if c-b>0:
    c=c-b
    i+=1
  else:
    break
while True:
  if a-d>0:
    a-=d
    j+=1
  else:
    break
if i<j:
  print('Yes')
else:
  print('No')
    

    
  



a,b,c,d=map(int,input().split())
i=0
j=0
while True:
  if c-b>0:
    c=c-b
    i+=1
  else:
    break
while True:
  if a-d>0:
    a-=d
    j+=1
  else:
    break
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 = list(map(int, input().split()))
turn = True
while True:
  if turn:
    c -= b
    if c <= 0:
      print("Yes")
  else:
    a -= d
    if a <= 0:
      print("No")
  turn ^= True

a, b, c, d = list(map(int, input().split()))
turn = True
while True:
  if turn:
    c -= b
    if c <= 0:
      print("Yes")
      import sys
      sys.exit()
  else:
    a -= d
    if a <= 0:
      print("No")
      import sys
      sys.exit()
  turn ^= True


Verdicts: Time Limit Exceeded

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):
te, to, ae, ao = map(int, input().split())

while te>0 and ae>0:
    ae -= to
    te -= ao
if ae < 0:
    print('No')
else:
    print('Yes')

te, to, ae, ao = map(int, input().split())

while True:
    ae -= to
    if ae <= 0:
        break
    te -= ao
    if te <= 0:
        break
        
if ae <= 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):
A, B, C, D = map(int, input().split())

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

A, B, C, D = map(int, input().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):
import math
a,b,c,d =map(int,input().split())

if math.ceil(a/b) >= math.ceil(c/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):
a, b, c, d = map(int, input().split())
while a >= 0:
  c -= b
  if c <= 0:
    print("Yes")
    break
  else:
    a -= d
    if a <= 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 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 (a - b) > 0:
    if (a - b) > 0:
        print('Yes')
    else:
        print('No')

a, b, c, d = map(int, input().split())
if (a - b) > 0:
    if (a - b) > 0:
        print('Yes')
    else:
        print('No')
else:
    print('No')

A, B, C, D = map(int, input().split())
while A > 0 and C > 0:
    C -= B
    A -= D
print("Yes" if C <= 0 else "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):
# -*- coding: utf-8 -*-

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

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

# -*- coding: utf-8 -*-
 
a, b, c, d = map(int, input().split())
 
while True:
  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):
a, b, c, d = map(int, input().split())
while a * c:
    c -= b
    a -= d
print('Yes' if a else 'No')

a, b, c, d = map(int, input().split())
print('Yes' if (a - 1) // d >= (c - 1) // b else '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):
def resolve():
    A, B, C, D = map(int, input().split()) 

    if (A // D) <= (C // B):
        print("Yes")
    else:
        print("No")

if __name__ == "__main__":
    resolve()

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

    if (A // D) == (C // B): 
        if (A % D) == 0 and (C % B) != 0:
            print("No")
        else:
            print("Yes")
    elif (C // B) < (A // D):
        print("Yes")
    else:
        if (C // B) == ((A // D) + 1) and (C % B) == 0:
            print("Yes")
        else:
            print("No")

if __name__ == "__main__":
    resolve()

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:
  a-=d
  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:
  a-=d
  c-=b
  if c<=0:
    print("Yes")
  elif a<=0:
    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 = list(map(int,input().split()));

while a>0 and c>0 :
    a -= d;
    c -= b;

if a < 0:
    print('No');
else :
    print('Yes');

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

if a//d <= c//b :
    print('Yes');
else :
    print('No');

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

while a>0 and c>0 :
    a -= d;
    c -= b;

if c <= 0:
    print('No');
else :
    print('Yes');

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

if (c+b-1)//b > (a+d-1)//d :
    print('No');
else :
    print('Yes');

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())
print('Yes' if int(c / b + 1) <= int(a / d + 1) else 'No')

a, b, c, d = map(int, input().split())
print('Yes' if int(c / b + 0.9999) <= int(a / d + 0.9999) 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())
print('Yes' if math.ceil(c/b)+1>math.ceil(a/d) else 'No')  

import math
a,b,c,d=map(int,input().split())
for _ in range(100000):
  c-=b
  if c<=0:
    print('Yes')
    exit()
  a-=d
  if a<=0:
    print('No')
    exit()

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

which = -1
while td > 0 and ad > 0:
    if which == -1:
        ad -= ta
    else:
        td -= aa
    which *= -1

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

td, ta, ad, aa = map(int, input().split())

which = -1
while td > 0 and ad > 0:
    if which == -1:
        ad -= ta
    else:
        td -= aa
    which *= -1

if ad <= 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):
a,b,c,d=map(int,input().split())
n=0
if a%d==0:
    n==a//d
else:
    n==a//d+1
if (a-n*d)<=(c-n*b):
    print("Yes")
else:
    print("No")

a,b,c,d=map(int,input().split())
if (a+d-1)//d>=(c+b-1)//b:
    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:    
    x=c-b
    if x<=0:
        print('No')
        break
    y=a-d
    if y<=0:
        print('Yes')
        break

a,b,c,d = map(int,input().split())
x=c
y=a
while True:  
    x=x-b
    
    if x<=0:
        print('Yes')
        break
    y=y-d
    if y<=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())
n = 1
while A > 0 and C > 0:
  if n % 2 == 1:
    C = C - B
    ans = "Yes"
    n = n + 1
  else:
    A = A - D
    ans = "NO"
    n = n + 1
    
print(ans)

A, B, C, D = map(int, input().split())
n = 1
while A > 0 and C > 0:
  if n % 2 == 1:
    C = C - B
    ans = "Yes"
    n = n + 1
  else:
    A = A - D
    ans = "No"
    n = n + 1
    
print(ans)

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.ceil(c/b) <= math.ceil(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