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

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

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

print(time)
print(b * time)

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

print(b * time)

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 = input().sprit()
print(int(T/A)*B)

A, B, T = map(int, input().split())
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):
N=int(input())
LA=list(map(int,input().split()))
ans=[]

def gcd(m,n):
    while n:
        m,n=n,m%n
    return m

from functools import reduce
def multigcd(item):
    return reduce(gcd, item)

for n in range(N):
    L=LA[:n]+LA[n+1:]
    ans.append(multigcd(L))

print(max(ans))

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

p_m=1
for n in range(N):
    p_m*=LA[n]
    
LA_absolute=[i*(-1) if i<0 else i for i in LA]


if p_m>=0:
    print(sum(LA_absolute))
else:
    print(sum(LA_absolute)-2*min(LA_absolute))

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

print(B*(T//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 = list(map(int,input().split()))
print((A[2]-A[2]%A[0])/A[0]*A[1])

A = list(map(int,input().split()))
print(int((A[2]-A[2]%A[0])/A[0]*A[1]))

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 math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.buffer.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.buffer.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

a, b, t = rm()
print((t+0.5)//a * b)
















import sys
a, b, t = map(int, sys.stdin.buffer.readline().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())
 
count = 0
for i in range(0, t+1, a):
    count += i * b
print(count)

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

count = 0
for i range(1, t+1, a):
  count += i * b
print(count)
  

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

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

Verdicts: Wrong Answer

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 fractions

def main():
    N=int(input())
    num=list(map(int,input().split()))
    gcd=0
    gcd_list_front=[]
    gcd_list_back=[]
    gcd_list_front.append(num[0])
    gcd_list_back.append(num[-1])

    for  i in range(1,N-1):
        gcd_list_front.append(fractions.gcd(gcd_list_front[i-1],num[i]))
        gcd_list_back.append(fractions.gcd(gcd_list_back[i-1],num[-i-1]))
    gcd_list_back.reverse()

    gcd=max(gcd_list_back[0],gcd_list_front[-1])
    for i in range(0,N-2):
       temp_gcd=fractions.gcd(gcd_list_front[i],gcd_list_back[i+1])
       if temp_gcd>gcd:
           gcd=temp_gcd
    print(gcd)


if  __name__=="__main__":
    main()


import math

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

L=[0,0]
for ai in A:
    #L.append(gcd(L[-1],ai))
    L.append(math.gcd(L[-1],ai))
    print(L)

R=[0,0]
for ai in A[::-1]:
    #R.append(gcd(R[-1],ai))
    R.append(math.gcd(L[-1],ai))
    print(R)

print(max(math.gcd(l,r) for l,r in zip(L,reversed(R))))

import fractions

def main():
    N=int(input())
    num=list(map(int,input().split()))
    gcd=0
    gcd_list_front=[]
    gcd_list_back=[]
    gcd_list_front.append(num[0])
    gcd_list_back.append(num[-1])

    for  i in range(1,N-1):
        gcd_list_front.append(fractions.gcd(gcd_list_front[i-1],num[i]))
        gcd_list_back.append(fractions.gcd(gcd_list_back[i-1],num[-i-1]))
    gcd_list_back.reverse()

    gcd=max(gcd_list_back[0],gcd_list_front[-1])
    for i in range(0,N-2):
       temp_gcd=fractions.gcd(gcd_list_front[i],gcd_list_back[i+1])
       if temp_gcd>gcd:
           gcd=temp_gcd
    print(gcd)


if  __name__=="__main__":
    main()

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

A[0]=A[0]-1
A[1]=A[1]-1
sum=0

for a in A:
    if a>0:
        sum+=a

print(sum)


import fractions

def main():
    N=int(input())
    num=list(map(int,input().split()))
    gcd=0
    gcd_list_front=[]
    gcd_list_back=[]
    gcd_list_front.append(num[0])
    gcd_list_back.append(num[-1])

    for  i in range(l,N-1):
        gcd_list_front.append(fractions.gcd(gcd_list_front[i-1],num[i]))
        gcd_list_back.append(fractions.gcd(gcd_list_back[i-1],num[-i-1]))
   gcd_list_back.reverse()

   gcd=max(gcd_list_back[0],gcd_list_front[-1])
   for i in range(0,N-2):
       temp_gcd=fractions.gcd(gcd_list_front[i],gcd_list_back[i+1])
       if temp_gcd>gcd:
           gcd=temp_gcd
    print(gcd)


if  __name__="__main__":
    main()


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

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


Verdicts: 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):
A, B, T = int(x) for x in input().split()

print((T//A)*B)

A, B, T = (int(x) for x in 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):
l = input().split()
list = [int(i) for i in l]
x = int(list[-1] / list[0])
num = list[1] * x

l = input().split()
list = [int(i) for i in l]
x = list[-1] / list[0]
num = list[1] * x
print(num)

l = input().split()
list = [int(i) for i in l]
x = int(list[-1] / list[0])
num = list[1] * x
print(num)

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

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

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


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

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


Verdicts: Runtime Error

Runtime Error

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

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

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

while t + 0.5 > tt + a:
	c+= b
	tt += a	

	
print(c)

import math
import functools

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

if max(v) % 2 ==0:
	b = True
else:
	b = False
		
v.sort()

for index,_ in enumerate(v):
	if _  % 2 ==0:
		if not b:
			v[index] = v[-1]
			break
			
	else:
		if b:
			v[index] = v[-1]
			break
			
ans = functools.reduce(math.gcd,v)
print(ans)



import math
import functools
import fractions

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

if max(v) % 2 ==0:
	b = True
else:
	b = False
		
v.sort()

for index,_ in enumerate(v):
	if _  % 2 ==0:
		if not b:
			v[index] = v[-1]
			break
			
	else:
		if b:
			v[index] = v[-1]
			break
				


for i in range(1,len(v)):
	ans = fractions.gcd(ans, v[i])
	
print(ans)



import math
#from functools import reduce
import functools

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

while t + 0.5 > tt + a:
	c+= b
	tt += a	

	
print(c)

Verdicts: Wrong Answer

Runtime Error

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

argv = sys.argv
a = int(argv[1])
b = int(argv[2])
t = int(argv[3]) + 0.5 - a

r = 0

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

print(r)


argv = sys.argv
a = int(input())


b = int(input())

t = int(input()) + 0.5 - a

r = 0

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

print(r)


args = input()
args = args.split(' ')

a = int(args[0])
b = int(args[1])
t = int(args[2]) + 0.5 - a

r = 0

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

print(r)


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

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


A, B, T = map(int, input().rstrip().split())
c = (T + 0.5) // A
t = c * B
return t
  


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


Verdicts: Wrong Answer

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((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(" "))
time = 0
bis = 0
while time < t:
  bis += b
  time += a
print(bis)

a,b,c = map(int,input().split(" "))
t = 0
count = 0
while True:
    t += a
    if t > c:
        print(count)
        exit()
    else:
        count += b
print(count)

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

res = 0
for i in range(N):
    a = V[i] - C[i]
    if a > 0:
        res = res + a
    else:
        pass

print(res)



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

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


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


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())
n = 1
for i in range(20):
  if T > i*A:
    n = n + 1
print(B*n)

A, B, T = map(int,input().split())
n = 0
for i in range(20):
  if T > i*A:
    n = n + 1
print(B*n)


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 = [int(s) if s.isdigit() else s for s in input().split()]
print(int((T + 0.5 // A) * B))

A, B, T = [int(s) if s.isdigit() else s for s in 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())
for i in range(0,21):
    if (T+0.5)-A*i < 0:
        print(A*(i-1))
        break


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(s)for s in input().split()]
print(b*t//a)

a,b,t=[int(s)for s in 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()))

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 = map(int,input().split())
ans = 0
T = A
while(T<=t):
  ans += B
  T += A
print(ans)

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

number = ((T+0.5)//A)*B

print(number)

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

number = round(((T+0.5)//A)*B)

print(number)

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_list(numbers):
    return reduce(fractions.gcd, numbers)

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


ans = 0
for i in range(n):
    init = a_list[:]
    init.pop(i)
    gcd = gcd_list(init)
    if ans < gcd:
        ans = gcd

print(ans)

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

ans = [i for i in range(1,30) if i%a == 0 and i<t+0.5]
print(len(ans)*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())
v=list(map(int,input().split()))
c=list(map(int,input().split()))
s = 0
for i in range(n):
    s += max(0,v[i]-c[i])
print(s)

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 math

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

if isinstance(A,int) and isinstance(B,int) and isinstance(T,int) :
    num_biscuit=0

    if 1<=A<=20 and 1<=B<=20 and A<=T<=20:
        
        for i in range(math.floor(T/A)):
            num_biscuit=num_biscuit+B
            print(num_biscuit)
    else :
        print(0)

else :
    print("ERROR")
    exit()


import math

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

if isinstance(A,int) and isinstance(B,int) and isinstance(T,int) :
    num_biscuit=0
    if 1<=A<=20 and 1<=B<=20 and 1<=T<=20:
        for i in range(math.floor(T/A)):
            num_biscuit=num_biscuit+B
        print(num_biscuit)
    # else :                                                                               
    #     print(0)                                                                         

else :
    print("ERROR")
    exit()


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

n=input()
v=list(map(int, input().split()))
c=list(map(int, input().split()))
t=[i-j,if i-j>0 else 0 for i,j in zip(v,c)]
print(sum(t))


import numpy as np
n=input()
v=np.array(map(int, input().split()))
c=np.array(map(int, input().split()))
t=v-c
a=0
for i in range(n)
if t[i]>0 :
a+=t[i]
print(a)

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

print(id)

pre_num=[0]*(n+1)
ans=[""]*m

id.sort(key=lambda x:x[1])

for p,y,i in id:
    pre_num[p]+=1
    ans[i]=str(p).zfill(6)+str(pre_num[p]).zfill(6)
    
print("\n".join(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())

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())
x = 0

while a <= t + 0.5:
	x = x + b
	a = a + a

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

ans = T//A * 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):
N = int(input())
V = list(map(int,input().split()))
C = list(map(int,input().split()))

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

print (count)

A,B,T = list(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):
A, B, T = input().split()
A = int(A)
B = int(B)
T = int(T)
n = (T+0.5) // A
N = n * B
N //= 1
print(N)

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

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

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())
time = 0

while time + a < t + 1/2:
  time += a

time += a
print(b*time)

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

while time + a < t + 1/2:
  time += a

print(b*time)


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

a,b,t=map(int,input().split())
print((0.5+t)//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):
#include "bits/stdc++.h"

using namespace std;

int main(){
  int A, B, T;
  cin >> A >> B >> T;

  cout << T/A*B << endl;
}

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):
import math
a,b,t=map(float,input().split())
c = math.floor(t/a)
print(c*b)

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

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

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(" ")
 
a = int(n[0])
b = int(n[1])
t = int(n[2])
 
w = (t / a)
print(w * b)

n = input().split(" ")

a = int(n[0])
b = int(n[1])
t = int(n[2])

w = (t / a)
pritn(w * b)

n = input().split(" ")
 
a = int(n[0])
b = int(n[1])
t = int(n[2])
 
w = int(t / a)
print(w * 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):
# -*- coding: utf-8 -*-
import fractions

N = int(input().rstrip())
As = list(map(int, input().rstrip().split()))


def gcd_list(numbers):
    res = math.gcd(numbers[0], numbers[1])
    if len(numbers) > 2:
        for idx in range(2, len(numbers)):
            res = fractions.gcd(res, numbers[idx])
    return res


max_gcd = 0
if(N) == 2:
    max_gcd = max(As)
else:
    for i in range(N):
        others = [As[j] for j in range(N) if j != i]
        max_gcd = max(gcd_list(others), max_gcd)

print(max_gcd)

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

N = int(input().rstrip())
As = list(map(int, input().rstrip().split()))


def gcd_list(numbers):
    res = fractions.gcd(numbers[0], numbers[1])
    if len(numbers) > 2:
        for idx in range(2, len(numbers)):
            res = fractions.gcd(res, numbers[idx])
    return res


max_gcd = 0
if(N) == 2:
    max_gcd = max(As)
else:
    for i in range(N):
        others = [As[j] for j in range(N) if j != i]
        max_gcd = max(gcd_list(others), max_gcd)

print(max_gcd)

# -*- coding: utf-8 -*-
import numpy as np
A, B, T = map(int, input().split())

x = int(np.floor((T + 0.5) / A))

print(x * 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):
n=int(input())
V=list(map(int, input().split()))
C=list(map(int, input().split()))

sum=0
for i in range(n):
  if V[i]>C[i]:
      sum+=V[i]-C[i]
print(sum)    

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

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 = 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):
def biscuit_generator():
    number = [int(x) for x in input().split()]
    A = number[0]
    B = number[1]
    T = number[2]
    return int(((T + 0.5) // A) * B)

biscuit_generator()

def biscuit_generator():
    number = [int(x) for x in input().split()]
    A = number[0]
    B = number[1]
    T = number[2]
    print(int(((T + 0.5) // A) * B))

biscuit_generator()

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

import fraction
from functools import reduce
from copy import copy

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

gcds=[]
for i in range(N):
    A_=copy(A)
    A_=pop(i)
    gcds.append(gcd(*A_))

print(max(gcds))


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

import fractions
from functools import reduce
from copy import copy

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

gcds=[]
for i in range(N):
    A_=copy(A)
    A_=pop(i)
    gcds.append(gcd(*A_))

print(max(gcds))


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

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

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


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

A =( z + 0.5) / x

print( A * y)

#coding:utf-8
a,b,t = input().split()
x = t // a
print(b*x)


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

Y =( X[3] + 0.5) / X[1]

print( Y * X[2])

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

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


#include <string>
#include <algorithm>
#include <cmath>
using namespace std;



int main(){
    //input    
    int A,B,T;
    cin >> A >> B >> T;
    int ans;
    ans = (T / A)*B;
    cout << ans << endl;
    

    return 0;
}

#[A,B,T] = [20,20,19]
[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):
from fractions import gcd

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

rs, ls = [0], [0]
for i in range(n-1):
  rs.append(gcd(rs[i], a[i]))
  ls.append(gcd(ls[i], a[-i-1]))

print(max(gcd(r, l) for r, l in zip(rs, ls[::-1])))

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):
s = list(map(int, input().split()))
if(0<=s[0]=<20 and 0<=s[1]=<20 and 0<=s[2]=<20)
	z=round((s[2]+0.5)/s[0])
	w=s[1]*z
	print(w)
    
else:
  print("error")

s = list(map(int, input().split()))
z=(s[2]+0.5)//s[0]
w=s[1]*z
print(z)

s = list(map(int, input().split()))
z=s[2]+0.5
q=z//s[0]
w=s[1]*q
print(w)

s = list(map(int, input().split()))
z=(s[2]+0.5)//s[0]
w=s[1]*z
print(w)


s = list(map(int, input().split()))
z=(s[2]+0.5)//s[0]
w=s[1]*z
print(w)


x=raw_input()
y=raw_input()
z=raw_input()
w=(int(z+0.5/x)*y)
print(w)

s = list(map(int, input().split()))
z=(int,(s[2]+0.5)/s[0])
w=s[1]*z
print(w)

s=list(map(int,input().split()))
a=s[2]%s[0]
c=s[2]-a
d=c/s[0]
b=d*s[1]
print(int(b))

Verdicts: Runtime Error

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):
def solve(a, b, t):
    result = int(t/a) * b
    return result

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

    return a, b, t


def main():
    a, b, t = input_from_console()
    print(solve(a, b, t))


def solve(a, b, t):
    result = int(t / a) * b
    return result

def input_from_console():
    a, b, t = map(int, input().split())
    return a, b, t


def main():
    a, b, t = input_from_console()
    print(solve(a, b, t))

if __name__ == "__main__":
    main()

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):
s = input()
d = s.split("/")
m = int(d[1])
if m > 4:
 print("TBD")
else:
 print("Heisei")

a,b,t =(int(x) for x in input().split())
c = t//a
print(c*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())
a = input().split()
mi = abs(int(a[0]))
ans =  0 
count = 0
for i in range(n):
    ans = ans + abs(int(a[i]))
    if mi > abs(int(a[i])):
        mi = abs(int(a[i]))
    if int(a[i])<0:
        count = count + 1
if count%2 ==0:
    print(ans)
else:
    print(ans-2*mi)


n = int(input())
a = input().split()
mi = abs(int(a[0]))
ans =  0 
for i in range(n):
    ans = ans + abs(int(a[i]))
    if mi > abs(int(a[i])):
        mi = abs(int(a[i]))
print(ans-2*mi)

n = int(input())
a = input().split()
mi = abs(int(a[0]))
ans =  0 
for i in range(n):
    ans = ans + abs(int(a[i]))
    if mi > abs(int(a[i])):
        mi = abs(int(a[i]))
print(ans-2*mi)


i = input().split()
a = float(i[0])
b = float(i[1])
t = float(i[2])
f = True
n = 0
while(f):

    if t  + 0.5 < n * a:
       f = False
       break
    n = n + 1
n = n-1
print(int(n * 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):
def solve():
    A,B,T = int(input().split())
    num = B*int(T/A)
    print(num)


solve()

def solve():
    A,B,T = map(int,input().split())
    num = B*int(T/A)
    print(num)


solve()

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

a = abt[0]
b = abt[1]
t = abt[2]

t05 = t + 0.5
times = t05 // a

total = b * times


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

a = abt[0]
b = abt[1]
t = abt[2]

t05 = t + 0.5
times = t05 // a

total = b * times

print(str(total))


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

a = abt[0]
b = abt[1]
t = abt[2]

t05 = t + 0.5
times = t05 // a

total = b * times

print(str(int(total)))

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 = (int(i) for i in input())

times = int(t / a)

num = times * b

print(num)


a, b, t = (int(i) for i in input().split())
 
times = int(t / a)
 
num = times * b
 
print(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):
N = int(input())
V = list(map(int,input().split()))
C = list(map(int,input().split()))

for i in range(N):
    if V[i] <= C[i]:
        continue
    Max = Max + V[i] - C[i]
print(Max)

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):
N = int(input())
V = [int(n) for n in input().split(" ")]
C = [int(n) for n in input().split(" ")]
ret = 0
for i in range(N):
    if V[i] - C[i] > 0:
        ret += V[i] - C[i]

print(ret)



input = input()
sp_input = input.split(" ")
A = int(sp_input[0])
B = int(sp_input[1])
T = int(sp_input[2]) + 0.5

ret = B
i = 0
while A <= T:
  ret += B
  A += A


print(ret)


input = input()
sp_input = input.split(" ")
A = int(sp_input[0])
B = int(sp_input[1])
T = int(sp_input[2]) + 0.5
a = A

ret = 0
i = B
while a <= T:
  ret += B
  a += A

print(ret)


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):
def calc_max_total_jewels_value():
  jewels = int(input())
  jewel_value = [int(x) for x in input().split()]
  jewel_cost = [int(x) for x in input().split()]
  
  max_total_jewels_value = 0
  for jewel_no in range(jewels):
    max_total_jewels_value += max([0, jewel_value[jewel_no] - jewel_cost[jewel_no]])
    
  return max_total_jewels_value

if __name__ == '__main__':
  print(calc_max_total_jewels_value())

def count_sum_generated_biscuit():
  generation_interval_sec,\
  biscuit_per_generation,\
  initial_target_sec = [int(x) for x in input().split()]
  
  target_sec = initial_target_sec + 0.5
  sum_generated_biscuit\
  = (target_sec // generation_interval_sec) * biscuit_per_generation
  
  return int(sum_generated_biscuit)
  
if __name__ == '__main__':
  print(count_sum_generated_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):
first = input().split(' ')
per_time = int(first[0])
per_make = int(first[1])
time = int(first[2]) + 0.5

made = int(per_make / per_time * time)

print(made)

first = input().split(' ')
per_time = int(first[0])
per_make = int(first[1])
time = int(first[2]) + 0.5

made = per_make * int(time / per_time)

print(made)

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

a,b,t=list(map(int, list(input().split())))
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,t = map(int,input().split())
now = 0
ans = 0
while now < t:
  ans += b
  now += a
print(ans)

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


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


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

x = (t+0.5)%a
return b*x

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

x =(t+0.5)//a

print(b*x)

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

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

print(b)



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

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

print(x)

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

print(b*(a//t))

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

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()))
 
L = [0]*(N+2)
R = [0]*(N+2)
 
import fractions
 
for i in range(1,N+1):
    L[i] = fractions.gcd(L[i-1],A[i-1])
for i in range(0,N)[::-1]:
    R[i] = fractions.gcd(R[i+1],A[i])
 
M = [fractions.gcd(L[i-1],R[i]) for i in range(1,N+1)]
print(max(M))

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

for i in range(N):
    for j in range(N):
        if i == j:
            pass
        else:
            G.append(gcd(A[i], A[j]))
            

print(max(G))

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

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

Verdicts: Runtime Error

Runtime Error

Accepted