TnT/Multi_CodeNet4Repair huggingface dataset:
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
import sys
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits


def input(): return sys.stdin.readline().strip()


def INT(): return int(input())


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


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


sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

a,b,t=MAP()

print(int((t+0.5)/a)*b)
                                                                                    
                                                                            32,0-1       全て


import sys
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits


def input(): return sys.stdin.readline().strip()


def INT(): return int(input())


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


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


sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

a,b,t=MAP()

print(int((t+0.5)/a)*b)


Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t = map(int,input().split())
c =(t+0.5)//a
print(c*b)

a,b,t = map(int,input().split())
print((t+0.5)//a*b)

a,b,t = map(int,input().split())
print((t//a)*b)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):

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



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


Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

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

out = (T / A) * B

print(int(out))

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

A = input[0]
B = input[1]
T = input[2]

out = (T / A) * B

print(out)


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

A = input[0]
B = input[1]
T = input[2]

out = (T / A) * B

print(out,end='')


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

out = (T / A) * B

print(int(out))

A, B, T = list(map(int,input().split()))
T+=0.5
out = T // A * B
print(int(out))

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A, B, T = map( int, input().split() )
print( (T + 0.5) // A * B )

import math
A, B, T = map( int, input().split() )
print( math.floor( (T + 0.5) / A ) * B )

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
N=int(input())
V=list(map(int,input().split()))
C=list(map(int,input().split()))
ans=0
for i in range(N):
  if V[i]-C[i] >0:
    ans+=V[i]-C[i]
print(ans)


A,B,T=map(int,input().split())
print(int(B*((T+0.5)//A)))

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
N=int(input())
V=[int(i) for i in input().split()]
C=[int(i) for i in input().split()]
n=0
for j in range(N):
 k=V[j]-C[j]
 if k>0:
   n+=k
print(n)

N=int(input())
V=[int(i) for i in input().split()]
C=[int(i) for i in input().split()]
n=0
for j in range(N):
   k=V[j]-C[j]
   if k>0:
      n+=k
print(n)

A=[int(i) for i in input().split()] #A=A[0] B=A[1] T=A[2]
n=A[2]//A[0]*A[1]
print(n)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

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

print(int((T+0.5)/A * B))

A, B, T = map(int, input().split())

print(int((T+0.5)/A) * B)

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t=map(int,input().split())
cnt=0
for i in range(1,t+1,a):
    cnt+=b
print(cnt)

a,b,t=map(int,input().split())
cnt=0
for i in range(1,t+0.5,a):
    cnt+=b
print(cnt)

a,b,t=map(int,input().split())
cnt=0
for i in range(a,t+1,a):
    cnt+=b
print(cnt)

Verdicts: Wrong Answer

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
import fractions
N = int(input())
l = list(map(int,input().split()))

if len(l) == 2:
    memo = max(l)
else:
    memo = 1
    for i in range(N):
        g = fractions.gcd(*(l[:i]+l[i+1:]))
        if g > memo:
            memo = g

print(memo)

A,B,T = map(int,input().split())
print(int(((T+0.5)//A)*B))

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

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

A, B, T = map(int,input().split())
print(int(int(T / A) * B))

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

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

a,b,t=map(int,input().split())
print(t//a*b)

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
N = int(input())
a = list(map(int,input().split()))
err = 8
ma1 = [1]
def gcd(x, y):
    if y == 0:
        return x
    else:
        return gcd(y, x % y) 
for i in range(1,N):
    f = gcd(a[0],a[i])
    for j in range(1,N):
        if a[j]%f != 0:
            err = err + 1
        if err == 10:
            break
    if err < 10:
        ma1.append(f)
arr = 8
ma2 = [1]

tmp = a[N-1]
a[N-1]=a[0]
a[0]=tmp


for i in range(1,N):
    f = gcd(a[0],a[i])
    for j in range(1,N):
        if a[j]%f != 0:
            arr = arr + 1
        if arr == 10:
            break
    if arr < 10:
        ma2.append(f)



if max(ma2) > max(ma1):
    print(max(ma2))
else:
    print(max(ma1))

a = list(map(int, input().split()))
num = int(a[2]/a[0])
print(a[1]*num)

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
# -*- coding: utf-8 -*-

a, b, c = map(int, input().split())
int(b * ((t+0.5)//a))

# -*- coding: utf-8 -*-
a, b, c = map(int, input().split())
print(int(b * ((t+0.5)//a)))

# -*- coding: utf-8 -*-
import math

a, b, c = map(int, input().split())
b * math.floor((t+0.5)/a)

# -*- coding: utf-8 -*-
a, b, t = map(int, input().split())
print(int(b * ((t+0.5)//a)))

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
n = int(input())
A = list(map(int,input().split()))
gcd_list = []
max_element = max(A)

def gcd(a, b):
    while a % b != 0:
        b_next = a % b
        a = b
        b = b_next
    return b

for i in range(n):
    y = A[i]
    for j in range(1, max_element + 1):
        A[i] = j
        x = A[0]
        for k in range(1, n):
            x = gcd(x, A[k])
        gcd_list.append(x)
    A[i] = y
print(max(gcd_list))


n = int(input())
V = list(map(int,input().split()))
C = list(map(int,input().split()))
goods_list = []
for i in range (n):
    x = V[i] - C[i]
    if x > 0:
        goods_list.append(x)
print(sum(goods_list))


from math import floor
a, b, t = map(int,input().split())
num = floor(t / a)
print(num * b)


Verdicts: Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

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

num = T + 0.5 // A

print(num * B)


A, B, T = map(int, input().split())
 
num = (T + 0.5) // A
 
print(int(num * B))

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
def gcd(a,b):
    if b>a:
        a,b=b,a
    while b:
        a,b=b, a%b
    return a


def cul(n,x):
    l=len(x)
    b=[x[i] for i in range(l)]
    b.pop(n)
    tmp=b[0]
    for i in range(1,l-1):
        tmp=gcd(tmp,b[i])
    return tmp

import sys
import math
p=10
N=int(input())
a=list(map(int,input().split()))
if N<=p:
    ans=0
    
    for i in range(N):
        tmp=cul(i,a)        
        if tmp>ans: ans=tmp
    print(ans)
    sys.exit()
        
M=a[0]
for i in range(1,p):
    M=gcd(M,a[i])

ans=0
for i in range(1,math.ceil(M**0.5)+1 ):
    if M%i==0:
        cnt=0
        for j in range(p,N):
            if a[i]%i!=0:
                cnt+=1
                if cnt==2: break
            elif i==N-1 and i>ans: ans=i
        
        x=M//i
        cnt=0
        for j in range(p,N):
            if a[i]%x!=0:
                cnt+=1
                if cnt==2: break
            elif i==N-1 and x>ans: ans=x



print(ans)

A,B,T=map(int,input().split())
print(T//A*B)

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t = map(int,input().split())
sum = 0
sum = ((t + 0.5)//a )* b
print(sum)

a,b,t = map(int,input().split())
sum = 0
sum = (int)((t + 0.5)//a )* b
print(sum)

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
# import math
import fractions
import numpy as np
from itertools import accumulate, chain, islice, starmap
N = int(input())
numbers = list(map(int, input().split()))
# numbers = [2, 4, 8, 8]
# N = len(numbers)


def calculate_maximum_subgcd_with_np_ufunc(numbers):
    gcd = np.frompyfunc(fractions.gcd, 2, 1)
    cumgcds = gcd.accumulate(numbers, dtype=np.object).astype(np.int)
    sub_cumgcds = np.roll(cumgcds, 1)
    sub_cumgcds[0] = 0
    reverse_cumgcds = gcd.accumulate(
        numbers[::-1], dtype=np.object).astype(np.int)
    sub_reverse_cumgcds = np.roll(reverse_cumgcds, 1)
    sub_reverse_cumgcds[0] = 0
    return np.max(gcd(sub_cumgcds, sub_reverse_cumgcds[::-1]))


def calculate_maximum_subgcd_with_func(numbers):
    operation = fractions.gcd
    cumgcds = accumulate(numbers, operation)
    sub_cumgcds = islice(chain([0], cumgcds), len(numbers))
    reverse_cumgcds = accumulate(numbers[::-1], operation)
    sub_reverse_cumgcds = islice(chain([0], reverse_cumgcds), len(numbers))
    sub_gcds = starmap(operation, zip(sub_cumgcds, list(sub_reverse_cumgcds)[::-1]))
    return max(sub_gcds)


calculate_maximum_subgcd = calculate_maximum_subgcd_with_np_ufunc
# calculate_maximum_subgcd = calculate_maximum_subgcd_with_func

print(calculate_maximum_subgcd(numbers))


A, B, T = map(int, input().split())
# A, B, T = 20, 20, 19


def count_total_biscuit(A, B, T):
    return (T // A) * B


print(count_total_biscuit(A, B, T))


Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
line = list(map(int,input().split()))
print(line)
a = (line[2] // line[0]) * line[1]
print(a)

line = list(map(int,input().split()))
a = (line[2] // line[0]) * line[1]
print(a)

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t=map(int, input().split())
print int((t+0.5)/a*b)

a,b,t=map(int, input().split())
print(int((t+0.5)/a)*b)

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
import fraction
from functools import reduce

def gcd(*numbers):
    return reduce(fraction.gcd, numbers)

def gcd_list(numbers):
    return reduce(fraction.gcd, numbers)

N = int(input())
A = (input()).split()
# N = int('2')
# A = ('1000000000 1000000000').split()
A = [int(a) for a in A]
max=0

for i in range(N):
    B = A.copy()
    del B[i]
    for j in range(N-1):
        if max < gcd(*B):
            max = gcd(*B)
            
print(max)


import fractions
from functools import reduce

def gcd(*numbers):
    return reduce(fractions.gcd, numbers)

def gcd_list(numbers):
    return reduce(fractions.gcd, numbers)

N = int(input())
A = (input()).split()
# N = int('2')
# A = ('1000000000 1000000000').split()
A = [int(a) for a in A]
max=0

for i in range(N):
    B = A.copy()
    del B[i]
    for j in range(N-1):
        if max < gcd(*B):
            max = gcd(*B)
            
print(max)


import fraction
from functools import reduce

def gcd(*numbers):
    return reduce(math.gcd, numbers)

def gcd_list(numbers):
    return reduce(math.gcd, numbers)

N = int(input())
A = (input()).split()
# N = int('2')
# A = ('1000000000 1000000000').split()
A = [int(a) for a in A]
max=0

for i in range(N):
    B = A.copy()
    del B[i]
    for j in range(N-1):
        if max < gcd(*B):
            max = gcd(*B)
            
print(max)


A_B_T = input()
A = int(A_B_T.split()[0])
B = int(A_B_T.split()[1])
T = int(A_B_T.split()[2])

print(int((T + 0.5) // A * B))

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
x = input()
x = x.split(" ")
a = x[0]
b = x[1]
c = x[2]
n = c // a 
return(n * b)

x = input()
x = x.split(" ")
a = x[0]
b = x[1]
c = x[2]
n = c // a 
print(n * b)

x = input()
x = x.split(" ")
a = int(x[0])
b = int(x[1])
c = int(x[2])
n = c // a 
print(n * b)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t=map(int,input().split())
ans=0
ans=(((t+0.5)//a)*b
print(int(ans))

a,b,t=map(input().split())
ans=0.0
ans=int(((t+0.5)//a)*b)
print(ans)

a,b,t=map(input().split())
ans=0
ans=int(((t+0.5)//a)*b)
print(ans)

n=int(input())
xlist=[]
ylist=[]
v=list(map(int,input().split()))
c=list(map(int,input().split()))
for i in range(n):
  if v[i]>c[i]:
    xlist.append(v[i])
    ylist.append(c[i])
ans=sum(xlist)-sum(ylist)
print(ans)

a,b,t=map(int,input().split())
ans=int(((t+0.5)//a)*b)
print(ans)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A, B, T = map(int, input().split())
T += 0.5
print(int(T/A*B)


A, B, T = map(int, input().split())
T += 0.5
print(int(T//A*B))


Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a, b, c = map(int, inpuit().split())
print((c//a)*b)

a, b, c = map(int, input().split())
print((c//a)*b)


Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

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

print(int(B* T//A))

A, B, T = map(int, input().split())

print(int(B* (T//A)))



Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
import math

A,B,T = map(int,input().split())

freq = math.floor(((T+0.5)/A))

print(A*freq)

import math

A,B,T = map(int,input().split())

freq = math.floor(((T+0.5)/A))
print(B*freq)

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,c=map(int,input().split())
d=0
e=1
while 1:
  if c+0.5>a:
    a*=e
    e+=1
    d+=b
  else:
    break
print(d)
  


a,b,c=map(int,input().split())
c+=0.5
print(int(c/a*b))

a,b,c=map(int,input().split())
d=0
e=1
while 1:
  if c+0.5<a:
    a*=e
    e+=1
    d+=b
  else:
    break
print(d)
  

a,b,c=map(int,input().split())
d=0
f=0
e=1

while 1:
  
  f=a*e
  if c+0.5>=f:
    e+=1
    
    d+=b
  else:
    break
print(d)
  


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
mport math 

a,b,c= input().split()
x,y,z=(int(a),int(b),int(c))
p = math.floor(z / x)
print(int(p * y))


import math 

a,b,c= input().split()
x,y,z=(int(a),int(b),int(c))
p = math.floor(z / x)
print(int(p * y))

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
import numpy as np
 
N = input()
A = np.array([int(x) for x in input().split(" ")])

if len(np.where(A>0)[0])%2 == 0:
  print(np.abs(A).sum())
else:
  print(np.abs(A).sum() - np.abs(A).min()*2)

a, b, t = [int(x) for x in input().split(" ")]

mul = (t + 0.5) // a

print(int(b * mul))

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A, B, T = int(sys.stdin.readline().strip())
return T // A * B

import sys 
A, B, T = list(map(int, sys.stdin.readline().strip().split()))
print(T // A * B)


Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t = map(int, input().split())
print(((t+0.5)//a)*b)

a,b,t = map(int, input().split())
print(int(((t+0.5)//a)*b))

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
import itertools
n = int(input())
v = list(map(int, input().split()))
c = list(map(int, input().split()))

lv = []
lc = []
diff = []
for i in range(1,n+1):
    for p in itertools.combinations(v,i):
        lv.append(sum(p))
    for p in itertools.combinations(c,i):
        lc.append(sum(p))
for i in range(len(lv)):
    diff.append(lv[i]-lc[i])
print(0 if max(diff)<0 else max(diff))


a,b,t = map(int, input().split())

print(int((t+0.5)//a*b))

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
N = int(input())
C = list(map(int, input().split()))
V = list(map(int, input().split()))
sum = 0
for i in range(N):
    sum += max(0, V[i]-C[i])
print(sum)

A,B,C = map(int, input().split())
print(round(C/A*B))

A,B,C = map(int, input().split())
print(round((C+0.5)/A*B))

A,B,C = map(int, input().split())
print(round(C//A*B))

Verdicts: Runtime Error

Wrong Answer

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A, B, T = map(int, input().split())
cnt = 0

for i in range(0, T+0.5, A):
  cnt += B
print(cnt)

A, B, T = map(int, input().split())

print(int(((B/A)*T)))

A, B, T = map(int, input().split())

print(int(B/A) * T)


A, B, T = map(int, input().split())

print( (T+1//A) * B)


A, B, T = map(int, input().split())

print(int(B/A * (T + 0.5)))


A, B, T = map(int, input().split())

print(int(B/A * T))


A, B, T = map(int, input().split())

print( (T//A) * B)


Verdicts: Runtime Error

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
# -*- coding: utf-8 -*-

N = int(input())
V = map(int, input().split())
C = map(int, input().split())

gain = 0
for i in range(0,N):
    if(V[i]>C[i]):
        gain += V[i] - C[i]

print(gain)

a,b,t=map(int,input().split())
print((a//t)*b)

a,b,t=map(int,input().split())
print((t//a)*b)

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t=map(int,input().split());print((t+0.5)//a*b)

a,b,t=map(int,input().split());print(int((t+0.5)//a*b))

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t=map(int,input().split())
print(int(((t+0.5)//a*b))

a,b,t=map(int,input().split())
print((t+0.5)//a*b)

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

Verdicts: Runtime Error

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A, B, T = [input(), input(), input()]

print( B * int((T + 0.5)/A) )


print( B * int((T + 0.5)/A) )

A, B, T = map(int, input().split())

print( B * int((T + 0.5)/A) )

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A, B, T = map(int, input().split())
ans = ((T + 0.5) // A) * B
print(ans)

A, B, T = map(int, input().split())
ans = ((T + 0.5) // A) * B
print(int(ans))

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

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

print(a + b * t)

a, b, t = map(int, input().split())

print(a // t * b)

a, b, t = map(int, input().split())

print(t // a * b)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
from functools import reduce

d = {}


def gcd(a, b):
    if (a, b) in d:
        return d[(a, b)]
    else:
        while b != 0:
            a, b = b, a % b
        d[(a, b)] = a
    return a


def gcd_list(numbers):
    return reduce(gcd, numbers)


N = int(input())
A = [int(a) for a in input().split()]

max_ = 0
for i in range(1, len(A) + 1):
    num = gcd_list(A[:i-1] + A[i:])
    if max_ < num:
        max_ = num

print(max_)


A, B, T = map(int, input().split())

ans = 0
s = 1
while True:
    if s % A == 0:
        ans += B
    s += 1
    if s > T + 0.5:
        break

print(ans)

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a, b, t = map(int, input().split())
return (t % a) * b

a, b, t = map(int, input().split())
print( (t//a)*b)

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t = list(map(int,input().split()))
printf(t//a * b)

a,b,t = list(map(int,input().split()))
print(t//a * b)

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
import numpy as np
import copy

N = int(input())
A = [int(i) for i in input().split()]
A = list(set(A))

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

if N==2:
    print(max(A))
else:
    gcds = []
    for i in range(len(A)-1):
        if i == 0:
            gcds.append(gcd(A[0],A[1]))
        else:
            gcds.append(gcd(gcds[-1],A[i]))
    gcds = np.asarray(gcds)
    
    index = []
    for idx,n in enumerate(gcds.min() == gcds):
        if n==True:
            index.append(idx)
    a = []
    for i in index:
        if i+1 in index:
            None
        else:
            a.append(i+1)
    for i in a:
        index.append(i)
    gcds = []
    for idx in index:
        A_temp = copy.deepcopy(A)
        A_temp.pop(idx)
        gcds_temp = []
        for i in range(len(A_temp)-1):
            if i ==0:
                gcds_temp.append(gcd(A_temp[0],A_temp[1]))
            else:
                gcds_temp.append(gcd(gcds_temp[-1],A_temp[i]))
        gcds.append(min(gcds_temp))
    print(max(gcds))


import math
[A,B,T] = [int(i) for i in input().split()]
print(B * math.floor(T  / A ))

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
n = input().split()
ans = int( int(n[2]+0.5) / n[1]   ) * n[1]
print(ans)

n = input().split()
print(int((n[2] + 0.5 ) / n[0]) * n[1])

n = input().split()
ans = int( (int(n[2]) + 0.5) / int(n[0])) * int(n[1])
print(ans)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
import math

n = int(input())
a = list(map(int, input().split()))
max = 0

for i in range(n):
    if i == 0:
        b = a[1:]
    elif i == n-1:
        b = a[:n-1]
    else:
        tmp1 = a[:i]
        tmp2 = a[i+1:]
        b = []
        b.extend(tmp1)
        b.extend(tmp2)
    current = b[0]
    for j in range(n-1):
        current = math.gcd(current, b[j])
    if max < current:
        max = current
print(max)


a, b, t = map(int, input().split())
times = t // a
print(times*b)


Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a, b, c = map(int,input().split())
print((c+0.5)//a*b)

# AtCoder
a, b, c = map(int, input().split())
print(int((c+0.5)//a*b))


Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
###
### atcorder test program
###

### math class
class math:
    ### GCD
    def gcd(self, a, b):
        if b == 0:
            return a
        return self.gcd(b, a%b)

    def gcd_list(self, A):
        if not A:
            return 0
        for i in reversed(range(1, self.gcd(max(A),min(A))+1)):
            count = 0
            for j in A:
                if (j % i) == 0:
                    count += 1
            if count == len(A):
                return i
        return 0

### input num
#i = input()
#A, B, T = [int(x) for x in i.split()]
N = int(input())
A = [int(x) for x in input().split()]
#C = [int(x) for x in input().split()]


#print("debug:{}".format(gcd(max(A),min(A))))
#print(list(reversed(range(1, gcd(max(A),min(A))+1))))

mathfunc = math()
anslist = []

for i in range(N):
    Rgcd = mathfunc.gcd_list(A[:i])
    Lgcd = mathfunc.gcd_list(A[i+1:])
    anslist.append(mathfunc.gcd(Rgcd,Lgcd))

### output
print(max(anslist))


## input num
i = input()
A, B, T = [int(x) for x in i.split()]

print((T//A)*B)


Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t=int(input())
print((t//a)*b)

a,b,t=map(int,input().split())
print(b*(t//a))

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a, b, t=map(int, input().split())
s = (t+0.5) // a 
print(b*s)

a, b, t=map(int, input().split())
s = (t+0.5) // a 
print(int(b*s))

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
n = int(input())
v_list = list(map(int, input().split()))
c_list = list(map(int, input().split()))
sum = 0

for v, c in zip(v_list, c_list):
    if v - c > 0:
        sum += v - c

print(sum)


a, b, t = map(int, input().split())
print(t // a * b)


Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

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

a, b, t = map(int, input().split())
print(b*(t//a))

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a, b, t = map(int, input().split())
bis = 0
for i in range(0,t+1,a):
  bis += b
print(bis)

a, b, t = map(int, input().split())
bis = 0
for i in range(a,t+1,a):
  bis += b
print(bis)


Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a, b, t = (int(i) for i in input().split())
amount = ((t + 0.5)//a)*b
print(amount)

a, b, t = (int(i) for i in input().split())
amount = (t + 0.5)//a*b
print(amount)

A,B,T = map(int, input().split())
print(T/A*B)

A,B,T = map(int, input().split())
print(T//A*B)


Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,c = list(map(int,input().split()))
print(a*(c//b))


a,b,c = list(map(int,input().split()))
print(b*(c//a))

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

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

a,b,t=map(int,input().split())
print(b*(t//a))


Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,n=map(int, input().split())
count = 0
t = 0
while t < (n+0.5):
    count += b
    t += a
print(count)

a,b,n=map(int, input().split())
count = 0
t = 0
while t < n:
    count += b
    t += a
print(count)

a,b,n=map(int, input().split()) 
if a <= n:
    t = int((n+0.5)/a)
else:
    t = 0
print(b*t)

Verdicts: Wrong Answer

Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t=map(int,input().split())
print(max(t//a*b),0)

a,b,t=map(int,input().split())
print(max(t//a*b),0)

a,b,t=map(int,input().split())
print(max(t//a*b,0))

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a , b , t = map(int(), input().split())
x = 0
y = 0
x = t // a
y = x * b
print(y)

a,b,t = map(int(),input().split())
x = t // a
y = x * b
print(y)

    a,b,t = map(int,input().split())
    x = t // a
    y = x * b
    print(y)

a,b,t = map(int,input().split())
x = t // a
y = x * b
print(y)

Verdicts: Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A,B,T=map(int,input().split())
print(B*(T%A))


A,B,T=map(int,input().split())
print(B*(T//A))

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

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

t += 0.5

print(b*(t//a))

a,b,t=map(int,input().split())

t += 0.5
print(int(b*(t//a)))

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t = map(int,input().split())
i = 1
ans =0 
while a < t:
  a *= i
  ans += b
  i += 1
print(ans)

a,b,t = map(int,input().split())
ans =0 
for  i in range(1,100):
    if a*i > t+0.5:
        break
    ans += b
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

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

print(((t+0.5)//a)*5)


a, b, t = map(int, input().split())

print((t//a)*b)


Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A, B, T = (int(i) for i in input().split())  
c=int(T+0.5/A)
ans=c*B
print(ans)

A, B, T = (int(i) for i in input().split())  
c=int((T+0.5)/A)
ans=c*B
print(ans)

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
import numpy as np

N = int( input() )
A = np.array(list( map( int, input().split() ) ))



A_abs = np.abs(A)

if 0 in A:
    print(np.sum(A_abs))

else:
    num = 0
    for i in range(N):
        if A[i] < 0:
            num += 1

    if num % 2 == 0:
        print(np.sum(A_abs))
    else:
        print(np.sum(A_abs) - 2 * min(A_abs))



A, B, T = map(int, input().split())

N = 1
for i in range(100):
    if N * A > T + 0.5:
        N -= 1
        break

    N += 1

ret = N * B
print(ret)

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
aaa

A=int(input())
B=int(input())
T=int(input())
reward=0
time=0

for t in range(T):
    time += 1
    if time%A == 0:
        reward = reward + B
        
print(reward)

A, B, T = map(int, input().split())
reward=0
time=0

for t in range(T):
    time += 1
    if time%A == 0:
        reward = reward + B
        
print(reward)

Verdicts: Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

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

print( (T+0.5)//A * B)

A, B, T = map(int, input().split())

print( int((T+0.5)//A * B))


Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
from fractions import gcd
N = int(input())
Alist = [0]+list(map(int, input().split()))+[0]
Rlist = [0]*(N+2)
Llist = [0]*(N+1)
for i in range(N):
    Llist[i+1] = gcd(Llist[i], Alist[i])
    Rlist[N-i] = gcd(Rlist[N-i+1], Alist[N-i+1])
print(max([gcd(Rlist[i], Llist[i]) for i in range(1,N+1)]))


A, B, T = map(int, input().split())
print((T // A ) * B)

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a,b,t = map(int,input().split())
sum = 0

for i in range(1,90):
  if i*a > t+ (1/2):
    ans = i-1
    break
    
for j in range(1,i):
  sum += j*b
  
  
print(sum)

a,b,t = map(int,input().split())
sum = 0

for i in range(1,90):
  if i*a > t+ (1/2):
    ans = i-1
    break
    
for j in range(1,ans+1):
  sum += b
  
  
print(sum)

Verdicts: Wrong Answer

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a, b, t = map(int, '20 20 19'.split())
print(sum([b for _ in range(a, t + 1, a)]))


a, b, t = map(int, imput().split())
print(sum([b for _ in range(a, t+1, a)]))


a, b, t = map(int, imput().split())
total = 0
for _ in range(a, t+1, a):
    total += b
print(total)

a, b, t = map(int, imput().split())
if a > t:
    print(sum([b for _ in range(a, t+1, a)]))
else:
    print(0)


a, b, t = list(map(int, imput().split()))
print(sum([b for _ in range(a, t+1, a)]))

a, b, t = list(map(int, input().split()))
print(sum([b for _ in range(a, t+1, a)]))

Verdicts: Wrong Answer

Runtime Error

Runtime Error

Runtime Error

Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
a = input()
b = input()
t = input()

print(int((t+0.5)/a)*b)

a,b,t=map(int,input().split())

print(int((t+0.5)/a)*b)

Verdicts: Runtime Error

Accepted
Problem: A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.  Find the total number of biscuits produced within T + 0.5 seconds after activation.

Submission attempts (in order):
A, B, T = map(int, input().split(" "))
if A>T:
    print(0)
else:
    count = (T-T%A)/A
    ans = B * count
    print(ans)

A, B, T = map(int, input().split(" "))
if A>T:
    print(0)
else:
    count = (T-T%A)/A
    ans = B * count
    print(int(ans))

Verdicts: Wrong Answer

Accepted