Problem:


Score : 100 points

Problem Statement

Takahashi is meeting up with Aoki.

They have planned to meet at a place that is D meters away from Takahashi's house in T minutes from now.

Takahashi will leave his house now and go straight to the place at a speed of S meters per minute.

Will he arrive in time?

Constraints

1 \leq D \leq 10000

1 \leq T \leq 10000

1 \leq S \leq 10000

All values in input are integers.

Input

Input is given from Standard Input in the following format:

D T S

Output

If Takahashi will reach the place in time, print Yes; otherwise, print No.

Sample Input 1

1000 15 80

Sample Output 1

Yes

It takes 12.5 minutes to go 1000 meters to the place at a speed of 80 meters per minute. They have planned to meet in 15 minutes so he will arrive in time.

Sample Input 2

2000 20 100

Sample Output 2

Yes

It takes 20 minutes to go 2000 meters to the place at a speed of 100 meters per minute. They have planned to meet in 20 minutes so he will arrive just on time.

Sample Input 3

10000 1 1

Sample Output 3

No

He will be late.



Sample input:
1000 15 80


Sample output:
Yes

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())

if T*S >= D:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
D,T,S = list(map(int, input().split()))

if(S*T >= D):
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
import math
D, T, S = map(int, input().split())
if T >= D / S:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:

d,t,s = map(int, input().split(" "))
if d/s <= t:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
from sys import stdin
rs = lambda : stdin.readline().strip()
ri = lambda : int(rs())
ril = lambda : list(map(int, rs().split()))

def main():
    D, T, S = ril()
    print("Yes" if S * T >= D else "No")


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def main():
    D, T, S = map(int, input().split())
    return T * S >= D
if main():
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())
print("No") if d > t*s else print("Yes")

Submission status: Accepted

Solution code:
d,t,s = map(int, input().split())
if s*t >= d:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())
if d <= t*s:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())

if d<=t*s:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
if S * T >= D:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d,t,s =map(int,input().split())

if s*t>=d:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
from collections import defaultdict, Counter
from itertools import product, permutations, combinations, accumulate
from bisect import bisect_left, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor


def input_list():
    return list(map(int, input().split()))


def input_int():
    return int(input())


D, T, S = input_list()
if D / S <= T:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

D,T,S=map(int,input().split())

if D <= S*T:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())
print("Yes" if t*s>=d else "No")

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())
if D <= T*S:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

d,t,s=MI()
if d<=t*s:print("Yes")
else:print("No")

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())
if t-(d/s)>=0:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())

if T * S >= D:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D,T,S=map(int,input().split())

print('Yes' if (D/S)<=T else 'No')

Submission status: Accepted

Solution code:
from sys import stdin
input = stdin.readline

if __name__ == "__main__":
    D, T, S = map(int, input().split())
    if D > T * S: print("No")
    else:print("Yes")

Submission status: Accepted

Solution code:
d, t, s = map(int,input().split())
if d/s <= t:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())
if D/T<=S:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
def main():
    D, T ,S = map(int, input().split())
    if D > T*S:
        print('No')
    else:
        print('Yes')

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
import fractions
import collections
import itertools
D,T,S=map(int,input().split())
time=D/S
if time<=T:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
D, T, S = map(int, input().split())

m = D / S
if m <= T:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
#!python3

import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())

def resolve():
    D, T, S = iim()

    print("Yes" if D/S <= T else "No")

if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())

if d<=t*s:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
D,T,S = list(map(int,input().split()))

if D/T <= S:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())

if D > T * S:
    print('No')
else:
    print('Yes')

Submission status: Accepted

Solution code:
in0 = input().split()
D = int(in0[0])
T = int(in0[1])
S = int(in0[2])

if D/S <= T: 
  print("Yes")
else: 
  print("No")

Submission status: Accepted

Solution code:
def main():
    d, t, s = map(int, input().split())
    if t*s >= d:
        print("Yes")
    else:
        print("No")

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
from math import floor, ceil, sqrt, factorial, log, gcd
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict
from heapq import heappop, heappush, heappushpop
import copy
import numpy as np
import sys
INF = float('inf')
mod = 10**9+7


def lcm(a, b): return a * b / gcd(a, b)

# 1 2 3
# a, b, c = LI()


