TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):

N,X,T = map(int, input().split())
print(N)


count = 0


if N % X == 0:
    count = N / X
    print(count)
else:
    count = N // X + 1
    print(count)


ans = count * T


import math

N,X,T = map(int, input().split())

print(math.ceil(N/X) * T)


Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

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

if n % x == 0:
  print(n / x * t)
else:
  print((n / x + 1) * t)

n, x, t = map(int, input().split())

if n % x == 0:
  print(n // x * t)
else:
  print((n // x + 1) * t)


Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"

import string
s = v()

if s == 'zyxwvutsrqponmlkjihgfedcba':
    print(-1)
    exit()

lis =list(string.ascii_lowercase)
nlis = [0]*26

for i in s:
    t = lis.index(i)
    nlis[t] += 1

if sum(nlis) != 26:
    for i in range(26):
        if nlis[i] == 0:
            print(s+lis[i])
            break
else:
    for i in range(25, -1, -1):
        for j in lis:
            if s[i] < j and j not in s[:i]:
                print(s[:i] + j)
                exit()


import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"

n,x,t = I()

if n % x == 0:
    print(t*(n//x))
else:
    print(t*(n//x+1))




Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import math
n,x,t=map(int(input().split()))
ans=math.ceiling(n/x)*t
print(ans)

import math
n,x,t=map(int,input().split())
ans=math.ceil(n/x)*t
print(ans)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
line = [int(i) for i in input().rstrip().split()]
N = line[0]
X = line[1]
T = line[2]

print((N//X+1)*T)line = [int(i) for i in input().rstrip().split()]
N = line[0]
X = line[1]
T = line[2]

if N%X == 0:
	print((N//X)*T)
else:
    print((N//X+1)*T)
    

line = [int(i) for i in input().rstrip().split()]
N = line[0]
X = line[1]
T = line[2]
 
if N%X == 0:
	print((N//X)*T)
else:
    print((N//X+1)*T)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n,x,t= map(int,input().split())
f1=n/x
f2=n//x
if f1==f2:
  print(f2)
else:
  print(f2+1)

n,x,t= map(int,input().split())
f1=n/x
f2=n//x
if f1==f2:
  print(f2*t)
else:
  print((f2+1)*t)


Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n = list(input())
a = 0
for i in n:
  a +=int(i)
  
if a%9==0:
  print('Yes')
else:
  print('No')

m,n,k = map(int,input().split())
if m%n == 0:
  print(int(k*((m//n))))
elif m%n !=0:
  print(int(k*((m//n)+1)))

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
q = input().strip().split()
N, X, T = int(q[0]), int(q[1]), int(q[2])
ans = ((N + X) // X - 1) * T
print(ans)

q = input().strip().split()
N, X, T = int(q[0]), int(q[1]), int(q[2])
ans = ((N + x) // x - 1) * T
print(ans)

q = input().strip().split()
N, X, T = int(q[0]), int(q[1]), int(q[2])
ans = (N + X - 1) // X * T
print(ans)


Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N,X,T = int(input().split())
t = 0
while(N>0):
  t += 1
  N -= X

print(T*t)

N,X,T = map(int, input().split())
t = 0
while(N>0):
  t += 1
  N -= X

print(T*t)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import math
n, x, t = map(int, input().split())
print(math.ceil(x/n)*t)

import math
n, x, t = map(int, input().split())
print(math.ceil(n/x)*t)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N = int(input())

c = N % 9
if(c==0):
  print("Yes")
else:
  print("No")
        
     

N,X,T = map(int,input().split())

count = 0
while(N>0):
  N = N - X
  count += 1
  
print(T*count)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
if __name__ == "__main__":
    n, x, t = map(int, input().split())

    ans = t * (n + x - 1) / x
    ans = int(ans)
    print(ans)

if __name__ == "__main__":
    n, x, t = map(int, input().split())

    if n%x == 0:
        ans = n//x
    else:
        ans = (n//x) + 1
    ans *= t
    print(ans)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

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

p=n//x

if t%p==0:
  print(t*p)
else:
  print(t*(p+1))

n,x,t=map(int,input().split())

p=n//x

if n%x==0:
  print(t*p)
else:
  print(t*(p+1))

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import math as mt
a,b,c=map(int,input().split())
y=b/a
y1=mt.ceil(y)
y2=int(y1)
y3=int(y2*c)
print(y3)

import math as mt
a,b,c=map(int,input().split())
y=a/b
y1=mt.ceil(y)
y2=int(y1)
y3=int(y2*c)
print(y3)


Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import math
N,X,T=map(int,input().split())
ans = math.ceil(N/(X*T))
print(ans)


import math
N,X,T=map(int,input().split())
ans = math.ceil(N/X)*T
print(ans)


Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import numpy as np
h,w,m = map(int,input().split())
bomb = list(tuple(map(lambda x: int(x)-1,input().split())) for i in range(m))
Map= np.zeros((h,w))
for i in bomb:
    Map[i] = 1
    
bombx = np.count_nonzero(Map,axis=0)
bomby = np.count_nonzero(Map,axis=1)
maxx = max(bombx)
maxy = max(bomby)
maxx_index = np.where(bombx == maxx)
maxy_index = np.where(bomby == maxy)

flag = 0
for i in maxx_index[0]:
    for j in maxy_index[0]:
        if Map[i][j] == 0:
            flag = 1
if flag == 0:
    print(maxx+maxy)
else:
    print(maxx+maxy-1)

n,x,t = map(int,input().split())
cnt = -((-n)//x)
print(t*cnt)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

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

if n%t == 0:
    print(int((n//x)*t))
else:
    print(int((n // x)*t + 1))


n, x, t = map(int, input().split())

if n%x == 0:
    ans = (n // x) * t
else:
    ans = (n // x + 1) * t

print(ans)


Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import math
N, X, T = map(int, input().split())
print(math.ceil(n / x) * t)


import math
N, X, T = map(int, input().split())
print(math.ceil(N/ X)* T)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N,X,T=map(int, input().split())
if N%X==0:
    print(N//X)
else:
    print((N//X)+1)

N,X,T=map(int, input().split())
if N%X==0:
    print((N//X)*T)
else:
    print(((N//X)+1)*T)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

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

if n%x == 0:
  print(t*n/x)
else:
  print(t*n/x + t)

n,x,t = map(int,input().split())

if n%x == 0:
  print(t*n//x)
else:
  print(t*n//x + t)

n,x,t = map(int,input().split())

if n%x == 0:
  print(t*(n//x))
else:
  print(t*(n//x)+t)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N = int(input())
A = list(map(int, input().split()))
A.reverse()
ans = 0
max_step = 0
for i in range(N):
    max_step = max(A[i:]) - A[i]
    ans += max_step
print(ans)

N = int(input())
A = list(map(int, input().split()))
A.reverse()
ans = 0
max_step = 0
for i in range(N):
    max_step = max(A[i:]) - A[i]
    ans += max_step
print(ans)

N, X, T = map(int, input().split())
min_time = 0
while N > 0:
    min_time += T
    N -= X
print(min_time)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N=int(input())
X=int(input())
T=int(input())
print((N//X+1)*T)


N,X,T=map(int,input(),split())
if N/X==0:
  print(N/X*T)
else:
  print((N//X+1)*T)


N=int(input())
X=int(input())
T=int(input())
print((int(N//X)+1)*T)


N,X,T=map(int,input(),split())
print((N//X+1)*T)

N=int(input())
X=int(input())
T=int(input())
print((int(N/X)+1)*T)

n,x,t=map(int,input().split())
if n%x==0:
  print(n//x*t)
else:
  print((n//x+1)*t)


Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
X = int(input())
T = int(input())
N = int(input())
Y = X
ans = 0
cnt = 1

while X < N:
    X = X + Y
    cnt = cnt + 1

ans = T * cnt
print(ans)


n,x,t = map(int, input().split())
Y = X
ans = 0
cnt = 1

while X < N:
    X = X + Y
    cnt = cnt + 1
	ans = T * cnt
	print(ans)

X = int(input())
T = int(input())
N = int(input())
Y = X
ans = 0
cnt = 1

while X < N:
    X = X + Y
    cnt = cnt + 1

ans = T * cnt
print(ans)


# -*- coding: utf-8 -*-
X = int(input())
T = int(input())
N = int(input())
Y = X
ans = 0
cnt = 1

while X < N:
    X = X + Y
    cnt = cnt + 1

ans = T * cnt
print(ans)


n, x, t = map(int, input().split())
tm = (n // x) * t 
if (n % x) != 0:
    tm += t
print(tm)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import math
N,X,T=list(map(int,input().split()))
print(N,X,T)
print(math.ceil(N/X)*T)

import math
N,X,T=list(map(int,input().split()))
print(math.ceil(N/X)*T)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n,x,t = map(int, input().split())
ans = 0
ans += -(-n//x)
print(ans)

n,x,t = map(int, input().split())
ans = 0
ans += -(-n//x)
print(t*ans)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import sys
input = sys.stdin.readline
h,w,m = map(int,input().rstrip().split())
hw = [list(map(int,input().rstrip().split()))for _ in range(m)]

tate = [0]*(h+1)
yoko = [0]*(w+1)
bombpoint = set()

for x,y in hw:
    tate[x] += 1
    yoko[y] += 1
    bombpoint.add((x,y))

ans_x = []
ans_y = []
x_max = max(tate)
y_max = max(yoko)
for i in range(len(tate)):
    if tate[i] == x_max:
        ans_x.append(i)
for i in range(len(yoko)):
    if yoko[i] == y_max:
        ans_y.append(i)

ans = x_max + y_max
for x in ans_x:
    for y in ans_y:
        if (x,y) not in bombpoint:
            print(ans)
            exit()
print(ans - 1)


N, X, T = (int(x) for x in input().split() )

a = int(N/X)

if N % X != 0:
    t = (a + 1)* T
else:
    t = a * T

print(t)


Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N, X, T = [int(i) for i in input().split()]
print(T * N // X)

N, X, T = [int(i) for i in input().split()]
print((N // X) * T)

import math
N, X, T = [int(i) for i in input().split()]
print(math.ceil(N / X) * T)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n,x,t=map(int,input().split())
d=x//n
print(t*(d+1))

n,x,t=map(int,input().split())
d=n//x
if n%x==0:
  print (t*d)
else:  
  print(t*(d+1))




Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n,x,t=map(int,input().split())
s=ceil(n//x)
print(s*t)

import math
n,x,t=map(int,input().split())
s=math.ceil(n/x)
print(s*t)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n=int(input())
l=map(int,input().split())
ans=0
maxt=0
for i in l:
  if i<maxt:
    ans+=maxt-i
  maxt=max(i,maxt)
print(ans)


n=int(input())
l=list(map(int,input().split()))
ans=0
maxt=0
for i in l:
  if i<maxt:
    ans+=maxt-1
    maxt=max(i,maxt)
print(ans)


n,x,t=map(int,input().split())
if n%x==0:
  print(n/x*t)
else:
  print((n/x+1)*t)

n,x,t=map(int,input().split())
if n%x==0:
  print(n//x*t)
else:
  print((n//x+1)*t)


Verdicts: Runtime Error

Runtime Error

Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N, X, T = (int(a) for a in input().split())
print(math.ceil(N / X) * T)

import math
N, X, T = (int(a) for a in input().split())
print(math.ceil(N / X) * T)


Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n, x, t = map(int, input().split(" "))

out = int(math.ceil(n/x)) * t
print(out)

import math
n, x, t = map(int, input().split(" "))
 
out = int(math.ceil(n/x)) * t if x != 0 else 0
print(out)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
print("33")


import math

n, x, t = map(int, input().split())

res = math.ceil(1. * n / x) * t

print(res)


Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N, X, T = [int(s) for s in input().split(" ")]

t = T * (N + X - 1) / X 
print(t)

N, X, T = [int(s) for s in input().split(" ")]

t = T * ((N + X - 1) // X )
print(t)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
# cook your dish here
n,x,t=list(map(int,input().split()))
rate=int(x/t)
if(rate==0 or rate==1):
    answer=n*t
    print(int(answer))
elif(rate!=0 and rate!=1):
    answer=n/rate
    print(int(answer))
elif(n==20 , x=12 , t=6 ):
    print(12)

# cook your dish here
n,x,t=list(map(int,input().split()))
rate=int(x/t)
if(rate==0 or rate==1):
    answer=n*t
    print(int(answer))
else:
    answer=n/rate
    print(int(answer))

import math
 
n, x, t = map(int, input().split())
 

# print(count * t)
 
count = n // x
if n % x != 0:
    count = count + 1
print(count * t)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N = int(input())

hantei = 0

while N != 0 or N > 1:
    hantei += N % 10
    N = N // 10

if hantei % 9 == 0:
    ans = "Yes"
else:
    ans = "No"

print(ans)


N, X, T = map(int ,input().split())

ans = (N // X) * T
if N % X != 0:
    ans += T

print(ans)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import sys
import os
import math
f = open('test01.txt', 'r')
sys.stdin = f

n,x,t = map(int,input().split())
print(math.ceil(n/x)*t)

import math

n,x,t = map(int,input().split())
print(math.ceil(n/x)*t)


Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
def solve():
    N = int(input())
    X = int(input())
    T = int(input())
    try_num = N // X
    print(try_num)
    if N % X != 0 :
        try_num += 1
    total_time = try_num * T
    print(total_time)

if __name__ == "__main__":
    solve()


def main() :
    N, X, T= list(map(int, input().split()))
    print((N + X - 1) // X * T)

if __name__ == "__main__":
    main()

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):

import math
N, X, T = [int(i) for i in input().split()]
print(math.ceil(N/X * T))


import math
N, X, T = [int(i) for i in input().split()]
print(math.ceil(N/X) * T)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n,x,t=map(int,input().split())
m=math.ceil(n/x)*t

import math
n,x,t=map(int,input().split())
m=math.ceil(n/x)*t
print(m)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N,X,T = map(int,input().split())
a = N // X
if N % X == 0:
    Time = a*T
else:
    Tiem = (a+1)*T
print(Time)

N,X,T = map(int,input().split())
a = N // X
Time = 0
if N % X == 0:
    Time = a*T
else:
    Time = (a+1)*T
print(Time)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

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

print(((n-1)+1)//x*t)


n, x, t = map(int, input().split())

print(((n-1)//x+1)*t)


Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
a=input().split('')
n=int(a[0])
x=int(a[1])
t=int(a[2])
f=x
m=t
while x<n:
  x=x+f
  t=t+m
print(t)


a=input().split(' ')
n=int(a[0])
x=int(a[1])
t=int(a[2])
f=x
m=t
while x<n:
  x=x+f
  t=t+m
print(t)


Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
a = list(map(int,input().split()))
n = a[0]
x = a[1]
t = a[2]
print(n,x,t)

if n%x == 0:
  print((int)(n/x)*t)
else:
  print((int)(n//x+1)*t)

a = list(map(int,input().split()))
n = a[0]
x = a[1]
t = a[2]

if n%x == 0:
  print((int)(n/x)*t)
else:
  print((int)(n//x+1)*t)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import math

N, X, T = list(map(int, input().rstrip().split(' ')))

ans = math.floor(N / X) * T

print(ans)

import math

N, X, T = list(map(int, input().rstrip().split(' ')))

ans = math.ceil(N / X) * T

print(ans)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
#abc176b
N=input()
s=0
for i in range(len(N)):
 s+=int(N[i])
if s%9==0:
 print('Yes')
else:
 print('No')


#abc176a
import math
n,x,t=map(int,input().split())
print(math.ceil(float(n)/x)*t)


Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n=input()
n = int(n)
x=input()
x = int(x)
t=input()
t=int(t)
if x == 1:
    count = n
else:
    count = n//x 
    if n%x == 0:
        pass
    else:
    　　count = count + 1

print(t*count)

n=input()
n = int(n)
x=input()
x = int(x)
t=input()
t=int(t)
if x == 1:
    count = n
else:
    count = n//x 
    if n%x == 0:
        pass
    else:
        count = count + 1

print(t*count)

n = input()
n = int(n)
x = input()
x = int(x)
t = input()
t = int(t)

if x == 1:
    count = n
else:
    count = n//x
    if n%x == 0:
        pass
    else:
        count = count + 1

print(t*count)

n=input()
n = int(n)
x=input()
x = int(x)
t=input()
t=int(t)
if x == 1:
    count = n
else:
    count = n//x 
    if n%x == 0:
        pass
    else:
        count = count + 1

print(t*count)

n=input()
n = int(n)
x=input()
x = int(x)
t=input()
t=int(t)
if x == 1:
    count = n
else:
    count = n//x 
    if n%x == 0:
        pass
    else:
        count = count + 1

print(t*count)

n=input()
n = int(n)
x=input()
x = int(x)
t=input()
t=int(t)
if x == 1:
    count = n
else:
    count = n//x 
    if n%x == 0:
        pass
    else:
     count = count + 1

print(t*count)

n,x,t=map(int,input().split())
count = n // x
if n % x == 0:
    pass
else:
    count += 1
print(count * t)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import math
n,x,t = map(int,input().split())
print(math.ceil(n//x)*t)

import math
n,x,t = map(int,input().split())
print((math.ceil(n/x))*t)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
print("No"if int(input())%9else"Yes")


import math
def MAP(): return map(int, input().split())
N, X, T = MAP()

print(math.ceil(N / X) * T)


Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N, X, T = list(map(int(input().split())))

print((N // X + 1) * T)

import math

N, X, T = list(map(int, input().split()))

print(math.ceil(N / X) * T)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n,x,t=map(int,input().split())
print(t*(n+(x-1)//t))

n,x,t=map(int,input().split())
print(t*((n+x-1)//x))

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n,x,t = map(int,input().split())
print((n//x)*t)

from math import ceil
n,x,t = map(int,input().split())
print(ceil(n/x)*t)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
a,b,c=map(int,inout().split())
ans=0
while 1:
    if b>0:
        a-=b
        ans+=1
    else:
        break
print(ans*c)

a,b,c=map(int,input().split())
ans=a/b
if a%b!=0:
    ans+=1
print(ans*c)

a,b,c=map(int,input().split())
ans=0
while 1:
    if b>0:
        a-=b
        ans+=1
    else:
        break
print(ans*c)

n,x,t=map(int,input().split())
if n%x==0:
    print(int(n/x*t))
else:
    print(int(n//x+1)*t)

Verdicts: Runtime Error

Wrong Answer

Time Limit Exceeded

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N,X,T = input().split()


A = ((N // X) + 1 ) * T
print(int(A))

N,X,T = input(int()).split()

A = ((N // X) + 1 ) * T
print(int(A))

N,X,T = input(int()).split()

A = ((N // X) + 1 ) * T
print(A)

N,X,T = input(int()).split()


if N % X != 0:
  A = ((N // X) + 1 ) * T
else:
  A = (N/X) * T
print(int(A))

N,X,T = input().split()

N = int(N)
X = int(X)
T = int(T)

if N % X != 0:
  A = ((N // X) + 1 ) * T
else:
  A = (N/X) * T
print(int(A))

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N = int(input())
X = int(input())
T = int(input())

a = N // X
min_T = T*a

print(min_T)

N, X, T = map(int, input().split())

a = N // X
if N%X == 0
	min_T=T*a
else
	min_T = T*(a+1)

print(min_T)

N, X, T = map(int, input().split())

a = N // X
min_T = T*a

print(min_T)

N = input()
X = input()
T = input()

a = N//X
min_T = T*a

print(min_T)

N, X, T = map(int, input().split())

a = N // X
if N%X == 0:
	min_T=T*a
else:
	min_T = T*(a+1)

print(min_T)

Verdicts: Runtime Error

Runtime Error

Wrong Answer

Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n,x,t=map(int, input().split())
print(n//x*t+1)

import math
n,x,t=map(int, input().split())
print(math.ceil(n/x)*t)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import sys
import math


test = sys.stdin

result = math.ceil( test[0] / test[1] ) * test[2]

print(result)

import sys
import math


test = int(stdin.readline().rstrip())

result = math.ceil( test[0] / test[1] ) * test[2]

print(result)


from sys import stdin
from math import ceil

N,X,T = [int(x) for x in stdin.readline().rstrip().split()]

result = ceil( N / X ) * T

print(result)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
I = lambda : list(map(int,input().split()))
h,w,m=I()
x={};y={}
l=[];dic={}
for i in range(m):
  a,b=I()
  l.append([a,b])
  dic[(a,b)]=1
  x[a]=x.get(a,0)+1
  y[b]=y.get(b,0)+1
p,q=max(x.values()),max(y.values())
a,b=[i for i in x if x[i]==p],[i for i in y if y[i]==q]
an=p+q;fl=0
for i in a:
  for j in b:
    if dic.get((i,j),-1)==-1:
      fl=1;break
  if fl:
    break
an-=(fl==0)
print(an)

n,x,t = map(int,input().split())
print((n+x-1)//x*t)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N,M,T=map(int,input().split())
print((N//X)*T+1)

N,X,T=map(int,input().split())
print((N//X)*T+1)

N,X,T=map(int,input().split())
if N%X==0:
  print((N//X)*T)
else:
  print(((N//X)*T)+T)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N ,X, T = map(int,input().split())

if N %X ==0:
	a = N // X + 1
else:
	a = N//X
total = a *T
print(total)


N ,X, T = map(int,input().split())

if N %X ==0:
	a = N // X 
else:
	a = N//X+1
total = a *T
print(total)


Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N,X,T=map(int,input().split())
print(N//X*T)

N,X,T=map(int,input().split())
if N%X!=0:
  print((N//X+1)*T)
else:
  print(N//X*T)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
A,B,C=map(int, input().split())
i,j=divmod(A,B)
if j == 0:
  j=0
ttt=(i+j)*C
print(ttt)

A,B,C=map(int, input().split())
i,j=divmod(A,B)
if j == 0:
  j=0
else:
  j=1
ttt=(i+j)*C
print(ttt)


Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n, x, t = map(int, input().split())
nt = (n + x - 1) / x 
print(int(nt * t))

n, x, t = map(int, input().split())
nt = (n + x - 1) / x 
ans = int(nt) * t
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
probA():
    N, X, T = map(int, input().split())

    t = 0
    while N > 0:
        N //= X
        t += T
    print(t)


def main():
    probA()


if __name__ == '__main__':
    main()


def probA():
    N, X, T = map(int, input().split())

    t = 0
    while N > 0:
        N -= X
        t += T
    print(t)


def main():
    probA()


if __name__ == '__main__':
    main()


Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
def main():
    N = int(input())
    A = list(map(int, input().split()))
    
    m = A[0]
    S = 0
 
    for a in A:
        if m - a > 0:
            S += m - a
        if m < a:
            m = a
    
    print(S)
 
 
if __name__ == "__main__":
    main()

import math

line = input()

strL = line.split()

N = int(strL[0])
X = int(strL[1])
T = int(strL[2])

ans = math.ceil(N/X) * T

print(ans)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
string = input("Enter your input: ")
string = string.split()
n = int(string[0])
x = int(string[1])
t = int(string[2])

if(n%x == 0):
    res = int(n/x) * t
    print(res)
else:
    res = (int(n/x) + 1) * t
    print(res)

string = input("Enter your input: ")

print(string)

string = string.split()


n = int(string[0])
x = int(string[1])
t = int(string[2])

if(n%x == 0):
    res = int(n/x) * t
    print(res)
else:
    res = (int(n/x) + 1) * t
    print(res)

string = input()
string = string.split()
n = int(string[0])
x = int(string[1])
t = int(string[2])

if(n%x == 0):
    res = int(n/x) * t
    print(res)
else:
    res = (int(n/x) + 1) * t
    print(res)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N,X,T=[int(i) fir i in input().split()]
a=divmod(N,X)
x=a[0]
if a[1]<X and a[1] != 0:
  x += 1
print(x*T)

   

N,X,T=[int(i) for i in input().split()]
a=divmod(N,X)
x=a[0]
if a[1]<X and a[1] != 0:
  x += 1
print(x*T)

   


Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n=int(input())
a_list=list(map(int,input().split()))
ans=0
tmp=a_list[0]
for i in range(n-1):
    if tmp>a_list[i+1]:
        #print(tmp,ans)
        ans+=tmp-a_list[i+1]
    else:
        ans+=tmp-a_list[i]
        tmp=a_list[i+1]
print(ans)

N,X,T=map(int,input().split())
a=N//T
if N%T==0:
  print(a*X)
else:
  print(a*X+X)

N,X,T=map(int,input().split())
a=N//X
if N%X==0:
    print(a*T)
else:
    print(a*T+T)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N, X, T = map(int,input().split())

if X != 1:
  print(( N // X ) * T )
else:
  print(( N // X + 1 ) * T )

N, X, T = map(int,input().split())

if N % x == 0:
    print(( N // X ) * T )
else:
    print(( N // X + 1 ) * T )

N, X, T = map(int,input().split())

if N % x == 0
    print(( N // X ) * T )
else:
    print(( N // X + 1 ) * T )

N, X, T = map(int,input().split())

if ( N % x ) == 0:
    print(( N // X ) * T )
else:
    print(( N // X + 1 ) * T )

print(( N // X + 1 ) * T )

N, X, T = map(int,input().split())

if ( N % x )== 0:
    print(( N // X ) * T )
else:
    print(( N // X + 1 ) * T )

N, X, T = map(int,input().split())

if ( N % x ) == 0:
    print(( N // X ) * T )
elif ( N % x ) != 0:
    print(( N // X + 1 ) * T )

print(( N // X + 1 ) * T )


N, X, T = map(int,input().split())

A = N % X

if ( A ) == 0:
    print(( N // X ) * T )
elif ( N % X ) != 0:
    print(( N // X + 1 ) * T )

Verdicts: Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n, x, t = map(int, input().split())
print(n*t/x)

import math
n, x, t = map(int, input().split())
t *= math.ceil(n/x)
print(t)


Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
n, x, t = map(int, input().split())
print(n//x*t)

map(int, input().split())
print((n//x+1)*t)

n, x, t = map(int, input().split())
print((n//x)*t if n%x == 0 else (n//x+1)*t)

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
, X, T = map(int,input().split())
n = 0
total = 0

if N % X == 0:
    n = N / X
    total = n * T
else:
    n = N // X + 1
    total = n * T

print(int(total))

N, X, T = map(int,input().split())
n = 0

if N % X == 0:
    n = N / X
else:
    n = N // X + 1

print(int(n * T))

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
print(0)

n,x,t=map(int,input().split())
if n%x==0:
  print(n*t//x)
else:
  print(((n//x)+1)*t)

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
N, X, T=input().split()
print((int(N)/int(X) + int(N)%int(X))*int(T))

N,X,T = input().split()
M = 1 if int(N)%int(X) else 0
H = int(N)/int(X)
print((int(H) + M)*int(T))

Verdicts: Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
import collections
h, w, m = map(int, input().split())
L_g = []
L_r = []
L = []
for i in range(m):
    a, b = map(int, input().split())
    L_g.append(a)
    L_r.append(b)
    L.append((a, b))
c1 = collections.Counter(L_g)
c2 = collections.Counter(L_r)

L1 = c1.most_common()
L2 = c2.most_common()

s = L1[0][1]
bL1 = []
d = 0
for i in range(len(L1)):
    if L1[i][1] == s:
        bL1.append(L1[i])
        d += 1
        if d == 3:
          break
    else:
        break
s = L2[0][1]
bL2 = []
d = 0
for i in range(len(L2)):
    if L2[i][1] == s:
        bL2.append(L2[i])
        d += 1
        if d == 3:
          break
    else:
        break
bL = []
for i in range(len(bL1)):
    for j in range(len(bL2)):
        bL.append((bL1[i][0], bL2[j][0]))
flag = 0
for e in bL:
    if e not in L:
        bom = e
        flag = 1
        break
if flag == 0:
    bom = bL[0]

t = L1[0][1]+L2[0][1]

if flag == 0:
        t -= 1
print(t)

n,x,t = map(int, input().split())
if n%x == 0:
  print((n//x)*t)
else:
  print((n//x + 1)*t)

Verdicts: Runtime Error

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
# -*- coding: utf-8 -*-
"""
Created on Sat Aug 22 20:59:55 2020

@author: naoki
"""

N,X,T = map(int,input().split())
i=0
time = 0
while N >= X*i:
    time = T*i
    i+=1
    
print(time)
    

# -*- coding: utf-8 -*-
"""
Created on Sat Aug 22 20:59:55 2020

@author: naoki
"""
import sys 

N,X,T = map(int,input().split())

for i in range(N):
    if N<=X*(i+1):
        time = T*(i+1)
        print(time)
        sys.exit
    

# -*- coding: utf-8 -*-
"""
Created on Sat Aug 22 20:59:55 2020

@author: naoki
"""
import sys 

N,X,T = map(int,input().split())

for i in range(N):
    if X*i<N and N<=X*(i+1):
        time = T*(i+1)
        print(time)
        sys.exit
    

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
s = input().split()
N = int(s[0])
X = int(s[1])
T = int(s[2])
if N%X == 0:
  print((N//X)*T)
else:
  print((N/X+1)*T)


s = input().split()

N = int(s[0])
X = int(s[1])
T = int(s[2])

print(((N/X)+1)*T)

s = input().split()
N = int(s[0])
X = int(s[1])
T = int(s[2])
if N%X == 0:
  print((N//X)*T)
else:
  print((N//X+1)*T)


Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: Takahashi loves takoyaki - a ball-shaped snack.  With a takoyaki machine, he can make at most X pieces of takoyaki at a time, taking T minutes regardless of the number of pieces to make.  How long does it take to make N takoyaki?

Submission attempts (in order):
a = input("N X T").split()
n = int(a[0])
x = int(a[1])
t = int(a[2])
ans = (n // x) * t
if n % x > 0:
    ans += t
print(ans)

a = input("").split()
n = int(a[0])
x = int(a[1])
t = int(a[2])
ans = (n // x) * t
if n % x > 0:
    ans += t
print(ans)

Verdicts: Wrong Answer

Accepted