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):
# -*- coding: utf-8 -*-
import numpy as np

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

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

t = 0
created = 0

while 1:
    t += 1

    if t%A == 0:
        print("create t:", t)
        created += B

    if t >= T:
        break

print(created)


# -*- coding: utf-8 -*-
import numpy as np

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

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

t = 0
created = 0

while 1:
    t += 1

    if t%A == 0:
        #print("create t:", t)
        created += B

    if t >= T:
        break

print(created)


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 = 0
t += 0.5

ans += (t / a) * b
print(ans)

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

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

a, b, t = list(map(int, input().split()))
i = 0
print(a,b,t)
while (i * a) <= t:
    i += 1
print((i - 1) * b)

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

a, b, t = list(map(int, input().split()))
i = 0
while (i * a) <= t:
    i += 1
print((i - 1) * 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):
def gcd(a, b):
    while b:
        a, b = b, a%b
    return a

n=int(input())
al=input().split()
al_i = [int(s) for s in al]

if (n == 2):
   print(gcd(al_i[0],al_i[1]))
   return

fg = [0] * n
bg = [0] * n

for x in range(n):
   if (x == 0):
       fg[0] = al_i[0]
       y = 1
   else:
      while y <= x:
         fg[y] = gcd(fg[y-1], al_i[y])
         y += 1

for x in range(n):
   if (x == 0):
      bg[0] = al_i[n-1]
      y = 1
   else:
      while y <= x:
         bg[y] = gcd(bg[y-1], al_i[n-1-y])
         y += 1

m = 0
gm = 0

for x in range(n):
   if (x == 0):
      g = bg[n-2]
   elif (x == n):
      g = fg[n-2]
   else:
      g = gcd(fg[x-1],bg[n-2-x])
   if (g > gm):
      gm = g

print(gm)


import fractions
from functools import reduce

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

n=int(input())
al=input().split()
al_i = [int(s) for s in al]
m = max(al_i)
gm = 0

for x in range(n):
   t = al_i[x]
   al_i[x] = m
   g = gcd(*al_i)
   al_i[x] = t
   if g>gm:
      gm = g
print(gm)


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

ans = (t+0.5)//a*b

print(ans)

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

ans = (t+0.5)//a*b

print(int(ans))

Verdicts: Wrong Answer

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

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

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

a, b, t = map(int, input().split())
if a > t:
    print("0")
else:
    s = t//a
    print(b*s)

Verdicts: Wrong Answer

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

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

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

Verdicts: Runtime Error

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

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

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


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

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


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 = (int(x) for x in input().split())
t = t + 0.5

total = t/a * b
print(int(total))


a, b, t = (int(x) for x in input().split())
t = t + 0.5

total = t//a * b
print(int(total))


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

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):
inputstr1 = input().split()
n = inputstr1[0]
k = inputstr1[1]
s = input()

chars = list(s)
chars[int(k)-1]=chars[int(k)-1].lower()
correct = "".join(chars)
print(correct)

a, b, t = map(int,input().split())
i = 1
bisket = 0

while t+0.5 > i*a:
    bisket += b
    i += 1

print(bisket)


Verdicts: Runtime Error

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

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

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

def biscuit_generator(a, b, t):
    biscuit = 0
    n = 1
    t -= a
    while (t+0.5) > 0:
      biscuit += b
      n +=1

      t -= a * n
    return biscuit

print(biscuit_generator(A, B, T))


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

Runtime Error

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

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

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

print(answer)

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

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

print(answer)


A, B, T = map(int, input().split())
print(int(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())
ans = math.floor(t/a) * b
print(ans)

n = int(input())
list_v = map(int,input().split())
list_c = map(int,input().split())
 
ans = 0
for i in range(n):
  if list_v[i] - list_c[i] > 0:
    ans += list_v[i] - list_c[i]
print(int(ans))

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

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

import math

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

Verdicts: 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):
from fractions import gcd
N=int(input())
A=list(map(int,input().split()))
Asorted = sorted(A)


L=[0]*N
R=[0]*N
L[0]=A[0]
R[0]=A[N-1]

for n in range(1,N):
  L[n]=gcd(A[n],L[n-1])
  R[n]=gcd(A[N-n-1],R[n-1])
  
  ans=max(L[N-2],R[N-2])

for i in range(1,N-1):
  ans=max(ans,gcd(L[i-1],R[N-i-2]))

print(ans)