def LI(): return list(map(int, sys.stdin.buffer.readline().split()))

# a = I()


def I(): return int(sys.stdin.buffer.readline())

# abc def
# a, b = LS()


def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()

# a = S()


def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')

# 2
# 1
# 2
# [1, 2]


def IR(n): return [I() for i in range(n)]

# 2
# 1 2 3
# 4 5 6
# [[1,2,3], [4,5,6]]


def LIR(n): return [LI() for i in range(n)]

# 2
# abc
# def
# [abc, def]


def SR(n): return [S() for i in range(n)]

# 2
# abc def
# ghi jkl
# [[abc,def], [ghi,jkl]]


def LSR(n): return [LS() for i in range(n)]

# 2
# abcd
# efgh
# [[a,b,c,d], [e,f,g,h]]


def SRL(n): return [list(S()) for i in range(n)]


def main():
    d, t, s = LI()
    if t >= d / s:
        print("Yes")
    else:
        print("No")


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def main():
    D, T, S = map(int, input().split())
    cond = T * S >= D
    print('Yes' if cond else 'No')


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
if D - T*S <= 0:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
#a
D,T,S = map(int,input().split())

if T*S>=D:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D,T,S=map(int, input().split())

if T*S >=D:
	print("Yes")
else:
	print("No")

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())

if S*T >= D:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
D, T, S = list(map(int, input().split()))

if (D / S <= T):
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())
if d-t*s <= 0:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())
if s*t < d:
    print("No")
else:
    print("Yes")

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
# = int(input())
if S*T >= D:
  print('Yes')
else:
  print('No')

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())

if d>t*s:
    print("No")
else:
    print("Yes")

Submission status: Accepted

Solution code:
# import sys
# import math #sqrt,gcd,pi
# import decimal
import queue # queue
# import bisect
# import heapq # priolity-queue
# import time
# from itertools import product,permutations,\
    # combinations,combinations_with_replacement
# 重複あり順列、順列、組み合わせ、重複あり組み合わせ
# import collections # deque
# from operator import itemgetter,mul
# from fractions import Fraction
# from functools import reduce

mod = int(1e9+7)
# mod = 998244353
INF = 1<<50

def readInt():
    return list(map(int,input().split()))

def main():
    d,t,s = readInt()
    if s*t<d:
        print("No")
    else:
        print("Yes")
    return

if __name__=='__main__':
    main()

Submission status: Accepted

Solution code:
d,t,s=list(map(int,input().split(" ")))
if d/s<=t:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D,T,S=map(int,input().split())

if D<=S*T:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
d,t,s = list(map(int,input().split()))

if d <= t * s:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())

if s*t>=d:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d, t, s = map(int , input().split())

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

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())
if t*s >= d:
  print('Yes')
else:
  print('No')

Submission status: Accepted

Solution code:
D, T, S = list(map(int, input().split()))

t = D // S
if D % S != 0: t += 1

if t <= T:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
# coding: utf-8
from functools import reduce
from queue import Queue
from collections import deque

d, t, s = list(map(int, input().split(" ")))

if t*s >= d:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D,T,S = map(int, input().split())

ans="No"
if D <= T*S: ans = "Yes"
print(ans)

Submission status: Accepted

Solution code:
d, t, s = list(map(int, input().split()))

if (d-1) // s + 1 <= t:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())

bl = s * t >= d

print("Yes" if bl else "No")

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())
if d<=s*t:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
def main():
    d, t, s = map(int, input().split())

    hun = d / s

    if t >= hun:
        print('Yes')
    else:
        print('No')


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

D, T, S = map(int, input().split())

if D > T * S:
    print('No')
else:
    print('Yes')

Submission status: Accepted

Solution code:
D,T,S = map(int, input().split())
if D > T*S:
    print('No')
else:
    print('Yes')

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())
if d/s>t:
    print('No')
else:
    print('Yes')

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())

if T * S >= D:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())
print('Yes' if t * s >= d else 'No')

Submission status: Accepted

Solution code:
D,T,S = list(map(int,input().split()))

if D/S <= T:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
d, t, s = map(float, input().split())
if d / s > t:
    print('No')
else:
    print('Yes')

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
from math import floor, sqrt, factorial, hypot, log  # log2ないｙｐ
from heapq import heappop, heappush, heappushpop
from collections import Counter, defaultdict, deque
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint


