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= raw_input( "N : ")
X= raw_input( "X : ")
T= raw_input( "T : ")
if(N % X == 0):
    print((N // X) * T)
else:
    print(((N // X) *T) + T)

n= raw_input( "N : ")
x= raw_input( "X : ")
t= raw_input( "T : ")
N=int(n)
X=int(x)
T=int(t)
if(N % X == 0):
    print((N // X) * T)
else:
    print(((N // X) *T) + T)

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

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

Verdicts: 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())
if N % T > 0:
  ret = N // T + 1
else:
  ret = N // T
print(ret)

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

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(d) for d in input().split())

print((N // X) * T)

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

import math
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())
times, mod = divmod(N,X)
if mod == 0:
  print(times * T)
else:
  print(times * T + 1)

N,X,T = map(int, input().split())
times, mod = divmod(N,X)
if mod == 0:
  print(times * T)
else:
  print(times * T + 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 = (int(x) for x in input().split())
print(math.ceil((N//X)*T))

import math
N,X,T = (int(x) for x in input().split())
a=math.ceil(N/X)
print(a*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())
a = (n//x + 1)*t
print(a)

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

n,x,t = int(input.split())
a = n//x + 1
print(a)

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

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

i = 0
while x*i>=n:
	i +=1

println(i*x)

n,x,t = map(int,input().split())
i = 0
while x*i<n:
	i +=1
print(i*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(map(int, input().split())) 
s = [0]*(N-1)
 
for n in range(N-1):
  s[n] = A[n] - A[n+1]
  if s[n] <= 0: 
    continue
  else:
    A[n+1] += s[n]

print(sum(int(s)))

N = int(input())
A = list(map(int, input().split())) 
ans = 0
 
for n in range(N-1):
  t = A[n] - A[n+1]
  if t <= 0: 
    continue
  else:
    A[n+1] += t
    ans += t
 
print(ans)

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

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

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,x,t=map(int,input().split())
u=x
v=t
while(x<n):
  x+=u
  a+=v
print(t)

n,x,t=map(int,input().split())
u=t
v=x
while(x<n):
  x+=v
  t+=u
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=map(int,input().split())
print(-n/x*-t)

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

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

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

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

Verdicts: Wrong Answer

Wrong Answer

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):
import math
N,X,T=map(int,input().split(' '))
 
ans=math.ceil(N/X)
print(ans)

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

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

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

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())
l=int(n/x)
if l>n/x:p=l+1
else:p=l
print(p*t)

n,x,t=map(int,input().split())
l=int(n//x)
if n%x>0:p=l+1
else:p=l
print(p*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(t*((n-1)//x+1)

n,x,t = map(int,input().split())
print(t*((n-1)//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):
n, x, t = map(int, input().split())

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

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

print((n//x) * t) if n%x==0 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 = int(input())
X = int(input())
T = int(input())

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

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

if X >= N:
    print(T)
elif 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):
from itertools import product

def add_magic_move(enable_to_move_list):
  ret = list(enable_to_move_list)
  for h, w in enable_to_move_list:
    for target_h, target_w in product([h-1, h, h+1], [w-1, w, w+1]):
      if -1 < target_h < H and -1 < target_w < W and (target_h, target_w) not in enable_to_move_list:
        s[target_h][target_w] = '.'
        ret += [(target_h, target_w)]
  return ret
    

def get_enable_to_move_list(h, w, enable_to_move_list):
  if (h, w) in enable_to_move_list:
    return enable_to_move_list
  enable_to_move_list += [(h, w)]
  targets = ((h+1, w), (h-1, w), (h, w+1), (h, w-1))
  for h, w in targets:
    if -1 < h < H and -1 < w < W and s[h][w] == '.':
      enable_to_move_list = get_enable_to_move_list(h, w, enable_to_move_list)
  return enable_to_move_list

H, W = map(int, input().split())
s_h, s_w = [i-1 for i in map(int, input().split())]
d_h, d_w = [i-1 for i in map(int, input().split())]
s = [list(input()) for i in range(H)]

enable_to_move_list = get_enable_to_move_list(s_h, s_w, [])
i = 0
while True:
  if (d_h, d_w) in enable_to_move_list:
    break
  tmp = add_magic_move(enable_to_move_list)
  i += 1
  for h, w in list(set(tmp) - set(enable_to_move_list)):
  	enable_to_move_list = get_enable_to_move_list(h, w, enable_to_move_list)
  if not set(tmp) ^ set(enable_to_move_list):
    i = -1
    break

print(i)

N, X, T = map(int, input().split())
t = int(N / X) if N % X == 0 else int(N // X + 1)
print(f'{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):
h, w=map(int, input().split())
ch, cw=map(int, input().split())
dh, dw=map(int, input().split())

grid=["0"]*(h+2)
grid[0]="0"*(w+2)
grid[h+1]="0"*(w+2)

for i in range(1, h+1):
    s=input()
    grid[i]= "0"+s+"0"

p=1
road=[[0] * (w+2) for i in range(h+2)]

for i in range(1, h+1):
    for j in range(1, w+1):
        if grid[i][j] == ".":
            for k in range(5):
                flag=0
                if flag == 0 and road[i][j]==0:
                    road[i][j]=p
                if grid[i][j+1] == "." and flag == 1 and road[i][j+1]==0:
                    road[i][j+1]=p
                    flag+=1

                if grid[i][j-1] == "." and flag == 2 and road[i][j-1]==0:
                    road[i][j-1]=p
                    flag+=1

                if grid[i+1][j] == "." and flag == 3 and road[i+1][j]==0:
                    road[i+1][j]=p
                    flag+=1

                if grid[i-1][j] == "." and flag == 4 and road[i-1][j]==0:
                    road[i-1][j]=p
                    flag+=1

    p+=1

print(road)

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

cnt = n//x

if n%x == 0:
    print(cnt*t)
else:
    cnt+=1
    print(cnt*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 sys

data = sys.stdin.read().split()
N = data[0]
X = data[1]
T = data[2]

def takoyaki(N, X, T):
  if N % X==0:
    return T * N / X
  else:
    return T * (N / X + 1)

from sys import stdin
 
data = stdin.read().split()
N, X, T = int(data[0]), int(data[1]), int(data[2])
 
if N % X == 0:
  print(int(T*N/X))
else:
  print(int(T*(N//X+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())

ans = (n // x) * t

print(int(ans))

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

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

print(int(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 = input()

while len(N) > 1:
    M = sum(int(N[i]) for i in range(len(N)))
    N = str(M)

if M == 9 or M == 0:
    print('Yes')
else:
    print('No')


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

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

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

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

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())
print('N',N)
print('X',X)
print('T',T)

print(N//X+1)

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

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

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

Verdicts: Wrong Answer

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())
if n%x==0:
  print(int(n//x)*t)
else:
  print((int(n//x)+1)*t)

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

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(int(n/x)*t)
else:
    print(int(n//x)+1)*t)

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

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_1=sum(A)
count=0
for i in range(0,len(A)-1):
    if A[i]>A[i+1]:
        A[i+1]=A[i]
a_2=sum(A)
print(a_2-a_1)
        
    

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

print((int(n+x-1/x))*k)


n,x,k=map(int,input().split(' '))

print(((n/x)+1))*k)


n,x,k=map(int,input().split(' '))

print(((n/x)+1)*k)


n,x,k=map(int,input().split(' '))

print(int((n+x-1)/x)*k)


Verdicts: Wrong Answer

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

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

print(math.ceil(n/x)*t)



import math

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

print(math.ceil(n/x)*t)

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

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

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

Verdicts: Wrong Answer

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):
import math
N, X, T = map(int, input().split())

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


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

count = N/X
#print(count)
count = math.ceil(count)
print(count * 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())
for i in range(1,1000):
    if i*X<N:
        i = i+1
    else :
        print(i*T)

import sys
N,X,T=map(int,input().split())
for i in range(1,1001):
  if X*i>=N:
    print(i*T)
    sys.exit()
  

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())
r=math.ceil(n/x)*t
print(r)

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

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

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):
a=int(input())
b=int(input())
c=int(input())

if a%b==0:
	print(c*(a/b))
else:
		print((c*((a//b)+1)))

a = list(map(int, input().split()))
if a[0]%a[1]==0:
  print((a[0]//a[1])*a[2])
else:
  print(a[2]*(a[0]//a[1])+a[2])

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

for i in range(1,1000000):
    if N < X:
        print(T*i)
        exit()
    else:
        N = N-X
        if N < X:
        	print(T*i)
        	exit()

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

for i in range(1,1000000):
  if test <= X:
    print(T*i)
    exit()
  test -= 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())
c=N%X
print(c*T+T)

    print(c*T+T)


N, X, T= map(int, input().split())
c=int(N/X)
if N%X == 0:
    print(c*T)
else:
    print(c*T+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):
N, X, T = map(int, input().split())

m = N//X
ans = m * T
print(ans)  

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

ans = 0
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):
N=int(input())
A=list(map(int, input().split()))
B=A
M=max(A)
k=0
Fumi=0

for k in range(1,N):
    if A[k-1]>A[k]:
        Fumi=Fumi+A[k-1]-A[k]
        A[k]=A[k-1]
    k=k+1

print(Fumi)

N, X, T = input().strip().split()
N, X, T = [int(N), int(X), int(T)]

q=N // X
mod = N % X

if mod != 0:
 q = q + 1

time = T*q

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

line = input()

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

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

print(ans)

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: 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: 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(ceil(n/x)*t)


from math import ceil
n, x, t = map(int, input().split())
print(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):
input1 = input()
input1 = input1.split()
N, X, T = int(input1[0]), int(input1[1]), int(input1[2])
result = int((N*T)/X)
print(result)

input1 = input()
input1 = input1.split()
N, X, T = int(input1[0]), int(input1[1]), int(input1[2])
result = int((N*T)/X)
print(result)

input1 = input()
input1 = input1.split()
N, X, T = int(input1[0]), int(input1[1]), int(input1[2])
t = 0
while(N>0):
    N = N - X
    t += T
print(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):
line = input().split()
n = int(line[0])
x = int(line[1])
t = int(line[2])
print(-(n//x)*t)

line = input().split()
n = int(line[0])
x = int(line[1])
t = int(line[2])
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):
N=int(input())
A=list(map(int,input().split()))

ans=sum(A)
s=N+1
j=s

if A==sorted(A):
    print(0)
    exit()

for i in range(N//2):
    x=max(A[:s])
    s=A.index(x)
    A[s:j]=[x]*len(A[s:j])
    j=s
    if  A==sorted(A):
        break

print(sum(A)-ans)

N,X,T=map(int,input().split())
if N%X==0:
    ans=T*(N//X)
else:
    ans=T*((N//X)+1)
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):
n,x,t=map(int(input().split()))
count=0
if(n<=x):
  print(t,end='\n')
else:
  while(x>=n):
    count=count+1
    x=x+x
print((count+1)*t)

n,x,t=map(int,input().split())
count=0
a=0
a=x
if(n<=x):
        print(t,end='\n')
        
elif(x==1):
        print((n)*t)
else:    
    while(x<n):
        count=count+1
        x=x+a    
    print((count+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()))

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


# ABC176A

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

print(-(-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(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 = list(input())
m=0
for i in range(1, len(n)):
    m+=i
if m%9==0:
    print("Yes")
else:
    print("No")


n,m,t =int(input())

z = (n+m-1)/m

ans = z * t

print(ans)

n, m, t = input().split()
z = ((int(n)+int(m))-1)//int(m)
ans = z * int(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):
def calculate(N,X,T):
    times = round(N/X)
    if times==0 :
        print(T)
    else :
        print(times * T)

def calculate(N,X,T):
    x = N // X
    if x ==0:
        return T
    elif not N % X == 0:
        return (x + 1)*T;
    else:
        return x*T
N,X,T = 100,20,30
result = calculate(N,X,T)
print(result)

N,X,T = 100,20,30
N/X * T

N/X * T

def calculate(N,X,T):
    x = N // X
    if x ==0:
        return T
    elif not N % X == 0:
        return (x + 1)*T;
    else:
        return x*T

def calculate(N,X,T):
    return N/X * T

def calculate(N,X,T):
    print(round(N/X * T))

def calculate(N,X,T):
    x = N // X
    if x ==0:
        return T
    elif not N % X == 0:
        return (x + 1)*T;
    else:
        return x*T
N,X,T = 100,20,30
result = calculate(N,X,T)
print(result)

def calculate(N,X,T):
    x = N // X
    if x ==0:
        return T
    elif not N % X == 0:
        return (x + 1)*T;
    else:
        return x*T

def calculate(N,X,T):
    x = N // X
    if x ==0:
        return T
    elif not N % X == 0:
        return (x + 1)*T;
    else:
        return x*T
N,X,T = 100,20,30
result = calculate(100,20,30)
print(result)

def calculate(N,X,T):
    x = N // X
    if x ==0:
        return T
    elif not N % X == 0:
        return (x + 1)*T;
    else:
        return x*T
N,X,T = map(int,input().split())
result = calculate(N,X,T)
print(result)

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Runtime Error

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

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)
if N//X<N/X<N//x+1:
  print((N//X+1)*T) 
else:
  print(N/X*T)

N,X,T=map(int,input().split())
if N//X<N/X<N//X+1:
  print((N//X+1)*T) 
else:
  print(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 main():
  n, x, t = map(int, input().split())
  times = n//x
  amari = n%x
  minutes = times * t
  if amari ==0:
    return print(minutes)
  else:
    return print(minutes + 1)

main()

def main():
  n, x, t = map(int, input().split())
  times = n//x
  amari = n%x
  minutes = times * t
  if amari ==0:
    return print(minutes)
  else:
    return print(minutes + t)

main()

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):
x=input().split()

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


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






x=input().split()

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

print(k*ceil(20/12))

x=input().split()

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


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






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=map(int,input().split())
ans=0
ans=(n/x+1)*t
print(ans)

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

import math
n,x,t=map(int,input().split())
A=math.ceil(n/x)
print(A*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]=list(map(int,input().split()))
kaisu=n//x+1
if n%x!=0:
    kaisu+=1
ans=kaisu*t
print(ans)

[n,x,t]=list(map(int,input().split()))
kaisu=n//x
if n%x!=0:
    kaisu+=1
ans=kaisu*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 = input().split()
n=int(n)
x=int(x)
t=int(t)
print(n,x,t)
if(n%x==0):
    print((n // x)*t)
else:
    print(((n // x )+ 1)*t)

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

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())
print((n + x - 1 // x) * 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)

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

from math import ceil
time = ceil(t/n) * x
print(time)


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

from math import ceil
time = ceil(n/x) * 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())
a = n/x
if n % x == 0:
  print(a*t)
else:
  print((a + 1)*t


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

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

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

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 = input( " N : ")
X =input( "X : ")
T=input("T :")
if(N % X == 0):
    print((N // X) * T)
else:
    print(((N // X) + 1) * T)


def Takoyaki(N , X ,T):
        if N%X != 0:
            print(N/X * T +T)
        else:
            print(N/X * T)
Takoyaki(20 , 12 , 6)

N, X, T = (int(x) for x in input().split())
if(N % X == 0):
    print((N // X) * T)
else:
    print(((N // X) + 1) * 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(' '))

print(int(T*N/X))

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

if N%X == 0:
  print(int(N//X*T))
else:
  print(int(N//X*T+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
from collections import deque

H,W = map(int, input().split())
ch,cw = map(int,input().split())
dh,dw = map(int, input().split())

#input maze information
s = ["#"*(W+4)]
s.append("#"*(W+4))
for i in range(H):
    s.append("##"+input()+"##")
s.append("#"*(W+4))
s.append("#"*(W+4))

ans = [[-1]*(W*4) for _ in range(H+4)]
for i in range(H+4):
    for j in range(W+4):
        if s[i][j] == "#":
            ans[i][j] = -2 

ch += 1
cw += 1
dh += 1
dw += 1
ans[ch][cw]=0

move = [[-1,0],[1,0],[0,1],[0,-1]]
magic = [
    [-2,-2],[-2,-1],[-2,0],[-2,1],[-2,2],\
    [-1,-2],[-1,-1],[-1,0],[-1,1],[-1,2],\
    [0,-2],[0,-1],[0,0],[0,1],[0,2],\
    [1,-2],[1,-1],[1,0],[1,1],[1,2],\
    [2,-2],[2,-1],[2,0],[2,1],[2,2]
    ]

list1=deque([])
list2=deque([])
list1.append([ch,cw])

while len(list1)>0:
    x,y = list1.popleft()
    list2.append([x,y])
    for p,q in move:
        v1,v2 = x+p,y+q
        if ans[v1][v2] == -1:
            list1.append([v1,v2])
            ans[v1][v2] = ans[x][y]
    if len(list1)==0:
        while len(list2) > 0:
            x2,y2 = list2.popleft()
            for v1,v2 in magic:
                i,j = x2+v1,y2+v2
                if ans [i][j] == -1:
                    ans[i][j] = ans[x2][y2]+1
                    list1.append([i,j])
print(ans[dh][dw])



from enum import Enum
from queue import Queue
import collections

import sys
import math

BIG_NUM = 2000000000
MOD = 1000000007
EPS = 0.000000001
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())
time=(n/x+1)*t
print(time)

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

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

b = a[0] // a[1]
c = a[0] % a[1]
ans = (b + c) * a[2]
print(str(ans))


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

b = a[0] // a[1]
c = a[0] % a[1]
if c != 0:
    c = 1
ans = (b + c) * a[2]
print(str(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
import math

def main(lines):
  line=lines.split()
  n = int(line[0])
  x = int(line[1])
  t = int(line[2])
  ans = math.ceil(n/x)*t
  print(ans)

if __name__ == '__main__':
    lines = []
    for l in sys.stdin:
        lines.append(l.rstrip('\r\n'))
    main(lines)


import sys

def main(lines):
  line=lines[0].split()
  n = int(line[0])
  x = int(line[1])
  t = int(line[2])
  ans = math.ceil(n/x)*t
  print(ans)

if __name__ == '__main__':
    lines = []
    for l in sys.stdin
        lines.append(l.rstrip('\r\n'))
    main(lines)


import sys

def main(lines):
  line=lines[0].split()
  n = int(line[0])
  x = int(line[1])
  t = int(line[2])
  ans = math.ceil(n/x)*t
  print(ans)

if __name__ == '__main__'
    lines = []
    for l in sys.stdin
        lines.append(l.rstrip('rn'))
    main(lines)


import sys

def main(lines):
  line=lines[0]

if __name__ == '__main__':
    lines = []
    for l in sys.stdin
        lines.append(l.rstrip('\r\n'))
    main(lines)


import sys

def main(lines):
  line = lines.split()
  n = int(line[0])
  x = int(line[1])
  t = int(line[2])
  ans = math.ceil(n/x)*t
  print(ans)
if __name__ == '__main__'
    lines = []
    for l in sys.stdin
        lines.append(l.rstrip('rn'))
    main(lines)


import sys

def main(lines):
  line=lines[0].split()
  n = int(line[0])
  x = int(line[1])
  t = int(line[2])
  ans = math.ceil(n/x)*t
  print(ans)

if __name__ == '__main__':
    lines = []
    for l in sys.stdin:
        lines.append(l.rstrip('\r\n'))
    main(lines)


import sys

def main(lines):
  line=lines

if __name__ == '__main__':
    lines = []
    for l in sys.stdin:
        lines.append(l.rstrip('\r\n'))
    main(lines)


import sys
import math

def main(lines):
    line=lines.split()
    n = int(line[0])
    x = int(line[1])
    t = int(line[2])
    ans = math.ceil(n/x)*t
    print(ans)

if __name__ == '__main__':
    lines=input()
    main(lines)


Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

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):
x,n,t = map(str,input().split(" "))
cnt =0
while (x > 0):
    x -= n
    cnt += 1
print(cnt * t)

answer = 0
n = int(input())
a = list(map(int, input().split(" ")))
for i in range(n - 1):
    a = sorted(a[:5], key=a[:5].count, reverse=True) + a[5:]
    if a[0] == a[1] == a[2]:
        answer += 1
    	del a[:3]

if a[0] == a[1] == a[2]:
    answer += 1

print(answer)

x,n,t = map(str,input().split())
cnt =0
while x > 0:
    x -= n
    cnt += 2
print(cnt * t)

x,n,t = map(int,input().split(" "))
cnt =0
while x > 0:
    x -= n
    cnt += 1
print(cnt * t)

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

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

print(ans)

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

if n % x == 0:
  ans = (n // x) * t
else:
  ans = (n // x + 1) * 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):
from collections import deque


def solvemaze(y, x, num):
    maps.append([])
    dx, dy = (-1, 0, 1, 0), (0, -1, 0, 1)
    maze[y][x] = num
    que = deque()
    que.append((y, x))
    while que:
        y_, x_ = que.popleft()
        maps[num].append((y_, x_))
        for i in range(4):
            y2 = y_ + dy[i]
            x2 = x_ + dx[i]
            if 0 <= y2 < h and 0 <= x2 < w and maze[y2][x2] == '.':
                maze[y2][x2] = num
                que.append((y2, x2))

def makeroute(s_maps, num):
    for y, x in s_maps:
        for i in range(-2, 3):
            for j in range(-2, 3):
                y2 = y + i
                x2 = x + j
                if 0 <= y2 < h and 0 <= x2 < w:
                    num2 = maze[y2][x2]
                    if not  num2 in [0, '#'] + E[num]:
                        E[num].append(num2)
                        E[num2].append(num)
    

h, w = map(int, input().split())
Ch, Cw = map(int, input().split())
Dh, Dw = map(int, input().split())
maze = [[x for x in input()] for _ in range(h)]
maps = []

num = 0
for i in range(h):
    for j in range(w):
        if maze[i][j] == '.':
            solvemaze(i, j, num)
            num += 1

E = [[] for _ in range(num)]
for i in range(num):
    makeroute(maps[i], i)

s = maze[Ch-1][Cw-1]
g = maze[Dh-1][Dw-1]
used = [False] * num
used[s] = True
que = deque()
que.append((0, s))
cost = [float('inf')] * num
cost[s] = 0
while que:
    c, v = que.popleft()
    for e in E[v]:
        if not used[e]:
            que.append((c+1, e))
            cost[e] = c+1
            used[e] = True

if not used[g]:
    print(-1)
else:
    print(cost[g])

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):
import math
N, X, T = (int(x) for x in input().split())
t = (N / X)*T
print(math.ceil(t))

import math
N, X, T = (int(x) for x in input().split())
t = math.ceil(N / X)
print(t*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)

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

n, x, t = map(int, input().split())
import math
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 = list(map(int, input().split()))

print(t*n//x)


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

print(n//x*t)


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

import math
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):
h,w,m = map(int,input().split())
row = [0]*(h+1)
col = [0]*(w+1)
bombs = set([])
for i in range(m):
  a,b = map(int,input().split())
  row[a] += 1
  col[b] += 1
  bombs.add((a,b))
r,c = max(row),max(col)
rcnt,ccnt = 0,0
for v in row:
  if v==r:
    rcnt += 1
for v in col:
  if v==c:
    ccnt += 1
doubled = 0
for i,j in bombs:
  if row[i]==r and col[j]==c:
    doubled += 1
if doubled==rcnt*ccnt:
  print(r+c-1)
else:
  print(r+c)

n,x,t = map(int,input().split())
print(-(-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//x) * t)

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

print(((n+x-1)//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())
print(t * (n + (x - 1)) // x)

n, x, t = map(int, input().split())
if n % x == 0:
    print(t * (n // x))
else:
    print(t * (n // x + 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=int(input())
arr=list(map(int,input().split()))
ans=0
for i in range(1,n):
	if(arr[i]<arr[i-1]):
		ans+=arr[i-1]-arr[i]
		arr[i]+=arr[i-1]-arr[i]
		
print(ans)
	


n,x,t=map(int,input().split())
ans=0;
while(n>0):
	ans+=t;
	n-=x;
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):
n, x, t = map(int, input().split())
cnt = n/x
if n%x > 0:
    cnt += 1
print(int(cnt*t))

n, x, t = map(int, input().split())
cnt = n // x
if n % x > 0:
    cnt += 1
print(int(cnt*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 = input()
S = math.ceil(N/X)
Ans = S * T
print(Ans)

import math
N, X, T = map(int, input().split())
S = math.ceil(N/X)
Ans = S * 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):
d, t, s = map(int, input().split())

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

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

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

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())
print(int(-(-N/X)*T))


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


Verdicts: Wrong Answer

Wrong Answer

Accepted