from fractions import gcd
N=int(input())
A=list(map(int,input().split()))
print(A)

L=[0]*N
R=[0]*N
L[0]=A[0]
R[0]=A[N-1]

for n in range(1,N):
  L[n]=gcd(A[n],L[n-1])
  R[n]=gcd(A[N-n-1],R[n-1])
  
  ans=max(L[N-2],R[N-2])

for i in range(1,N-1):
  ans=max(ans,gcd(L[i-1],R[N-i-2]))

print(ans)

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

for n in range(1,N):
  L[n]=gcd(A[n],L[n-1])
  R[n]=gcd(A[N-n-1],R[n-1])
  
  ans=max(L[N-2],R[N-2])

for i in range(1,N-1):
  ans=max(ans,gcd(L[i-1],R[N-i-2]))

print(ans)

from fractions import gcd
N=int(input())
A=list(map(int,input().split()))
A = sorted(A)[:: -1]


L=[0]*N
R=[0]*N
L[0]=A[0]
R[0]=A[N-1]

for n in range(1,N):
  L[n]=gcd(A[n],L[n-1])
  R[n]=gcd(A[N-n-1],R[n-1])
  
  ans=max(L[N-2],R[N-2])

for i in range(1,N-1):
  ans=max(ans,gcd(L[i-1],R[N-i-2]))

print(ans)

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