def ceil(a, b): return (a + b - 1) // b


inf = float('inf')
mod = 10 ** 9 + 7


def pprint(*A):
    for a in A:     print(*a, sep='\n')


def INT_(n): return int(n) - 1


def MI(): return map(int, input().split())


def MF(): return map(float, input().split())


def MI_(): return map(INT_, input().split())


def LI(): return list(MI())


def LI_(): return [int(x) - 1 for x in input().split()]


def LF(): return list(MF())


def LIN(n: int): return [I() for _ in range(n)]


def LLIN(n: int): return [LI() for _ in range(n)]


def LLIN_(n: int): return [LI_() for _ in range(n)]


def LLI(): return [list(map(int, l.split())) for l in input()]


def I(): return int(input())


def F(): return float(input())


def ST(): return input().replace('\n', '')


def main():
    D, T, S = LI()
    if D / S <= T:
        print("Yes")
    else:
        print("No")


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys
from sys import exit
from math import gcd, factorial, ceil, floor, sqrt
from bisect import bisect_left, bisect_right
from copy import deepcopy
from heapq import heapify, heappop, heappush
from itertools import permutations, combinations, product, accumulate
from collections import defaultdict, deque, Counter
sys.setrecursionlimit(10**7)

ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(map(int, input().split()))

D, T, S = mi()
if D <= T*S:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
ans = 'Yes' if S * T >= D else 'No'
print(ans)

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())
if T*S >= D:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D,T,S=map(int,input().split())
if T*S>=D:
  print('Yes')
else:
  print('No')

Submission status: Accepted

Solution code:
# import sys
# readline = sys.stdin.readline
# generator = (readline().strip() for _ in range(N))

# N, M = map(int, input().split())
# As = list(map(int, input().split()))
# queries = (input() for _ in range(N))


def solve():
    d, t, s = map(int, input().split())
    p = s * t
    if d > p:
        return "No"
    return "Yes"


def main():
    print(solve())


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())

x=t*s

if x>=d:
  print('Yes')
  
else:
  print('No')

Submission status: Accepted

Solution code:
def resolve():
    '''
    code here
    '''
    D, T, S = [int(item) for item in input().split()]

    if D / S <= T:
        print('Yes')
    else:
        print('No')


if __name__ == "__main__":
    resolve()

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())
if S*T < D:
    print('No')
else:
    print('Yes')

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())

if t*s >= d:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())

if (d/s)<=t:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
from sys import stdin, setrecursionlimit
#input = stdin.buffer.readline
setrecursionlimit(10 ** 7)

from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict, Counter
from itertools import combinations, permutations, combinations_with_replacement
from itertools import accumulate
from math import ceil, sqrt, pi, radians, sin, cos

MOD = 10 ** 9 + 7
INF = 10 ** 18

#N = int(input())
D, T, S = map(int, input().split())
#A = list(map(int, input().split()))
#A = [int(input()) for _ in range(N)]
#ABC = [list(map(int, input().split())) for _ in range(N)]
#S = input()
#S = [input() for _ in range(N)]

if T * S >= D:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())

print("Yes") if D <= T * S else print("No")

Submission status: Accepted

Solution code:
d, t, s = map(int,input().split())

if s * t >= d:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())

if d <= t*s:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
import sys
import math
import collections
import bisect
import itertools
import decimal

# import numpy as np

# sys.setrecursionlimit(10 ** 6)
INF = 10 ** 20
MOD = 10 ** 9 + 7
# MOD = 998244353

ni = lambda: int(sys.stdin.readline().rstrip())
ns = lambda: map(int, sys.stdin.readline().rstrip().split())
na = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
na1 = lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))


# ===CODE===

def main():
    d, t, s = ns()
    flg = d <= t * s
    print("Yes" if flg else "No")


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

'''
Author: andyli
Time: 2020-08-29 19:58:33
'''

import os
from io import BytesIO, IOBase
import sys


def main():
    d,t,s = map(int,input().split())

    print('Yes' if t*s>=d else 'No')
    return


# region fastio
BUFSIZE = 1048576


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = 'x' in file.mode or 'r' not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b'\n') + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode('ascii'))
        self.read = lambda: self.buffer.read().decode('ascii')
        self.readline = lambda: self.buffer.readline().decode('ascii')


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def input(): return sys.stdin.readline().rstrip('\r\n')

