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


A,B,T=map(int,input().split())
print(int((T+0.5)/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())
n=t//a
print(b*n*(n+1)//2)

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

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

count = t / a

answer = b * count

print(answer)

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

count = t / a

answer = b * count

print(round(answer))

a, b, t =[int(i) for i in input().split()]
count = t / a
answer = b * count
print(answer)

a, b, t =[int(i) for i in input().split()]
count = t / a
answer = b * count
print(round(answer))

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

if(a >= 1 and a <= 20 and b >= 1 and b <= 20 and t >= 1 and t <= 20):
    count = t / a
    answer = b * count
    print(round(answer))
else:
    print(0)

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

Verdicts: 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):
A,B,T = list(map(int,input().split()))
print((T/A)*B)



A,B,T = list(map(int,input().split()))
print(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):
[print(a//t*b)for a,b,t in[[int(i)for i in input().split()]]

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

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*(c//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())

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 = list(map(int, input().split()))
print(a * int((t + 0.5) / b))

a,b,t = list(map(int, input().split()))
print(b * int((t + 0.5) / 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*((t+0.5)//a))

a, b, t = map(int, input().split())
print(int(b*((t+0.5)//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 fractions
from functools import reduce

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

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

#in
n=int(input())
v=list(map(int, input().split()))

maxi = 0


if len(list(set(v))) == 1:
    maxi = (v[0])
elif len(v) == 2:
    maxi = (max(v))

else:
    for i in range(n):
        listv = v
        listv[i] = min(v) 
        listv[i] = max(listv)
        print(listv)
        print(v)
        listval = listv
        temp = gcd_list(listval)
        if temp> maxi:
            if temp != max(listv)
                maxi = temp



print(maxi)




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):
x = input().split()¥a, b,t = int(x[0]),int(x[1]),int(x[2])
t += 0.5
num = t//a
sum = int(num * b)
print(num)

x = input().split()
a, b,t = int(x[0]),int(x[1]),int(x[2])
t += 0.5
num = t//a
sum = int(num * b)
print(sum)

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):
fq, num, max_time = map(int, input().split())
time = 0
_sum = 0
while 1:
    time += fq
    if(time >= max_time + 0.5):
        break
    else:
        _sum += num
        fq += fq
print(_sum)

fq, num, max_time = map(int, input().split())
time = 0
_sum = 0
while 1:
    time += fq
    if time >= max_time + 0.5:
        break
    else:
        _sum += num
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, input().split())
print(((T+0.5)//B)*A)

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

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

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):
# GCD on Blackboard


from functools import reduce

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


def get_gcd(a, b):
    
    if a < b:
        a, b = b, a

    elif a % b == 0:
        return b

    return get_gcd(b, a % b)


def get_gcd_l(l):
    
    return reduce(get_gcd, l)


def answer(l):
    
    len_l = len(l)
    answers = []  

    for i in range(len_l): 
        temp_l = []
        temp_l += l[0 : i]
        temp_l += l[i+1 : len_l]
        answers.append(get_gcd_l(temp_l))
    ans = max(answers)
    return ans


def main():
    
    print(answer(A))


if __name__ == '__main__':
    main()




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

def answer():
    ans = T // A * B
    return ans

def main():
    print(answer())


if __name__ == '__main__':
    main()


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 fractions
import functools

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

ans = 1

for i in range(1,N):
    A_i = A[:i-1] + A[i:]
    ans = max(ans, functools.reduce(fractions.gcd, A_i))

print(ans)

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())
print(int(b*(t+0.5)//a))

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


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().split()
print((T//A)*B)


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


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

print(t//a*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,c= map(int,input().split())
pritn((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(" "))

ans = 0
while (t > b):
    t -= a
    ans += b
print(ans)

a,b,t = map(int,input().split(" "))
ans = 0
while (t >= a):
    t -= a
    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(b*(t%a))

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

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

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):
n = int(input())
v = map(int,input().split())
c = map(int,input().split())
cnt = 0
for i in range(n):
    if v[i] > c[i]:
        cnt += (v[i] - c[i])
    else:
        cnt += 0    
print(cnt)

a,b,t = map(int,input().split())
n = t // a
print(n*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 copy
import fractions
from functools import reduce

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

a = int(input())

xList = [int(i) for i in input().split()]
keisanList = copy.deepcopy(xList)
saidai = max(xList)
saidaiKoyakuSu = 0
koyakuSu = 0
listIndex = 0

for i in range(a):
    keisanList = copy.deepcopy(xList)
    keisanList[i] = saidai
    koyakuSu = gcd_list(keisanList)
    if(saidaiKoyakuSu < koyakuSu):
        saidaiKoyakuSu = koyakuSu
        listIndex = i

xList[listIndex] = saidai
print(gcd_list(xList))


a, b, c = map(int, input().split())
d = c + 0.5
bis = 0
byou = 0

for i in range(21):
    byou = i * a
    if byou >= d:
        break
    bis = i * b

print(bis)

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())
a =T//A
 number = 0
 for i in range(a):
  b=1
  s = a-b
  if s >0:
    number+=1
  b+=1
print(number*B)

  

A,B,T=(int,input().split())
a =T//A
 number = 0
 for i in range(a):
  b=1
  s = a-b
  if s >0:
    number+=1
  b+=1
print(number*B)

  

A,B,T = map(int,input().split())
a =T//A
number = 0
 for i in range(a):
  b=1
  s = a-b
  if s >0:
    number+=1
  b+=1
print(number*B)

  

A,B,T=(int,input().split())
a =T//A
number=0
for i in range(a):
 b=1
 s = a-b
 if s >0:
   number+=1
 b+=1
print(number*B)

  

A,B,T=(int,input().split())
int a =T//A
for i in range(a):
 int b=1
 int s = a-b
 if sum >0:
   number++
 b++
print(number*B)

  

A,B,T = map(int,input().split())
a =T//A
number = 0
 for i in range(a):
  b=1
  s = a-b
  if s >0:
    number+=1
  b+=1
print(number*B)

  

A,B,T=(int,input().split())
int a =T//A
number=0
for i in range(a):
 b=1
 s = a-b
 if s >0:
   number+=1
 b+=1
print(number*B)

  

A,B,T = map(int,input().split())
a =T//A
number = 0
for i in range(a):
  b=1
  s = a-b
  if s >=0:
    number+=1
  b+=1
print(number*B)

  

Verdicts: Runtime Error

Runtime Error

Runtime Error

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):
# -*- coding: utf-8 -*-
a, b, t = map(int, input().split())


p = (t+0.5)//a

anc = int(p*b)

print(ans)

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


p = int((t+0.5)//a)

ans = p*b

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

n = T // A

sum = 0
for i in range(n):
  sum = sum + B*(n+1)
  
print(sum)

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

n = T // A

sum = 0
for i in range(n):
  sum = 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):
import math
a,b,t = map(int,input().split())
b*(t//a)

import math
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())
c = 0

for i in range(0, int(t+0.5), a):
    c += b

print(c)

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

while t - a >= 0:
    c += b
    t -= a

print(c)

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())
ans = ((T + 0.5) // A ) * B
print(ans)

import fractions
 
N = int(input())
A = list(map(int,input().split()))
L = [0] * N
R = [0] * N

for i in range(1, N):
    L[i] = fractions.gcd(L[i-1], A[i-1])
    R[-i-1] = fractions.gcd(R[-i], A[-i])

ans = [0] * N

for i in range(0, N):
    ans[i] = fractions.gcd(L[i], R[i])

print(max(ans))

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

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

#A
import math
a, b, t = map(int, input().split())
print(math.floor(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(x) for x in input().split())
c=0
for i in range(t+1):
  if i%a==0:
    c+=b
print(c)

a,b,t=(int(x) for x in input().split())
c=0
for i in range(1,t+1):
  if i%a==0:
    c+=b
print(c)

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//a*b)


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

a,b,t=map(int,input().split())
print(t//a*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())
k = (t+0.5)//a
print(k*b)

a,b,t = map(int,input().split())
k = (t+0.5)//a
print(int(k*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):
inputs = list(map(int, inpit().split()))

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

Q = int(T / A)
print(Q)
X = Q* B
print(X)


inputs = list(map(int, input().split()))
 
A = inputs[0]
B = inputs[1]
T = inputs[2]
 
Q = int(T / A)
#print(Q)
X = Q* B
print(X)

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

m=a//t

print(int(m*b))

a,b,t=map(int,input().split())
     
m=t//a
     
print(int(m*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 = [int(i) for i in input().split()]



#def euclid(m, n):
#  if n == 0:
#    return m
#  new_m = n
#  new_n = m % n

#
#def array_euclid(numbers):
#  n = len(numbers)


#    if n == 2:
#      return numbers[0]
#    
#    numbers.pop()
#    return array_euclid(numbers)
#
#  numbers[n-1] = numbers[n-2]
#  numbers[n-2] = v
#  return array_euclid(numbers)

#print(array_euclid(a))

#if n == 2:
#  print(euclid(a[0], a[1]))
#if n > 2:
#  max_list = []
#  max_list.append(array_euclid(a[:]))

#    a2 = a[:]
#    a2.pop(i)
#    max_list.append(array_euclid(a2))
#  print(max(max_list))
#







#print(euclid(a[0],a[1]))




from fractions import gcd
from functools import reduce

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

max_list = []
max_list.append(gcd_list(a))
for i in range(n):
  a2 = a[0:i] + a[i+1:]
  #a2.pop(i)
  max_list.append(gcd_list(a2))
print(max(max_list))



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(((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 sys
import os
import math
from functools import reduce
from fractions import gcd

def test(x,k,m):
    #print("i=",k)
    tmp=[0]*len(x)
    for j in range(m):
        tmp[j]=x[j]
    #print('a=',x)
    #print('tmp=',tmp)
    del tmp[k]
    #print('tmp=',tmp)
    #print("a==",x)
    XX=gcd(*tmp)
    #print("XX=",XX)
    return XX

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

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

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

yakusu=[0]*len(a)
for i in range(n):
    yakusu[i]=test(a,i,n)

ans=max(yakusu)
print(ans)

import sys
import os
import math
import fractions
from functools import reduce
from fractions import gcd

def test(x,k,m):
    #print("i=",k)
    tmp=[0]*len(x)
    for j in range(m):
        tmp[j]=x[j]
    #print('a=',x)
    #print('tmp=',tmp)
    del tmp[k]
    #print('tmp=',tmp)
    #print("a==",x)
    XX=gcd(*tmp)
    #print("XX=",XX)
    return XX

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

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

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

yakusu=[0]*len(a)
for i in range(n):
    yakusu[i]=test(a,i,n)

ans=max(yakusu)
print(ans)

a,b,t = map(int,input().split())
count=1
sum=0
while a*count < t+0.5:
    sum=sum + b
    count+=1
print(sum)

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 = (float(i) for i in input().split())
print(int((t + 0.5) / a) * b)

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

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

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

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

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

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

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

import math
a, b, t = (float(i) for i in input().split())
print(int(math.floor((t + 0.5) / b)) * a)

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

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

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

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

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

import math
a, b, t = (float(i) for i in input().split())
print(int(math.fllor((t + 0.5) / b)) * a)

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

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

Verdicts: Wrong Answer

Runtime Error

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Runtime Error

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

Wrong Answer

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())
T=a
cnt=0
while T<=t:
    ans+=b
    T+=a
print(cnt)


a,b,t=map(int,input().split())
T=a
ans=0
while T<t+0.5:
    ans+=b
    T+=a
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):
def biscuit_generator(a, b, t):
  return ((t + 0.5) // a) * b

a, b, t = (int(i) for i in input().split()) 

return ((t + 0.5) // a) * b

a, b, t = (int(i) for i in input().split()) 

print((t // a) * b)

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):
N = int(input().strip())
A = list(map(int, input().strip().split(' ')))
A = sorted(A)


def divisor(n):
  result = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      result.append(i)
      if i != n // i:
        result.append(n//i)
  return result


def check(A, d):
  count = 0
  for a in A:
    if a % d == 0:
      continue
    count += 1
    if count > 1:
      return False
  return True

for i in sorted(list(set(divisor(A[0])+divisor(A[1]))))[::-1]:
  if check(A, i):
    print(i)
    exit()

A,B,T = map(int, input().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):
import fractions
def mygcd(N,A,S):
    if S == 'R':
        A.reverse()
    ans = [0, A[0]]
    for i in range(1, N):
        ans.append(fractions.gcd(ans[i],A[i]))
    if S == 'R':
        ans.reverse()
    return ans

def GCDonBlack(N,A):
    L = mygcd(N,A,'L')
    R = mygcd(N,A,'R')
    M = [fractions.gcd(L[i], R[i+1])  for i  in range(0,N)]
    return max(M)

N = int(input())
A = list(map(int, input().split()))
print(GCDonBlack(N,A))

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())
c=(t+0.5)//a
d=b*c
print(d)

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


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%a) * b)

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 = map(int ,input().split())
T = T+0.5
int(T/A)*B

A,B,T = map(int ,input().split())
T = T+0.5
print(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,c=map(int,input().split())
print((c+0.5)//a*b)

a,b,c=map(int,input().split())
print((c//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 = T // A
D = A * C

print(D)


A, B, T= (int(i) for i in input().split())

C = T // A
D = B * C

print(D)


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()]
ans = 0
for i in range(1, 20):
    if t < i*a:
        break
    t = t - i*a
    ans += b
print(ans)    
    
    

a, b, t = [int(i) for i in input().split()]
ans = 0
for i in range(1, 30):
    if t < i*a:
        break
    t = t - i*a
    ans += b
print(ans)    
    
    

a, b, t = [int(i) for i in input().split()]
ans = 0
for i in range(1, 30):
    if t < a:
        break
    t = t - a
    ans += b
print(ans)    
    
    

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((((t + 0.5) - ((t + 0.5) % a)) / a) * b)

a, b, t = map(int, input().split())
print(int((((t + 0.5) - ((t + 0.5) % a)) / 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):
#!/bin/env python
  

if __name__=='__main__':
  val_n = input()
  list_v = list(map(int,input().split()))
  list_c = list(map(int,input().split()))

  answer = 0
  for i in range(len(list_v)):
    if(list_v[i] - list_c[i] > 0):
      answer += list_v[i] - list_c[i]
  print(answer)

#!/bin/env python
  
import sys

def validate(input):
    if input < 0 or input > 20:
        return False
    return True

def biscuitGen(input_a, input_b, input_t):
    biscuits = 0
    if validate(input_a) and validate(input_b) and validate(input_t):
        biscuits = int(input_t / input_a) * input_b
    return biscuits

if __name__=='__main__':
    '''
    print how many biscuit will be generated 
    A: Seconds to generate biscuit
    B: Number of biscuit pieces to generate once
    T: Limit of the seconds to generate biscuit
    1 <= A,B,T <= 20
    '''
    biscuit = 0
    inarray = list(map(int,input().split()))
    if len(inarray) != 3:
        print("Please input 3 numbers")
        sys.exit()
    biscuit = biscuitGen(inarray[0], inarray[1], inarray[2])
    print(biscuit)

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+0.5)//A))

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

print(int(B*((T+0.5)//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 * ((T + 0.5)//A))

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

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*T//A) if A<=T else print(0)

A,B,T = map(int, input().split())
print(B*(T//A)) if A<=T else print(0)

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):
using System;
using System.Runtime.InteropServices;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            int a, b, t;
            string[] str =Console.ReadLine().Split(' ');
            a = int.Parse(str[0]);
            b = int.Parse(str[1]);
            t = int.Parse(str[2]);
            Console.WriteLine(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())
count=0

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

import math

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

count=(T+0.5)//A
print(math.floor(count*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,C=map(int,input().split())
print(int((A%(C+0.5))*B))


A,B,C=map(int,input().split())
print(((C+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())
print(((10*t+5)//10*a)*b)


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

a,b,t= map(int, input().split())
s=(10*t+5)//10*a
print(s*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

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())
print(((T+0.5)//A)*B)

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 = map(input().split())
print(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):
def biscuit(inputs):
  number=inputs[2]//inputs[0]*inputs[1]
  return number

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

biscuit(x)

A,B,T=map(int,input().split())
print("{}".format(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,intput().split())

print(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 = [int(c) for c in input().split()]

t = t + 0.5

ans = 0
time = a
while time <= t:
    print(a)
    ans += b
    time += a

print(ans)

a, b, t = [int(c) for c in 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 = input().split()
a = int(a)
b = int(b)
t = int(t)
ans = 0

c = int(t / a)

ans = a*c
print(ans)

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

c = t // a

ans = b*c
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 = int(input(A))
B = int(input(B))
T = int(input(T))

count = (T + 0.5) // A
biscuit = B * count
print(biscuit)


count = (T + 0.5) // A
biscuit = B * count
print(biscuit)

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

count = (T + 0.5) // A
bsc = B * count

print(bsc)

A = int(A)
B = int(B)
T = int(T)

count = (T + 0.5) // A
biscuit = B * count
print(biscuit)


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

count = T // A
bsc = B * count

print(bsc)


Verdicts: Runtime Error

Runtime Error

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

hmb = b * (a // t)
print(hmb)

n = int(input())
in_num = input().split()
lis_num = [int(s) for s in in_num]
m = max(lis_num)

x = [lis_num[i] % m for i in range(n)]
sx = max(x.remove(max(x)))
m2 = max(lis_num.remove(m))
y = [lis_num[i] % m2 for i in range(n)]
sy = max(y.remove(max(y)))
if sx == 0:
  ans = m
elif sy == 0:
  ans = m2
else:
  for i in range((m+1)//2, 0, -1):
    x = [lis_num[j] % i for j in range(n)]
    sx = max(x.remove(max(x)))
    if sx == 0:
      ans = i
      break
    else:
      continue
print(ans)


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

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):
A = int(input())
B = int(input())
T = int(input())

count = 0
x = int((T+0.5)/A)
for i in range(1,x+1):
    count += B

print(count)

A, B, T = (int(i) for i in input().split())

count = 0
for i in range(0, int(T/A)):
    count += B

print(count)

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())
x = (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 = map(int, input.split(" "))
  
  total=0
  
  for i in range(1,20):
    if a*i > t:
      break
    else:
      total += b
  
  print(total)
  
  
  

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

total=int(t/a)*b

print(total)


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 t>=a:
    print(b*t//a)
else:
    print(0)

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


if t>=b:
    print(b*t//a)
else:
    print(0)


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

print(int(((t+0.5)//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=list(map(int,input().split()))
b=0
c=1
while(c*a[0]<(a[2]+0.5)):
  b=b+a[1]
  
print(b)

a=list(map(int,input().split()))
b=0
c=1
while(c*a[0]<(a[2]+0.5)):
  b=b+a[1]
  c=c+1
  
print(b)

Verdicts: Time Limit Exceeded

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):
num =int(input())
value = list(map(int, input().split()))
value.sort()
point = 0
for i in range (0, value[0]):
  cnt = 0
  for j in range(0, num):
    if value[j]%(value[0]-i)!=0:
      cnt += 1
      point = j
  if cnt == 1 or cnt == 0:
    break
print(value[0] - i)

num =int(input())
value = list(map(int, input().split()))
value.sort()
point = 0
for i in range (0, value[0]):
  cnt = 0
  for j in range(0, num):
    if value[j]%(value[0]-i)!=0:
      cnt += 1
      point = j
  if cnt == 1 or cnt == 0:
    break
print(value[0] - i)

data = input().split()
A = int(data[0])
B = int(data[1])
T = int(data[2]) + 0.5
biscuit = 0
time = A
while time < T:
  biscuit += B
  time += A

print(biscuit)

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())
a = T // A
total = 0

if i in range(a):
  total += B
  
print(total)

A, B, T = map(int, input().split())
a = T // A
total = 0

for i in range(a):
  total += B
  
print(total)

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(A/T)*B)

A,B,T  = map(int, input().split())
 
print(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):
i = list(map(int, input().split()))



ans = i[1]*((i[2]+0.5)//(i[0]))
print(ans)

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



ans = int(i[1]*((i[2]+0.5)//(i[0])))
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 *B)

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

Verdicts: Wrong Answer

Accepted