print(int((T+0.5)//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):
n=int(input()).split(" ")
A=n[0]
B=n[1]
T=n[2]

bis=int((T+0.5)/A)*B

n=input().split(" ")
A=int(n[0])
B=int(n[1])
T=int(n[2])
 
bis=int((T+0.5)/A)*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())
ans = int(b*(t+0.5)/a)
print(ans)

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

print(int(ans))

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

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

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

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

Verdicts: Wrong Answer

Wrong Answer

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

s = O
for i in range(N) :
    if V[i] > C[i]:
        s +=V[i] - C[i]
    
print(s)

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

print(biscuit)

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

i = int((T + 0.5) // A)

print(int(B * i))



A = int(input())

B = int(input())

T = int(input())

i = int((T + 0.5) // A)

print(int(B * i))




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

i = int((T + 0.5) // A)

print(int(B * i))

Verdicts: Runtime Error

Runtime Error

Runtime Error

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

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

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

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

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

ans = []
minus_num = 0

for num in a:
    if num < 0:
        ans.append( num * -1 )
        minus_num += 1
    else:
        ans.append( num )

if minus_num % 2 == 0:
    print(sum(ans))
else:
    ans.sort()
    print(sum(ans[1:]) + ans[0] * -1)

h = int(input())
w = int(input())
n = int(input())

if n / max(h, w) > n:
    print(n // max(h, w) + 1)
elif n / max(h, w) == 1:
    print(1)
elif n / max(h, w) < 1:
    print(1)
else:
    print(n // max(h, w))

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

ans = []
minus_num = 0

for num in a:
    if num < 0:
        ans.append( num * -1 )
        minus_num += 1
    else:
        ans.append( num )

if minus_num % 2 == 0:
    print(sum(ans))
else:
    ans.sort()
    print(sum(ans[1:]) + ans[0] * -1)

import math

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

print( math.floor(t / a) * b )

Verdicts: Runtime Error

Runtime Error

Runtime Error

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

Submission attempts (in order):
vb

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

using namespace std;

int main()
{
    int a,b,t;

    cin >> a >> b >> t;

    cout << t/a*b;

    return 0;
}

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

C = T//A
Ans = B*C
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())
 
ans=[]
while a<=t+0.5:
  ans.appen(b)
  a+=a
  
print(sum(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(a//t*b)

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

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

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

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

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

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

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

Verdicts: Wrong Answer

Wrong Answer

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

f = open('a.txt', 'r')
sys.stdin = f

li = list(input().split())

A=int(li[0])
B=int(li[1])
T=int(li[2])

print(B*(T/A))

#import sys,os

#f = open('a.txt', 'r')


li = list(input().split())

A=int(li[0])
B=int(li[1])
T=int(li[2])

print(B*(T/A))

abt = input()
abt = list(map(int, abt.split(" ")))
output = (abt[2] + 0.5 ) //  abt[0] * abt[1]
print(int(output))


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

A,B,T = list(map(float,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):
N = int(input())
A = [int(x) for x in input().split()]
seki = 1

for x in range(2,int(1000000000**0.5)+1):
    count = 0

    for y in range(N):
        if A[y] % x != 0:
            count += 1
        if count >= 2:
            break
    else:
        seki = x

for i in range(N):
    count = 0
    if A[i] < 1000000000**0.5+1:
        break
    for j in range(N):
        if A[i] % A[j] != 0:
            count += 1
        if count >= 2:
            break
    else:
        seki = A[i]

print(seki)

import fractions
from functools import reduce



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

N = int(input())
A = [int(x) for x in input().split()]
list = []
max = 1

for x in range(N):

    for y in range(N):
        if x != y:
            list.append(A[y])

    gcd = gcd_list(list)
    if gcd > max:
        max = gcd

print(max)

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

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

q = input()
p = q.split()
a = int(p[0])
b = int(p[1])
t = int(p[2])
c = (t+0.5)//a
print(int(c*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
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]

#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))
from functools import reduce

def segfunc(a,b):
    if a == 0 or b == 0:
        return max(a, b)
    if a < b:
        a, b = b, a
    r = a % b
    if r == 0:
        return b
    return segfunc(b, r)

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

def init(init_val):
    #set_val
    for i in range(n):
        seg[i+num-1]=init_val[i]    
    #built
    for i in range(num-2,-1,-1) :
        seg[i]=segfunc(seg[2*i+1],seg[2*i+2]) 
    
def update(k,x):
    k += num-1
    seg[k] = x
    while k:
        k = (k-1)//2
        seg[k] = segfunc(seg[k*2+1],seg[k*2+2])
    
def query(p,q):
    if q<=p:
        return ide_ele
    p += num-1
    q += num-2
    res=ide_ele
    while q-p>1:
        if p&1 == 0:
            res = segfunc(res,seg[p])
        if q&1 == 1:
            res = segfunc(res,seg[q])
            q -= 1
        p = p//2
        q = (q-1)//2
    if p == q:
        res = segfunc(res,seg[p])
    else:
        res = segfunc(segfunc(res,seg[p]),seg[q])
    return res


n = ii()

A = li()



ide_ele = 0

num =2**(n-1).bit_length()
seg=[ide_ele]*2*num

init(A)
ans = 0

#ans = max(query(1, n), ans)

for i in range(n):
    
    ans = max(segfunc(query(0, i), query(i+1, n)), ans)
#ans = max(query(0, n-1), ans)

print(ans)

import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]

#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))

A, B, T = mi()

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

a, b, c = [int(i) for i in input().split()]
d = a % c
print(b * d)

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

c = c + 0.5

d = c // a

print(b * d)

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

c = c + 0.5

d = c // a

print(int(b * d))

Verdicts: Wrong Answer

Wrong Answer

Wrong Answer

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

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

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

Verdicts: Wrong Answer

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

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

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

A,B,T=(map(float, input().split())) 
print(int((T+0.5)//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):
N = int(input())
V = list(map(int, input().split()))
C = list(map(int, input().split()))
ans = 0
for i in range(N):
  if V[i] > C[i]:
    ans += V[i]-C[i]
print(ans)

A = int(3)
B = int(5)
T = int(7)
print(((T+0.5)//A)*B)

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

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

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

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

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

Verdicts: Runtime Error

Wrong Answer

Runtime Error

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

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())
val = 0
ing_total=0
while val <= t + 0.5:
    ing_total += b
    val+=a


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

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


Verdicts: Wrong Answer

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

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

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

A,B,T=map(int, input().split())
t_max = int((T+0.5)/(A))
for t in range(t_max):
	bis += B*(t+1)
print(bis)

A, B, T map(int, input().split()) 
t_max = int((T+0.5)/A)
bis = 0
for t in range(t_max):
  bis += B*(t+1)
print(bis)

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

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

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):
# -*- coding: utf-8 -*-
a,b,t=map(int,input().split(" "))
count=0
tt=0
while tt<=t+0.5:
  count=count+1
  tt=tt+count*a
print(b*(count-1))

# -*- coding: utf-8 -*-
a,b,t=map(int,input().split(" "))
count=0
tt=0
while tt<=t+0.5:
  count=count+1
  tt=tt+a
print(b*(count-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):
A, B, T = map(int, input().split())
n = (T+0.5) // A
print(n * B)

A, B, T = map(int, input().split())
n = (T+0.5) // A
print('{}'.format(n*B))

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

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

(T // A) *B

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

Verdicts: Runtime Error

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

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


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

ans=[]

for i in range(3):
    B=A[:]
    del B[i]
    sol=0
    for b in B:
        sol=gcd(sol,b)
    ans.append(sol)


print(max(ans))



N = int(input())

A = list(map(int, input().split()))
C=list(set(A))

#print(A)
#print(C)
def gcd(a, b):
  while b > 0:
    a, b = b, a%b
  return a

anslist=[]

if len(C)==1:
  ans=C[0]

elif len(C)==2:
  sol=max(A[0],A[1])

else:
  for i in range(3):
    B=A[:]
    B.remove(C[i])
    sol=0
    for b in B:
        sol=gcd(sol,b)
    anslist.append(sol)
    ans=max(anslist)

#print(anslist)
print(ans)



A, B, T = map(int, input().split())
print(int((T+1/2)/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):
import numpy as np
import math

N = int(input())
A = np.array([int(i) for i in (input()).split(" ")])
minA = np.min(A)

if(minA == np.max(A)):
    print(minA)
else:
    check = np.unique(minA // np.arange(1,minA))
    #check = minA // np.arange(1,minA)
    for i in check[::-1]:
        
        
        num = np.sum((A % i>0))
        if(num < 2):
            j = A[np.where(A % i>0)][0]
            #print(i,j,i*j//math.gcd(i,j))
            if(i*j//math.gcd(i,j) < 10**9):
                print(i)
                break

import numpy as np
import fractions

N = int(input())
A = np.array([int(i) for i in (input()).split(" ")])
maxA = np.max(A)

if(maxA == np.min(A)):
    print(maxA)
else:
    check = np.unique(maxA // np.arange(1,maxA))
    #check = minA // np.arange(1,minA)
    for i in check[::-1]:
        
        
        num = np.sum((A % i>0))
        if(num < 2):
            print(i)
            break

a,b,t = map(int, (input()).split(" "))
n = t//a
print("{}".format(n*b,'d'))

Verdicts: Runtime Error

Runtime Error

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

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

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


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



Verdicts: Wrong Answer

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

Submission attempts (in order):
from math import gcd
from functools import reduce

n=int(input());Alist=list(map(int,input().split()))

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

M_list = []
for i in range(n):
    alist = Alist[:i] + Alist[i+1:]
    M_list.append(gcd_L(alist))

print(max(M_list))

from fractions import gcd
 
n,*a = map(int, open(0).read().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])))

from fractions import gcd
from functools import reduce

n=int(input());Alist=list(map(int,input().split()))

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

M_list = []
for i in range(n):
    alist = Alist[:i] + Alist[i+1:]
    M_list.append(gcd_L(alist))

print(max(M_list))

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

Verdicts: Runtime Error

Runtime Error

Runtime Error

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

Submission attempts (in order):

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

print(A//T*B)


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

print((A//T)*B)

A,B,T = list(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(str(((t+0.5) // a) * b))

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

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

def GCD(L):
  while(len(L)>1):
    a=min(L)
    M=map(lambda x: x%a, L)
    L=[a]+list(filter(lambda x: x!=0, M))
  return a

cogcd=[ 0 for i in range(N)]

for i in range(N):
  cogcd[i]=GCD(A[:i]+A[i+1:])

print(max(cogcd))

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

def GCD(a,b):
  if(a<b): a,b=b,a
  while(b!=0):
    a,b=b,a%b
  return a

cogcd=[0 for i in range(N)]
allgcd=GCD(A[0],A[1])
cogcd[0]=A[1]
cogcd[1]=A[0]

for i in range(2,N):
  for j in range(i):
    cogcd[j]=GCD(cogcd[j],A[i])
  cogcd[i]=allgcd
  allgcd=GCD(allgcd,A[i])
print(max(cogcd))

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

res = 0
for k in range(1,10000):
    now = k * a
    if now < t:
        res += b

print(res)        




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

res = 0
t = t + 1
for k in range(1,10000):
    now = k * a
    if now < t:
        res += b

print(res)


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

a,b,t=map(int,input().split())
C=int(t+0.5)//a*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())
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):
import fractions
from functools import reduce
import sys
n = int(sys.stdin.readline())
a = list(map(int,sys.stdin.readline().split()))
a2 = a.copy()
res = []
for i in range(0,n):
    a2.pop(i)
    res.append(reduce(fractions.gcd,a2))
    a2 = a.copy()
print(max(res))

def gcd(a,b):
    if(b==0): 
        return a 
    else: 
        return gcd(b,a%b)


n = int(input())
a = map(int,input().split())
a = list(map(int, a))
a1 = a
res = 0
count = 0
count1 = 0
for i in a:
    for j in a1:
        if count != count1 and gcd(i,j)>res:
            res = gcd(i,j)
        count1 = count1 + 1
    count = count + 1
    count1 = 0
print(res)

import fractions
import copy
from functools import reduce
 
def gcd_list(numbers):
    return reduce(fractions.gcd,numbers)
  
n = int(input())
a = list(map(int,input().split()))
a2 = copy.deepcopy(a)
res = []
for i in range(0,n):
    a2.pop(i)
    res.append(gcd_list(a2))
    a2 = copy.deepcopy(a)
print(max(res))

import fractions
import copy
from functools import reduce
import sys
def gcd_list(numbers):
    return reduce(fractions.gcd,numbers)
  
n = int(sys.stdin.readline())
a = list(map(int,sys.stdin.readline().split()))
a2 = copy.deepcopy(a)
res = []
for i in range(0,n):
    a2.pop(i)
    res.append(gcd_list(a2))
    a2 = copy.deepcopy(a)
print(max(res))

def gcd(a,b):
    if(b==0): 
        return a 
    else: 
        return gcd(b,a%b)

n = int(input())
a = list(map(int,input().split()))
res = []
for i in range(0,n):
    for j in range(0,n):
        if i != j:
            res.append(gcd(a[i],a[j]))
print(max(res))

import fractions
import copy

def gcd_list(numbers):
    ans = numbers[0]
    for i in range(1,n-1):
        ans = fractions.gcd(ans,numbers[i])
    return ans
  
n = int(input())
a = list(map(int,input().split()))
a2 = copy.deepcopy(a)
res = []
for i in range(0,n):
    a2.pop(i)
    res.append(gcd_list(a2))
    a2 = copy.deepcopy(a)
print(max(res))

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

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

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

[a,b,t]=list(map(int,input().split()))
c=(t//a)*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):
B*((T+0.5)//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):
ABC = input().rstrip().split(" ")
A = int(ABC[0])
B = int(ABC[1])
C = int(ABC[2])
count = (C+0.5)//A
print(count*B)


ABC = input().rstrip().split(" ")
A = int(ABC[0])
B = int(ABC[1])
C = int(ABC[2])
count=A//(C + 0.5)
print(count*B)

ABC = input().rstrip().split(" ")
A = int(ABC[0])
B = int(ABC[1])
C = int(ABC[2])
count = (C+0.5)//A
print(int(count*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):
import fractions
def gcd_list(list1):
    ans=list1[0]
    for i in range(len(list1)):
        ans=fractions.gcd(ans,list1[i])
    return ans
N=int(input())
A=list(map(int,input().split()))
n=0
for i in range(N):
    b=A[i]
    A.remove(A[i])
    m=gcd_list(A)
    n=max(n,m)
    A.insert(i,b)
print(n)

N=int(input())
A=list(map(int,input().split()))
n=0
for i in range(len(A)):
    if A[i]<0:
        n+=1
if n%2==0:
    ans=0
    for i in range(len(A)):
        ans+=abs(A[i])
if n%2==1:
    B=A
    for i in range(len(A)):
        B[i]=abs(A[i])
    minn=min(B)
    ans=0
    for i in range(len(A)):
        ans+=B[i]
    ans-=2*minn
print(ans)
    
        

A,B,T=map(int,input().split())
print(int(((T+0.5)//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):
from fractions import gcd
from functools import reduce
import copy

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

fValueList = []
lValueList = []
maxList = []

if n == 2:
  print(gcd(a[0], a[1]))
else:
  fValueList.append(a[0])
  lValueList.append(a[n-1])
  for i in range(1,n-1):
    g = fValueList[i-1]
    fValueList.append(gcd(g, a[i]))

  for i in range(1,n-1):
    g = lValueList[i-1]
    lValueList.append(gcd(g, a[n-1-i]))
  
  maxList.append(fValueList[n-1])
  maxList.append(lValueList[n-1])
  for k in range(n-2):
    g = gcd(fValueList[k], lValueList[n-2-k])
    maxList.append(g)
    
  print(max(maxList))


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())
n=t//a
print(b*n*(n+1)/2)

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

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

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

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

ans=t/a*b
print(int(ans))

import sys
import math

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

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

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

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

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


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

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


Verdicts: Wrong Answer

Accepted