# endregion


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
n,k,t=map(int,input().split())
h=n/t
if h<=k:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
# /usr/bin/python3
# -*- coding: utf-8 -*-
from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, log10, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key
from bisect import bisect_left


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


def lcm(a, b):
    return (a*b) // gcd(a,b)

def intinput():
    return int(input())

def mulinputs():
    return map(int,input().split())

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

def bindex(a,x):
    i = bisect_left(a,x)
    if i != len(a) and a[i] == x:
        return i
    return None

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __radd__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x + self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x + self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rsub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x - self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x - self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rmul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rtruediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __rpow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(other.__x, self.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(other.__x, self.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")

    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x
    def __str__(self):
        return str(self.__x)



if __name__ == '__main__':
    D, T, S = mulinputs()

    if D/S <= T:
        print('Yes')
    else:
        print('No')

Submission status: Accepted

Solution code:
def main():
    D, T, S = map(int, input().split())

    if D/S <= T:
        print("Yes")
    else:
        print("No")
    
if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())
if t >= d/s:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d,t,s  = map(int, input().split())
if d <= t*s:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())

if T * S >= D:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())

a = d/s
if a > t:
    print('No')
else:
    print('Yes')

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
if D/S > T:
    print('No')
else:
    print('Yes')

Submission status: Accepted

Solution code:
d,t,s = map(int, input().split())
print('Yes' if t*s >= d else 'No')

Submission status: Accepted

Solution code:
d,t,s= map(int,input().split())

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

Submission status: Accepted

Solution code:
D, T, S = [int(x) for x in input().split()]
print('Yes' if D <= T * S else 'No')

Submission status: Accepted

Solution code:
if __name__ == "__main__":
    D, T, S = map(int, input().split())
    if T * S >= D:
        print("Yes")
    else:
        print("No")

Submission status: Accepted

Solution code:
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

d,t,s = na()

print('Yes' if t >= d/s else 'No')

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())

print('Yes' if (D+S-1)//S <= T else 'No')

Submission status: Accepted

Solution code:
a,b,c=map(int,input().split())
if a/c<=b:
  print('Yes')
else:
  print('No')

Submission status: Accepted

Solution code:
d, t, s = [int(_) for _ in input().split()]

if d <= t*s:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
def main():
    d, t, s = map(int, input().split())
    if d / s <= t:
        print("Yes")
    else:
        print("No")


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
import sys
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math
import copy
# from fractions import gcd

MOD = 10 ** 9 + 7
# MOD = 998244353
# sys.setrecursionlimit(10**8)

d, t, s = map(int, input().split())
if t*s >= d:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
def main():
    d,t,s = map(int,input().split())
    if d/s <= t:
        print('Yes')
    else:
        print('No')

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
A,B,C=list(map(int,input().split()))
if A <= B*C:
   print("Yes")
else:
   print("No")

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())

if d > t*s:
    print("No")
else:
    print("Yes")

Submission status: Accepted

Solution code:
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext
# input = sys.stdin.readline 
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []

def main():
    d, t, s = i_map()

    print('Yes' if d <= t * s else 'No')

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:

#!/usr/bin/python
# -*- coding: utf-8 -*-

# def
def int_mtx(N):
    x = []
    for _ in range(N):
        x.append(list(map(int,input().split())))
    return np.array(x)

def str_mtx(N):
    x = []
    for _ in range(N):
        x.append(list(input()))
    return np.array(x)

def int_map():
    return map(int,input().split())

def int_list():
    return list(map(int,input().split()))

def print_space(l):
    return print(" ".join([str(x) for x in l]))

# import
import numpy as np
import collections as col

# main code
D,T,S = int_map()

if D <= S*T:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

D,T,S=map(int,input().split())

if D<=T*S:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())

if D <= T * S:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
def solve():
    d, t, s = map(int, input().split())
    f = d/s
    print("Yes" if f <= t else "No")


def main():
    t = 1
    while t > 0:
        solve()
        t -= 1


main()

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())

if s*t>=d:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D,T,S=map(int,input().split())

if D/S<=T:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())
if t>=d/s: print("Yes")
else: print("No")

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())
if t >= d/s:
    print('Yes')
else:
    print('No')