Problem:


Score : 100 points

Problem Statement

A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.

Find the total number of biscuits produced within T + 0.5 seconds after activation.

Constraints

All values in input are integers.

1 \leq A, B, T \leq 20

Input

Input is given from Standard Input in the following format:

A B T

Output

Print the total number of biscuits produced within T + 0.5 seconds after activation.

Sample Input 1

3 5 7

Sample Output 1

10

Five biscuits will be produced three seconds after activation.

Another five biscuits will be produced six seconds after activation.

Thus, a total of ten biscuits will be produced within 7.5 seconds after activation.

Sample Input 2

3 2 9

Sample Output 2

6

Sample Input 3

20 20 19

Sample Output 3

0



Sample input:
3 5 7


Sample output:
10

Submission status: Accepted

Solution code:
def main():
    a, b, t = list(map(int, input().split()))
    i = a
    count = 0
    while i < t + 0.5:
        count += b
        i += a

    print(count)


main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

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

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

print( (T) // A * B)

Submission status: Accepted

Solution code:
def main():
    ABT = input()
    ABT = list(map(int, ABT.split()))
    A = ABT[0]
    B = ABT[1]
    T = ABT[2]
    res = int((T+0.5)/A)*B
    print(res)
main()

Submission status: Accepted

Solution code:
a, b, t = map(int, raw_input().split())
s = 0
time = 0
while True:
    time += a
    if time > t + 0.5:
        break
    s += b
print(s)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import re
import math

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

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

Submission status: Accepted

Solution code:
A, B, T = (int(x) for x in input().split())
number =((T+0.5) // A) * B
print(int(number))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a = list(map(int, input().split()))
b = 0

for i in range(a[2]+1):
    if i != 0 and i % a[0] == 0:
        b += a[1]

print(b)

Submission status: Accepted

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

t = T + 0.5
times = int(t // A)

ans = 0
for i in range(times):
    ans = (i+1)*B

print(ans)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 27 20:57:04 2019

@author: Yamazaki Kenichi
"""

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

print(T//A*B)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
A, B ,T = map(int, input().split(' '))
print(int(int(T/A)*B))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

bsum = 0
for i in range(A, T + 1, A):
	#print(i)
	bsum += B
print(bsum)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B, T = map(int, raw_input().split())
print T/A*B

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 27 20:59:13 2019

@author: yuta
"""

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

def main(abt):
    a = abt[0]
    b = abt[1]
    t = abt[2]
    count = int(t/a)*b
    print(count)
main(ABT)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

print(b * int(T/a))

Submission status: Accepted

Solution code:
a, b, t = map(int, input().split())
rtn = 0
cnt = 1

while True:
    if a * cnt >= t + 0.5:
        break
    rtn += b
    cnt += 1

print(rtn)

Submission status: Accepted

Solution code:
I = list(map(int, input().split()))
A = I[0]
B = I[1]
T = I[2]

ans = (T // A) * B

print(ans)

Submission status: Accepted

Solution code:
line=input().split()

for i in range(len(line)):
    if i==2:
        t=int(line[2])
    elif i==1:
        b=int(line[i])
    else:
        a=int(line[i])

print(b*(t//a))

Submission status: Accepted

Solution code:
A,B,T = list(map(int,input().split()))
count = int((T+0.5)/A)
print(count*B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

i = a
c = 0
while i<=(t):
  #print(i,t+0.5)  
  c+=b
  i+=a;
  
print(c)

Submission status: Accepted

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

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

Submission status: Accepted

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

ans = T // A * B

print(ans)

Submission status: Accepted

Solution code:
# coding: utf-8
import re
import bisect
from datetime import datetime as dt

a, b, t = map(int, raw_input().split())
d = a
c = 0
while float(a) <= float(t) + 0.5:
    c += b
    a += d
print c

Submission status: Accepted

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

print(b * time)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a,b,t=map(int,input().split())
T=a
ans=0
while T<=t:
    ans+=b
    T+=a
print(ans)

Submission status: Accepted

Solution code:
A,B,T = map(int,input().split())
cnt=0
for i in range(1,T+1):
    if i % A ==0:
        cnt += B
print(cnt)

Submission status: Accepted

Solution code:
tmp_lst = input().split()

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

count = int(T / A) * B

print(count)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a, b, t = map(int,input().split())
counter = 0
c = a
while a <= t:
	counter += b
	a = a + c
print(counter)

Submission status: Accepted

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

cnt=-B
x=0
while x <= T:
    cnt += B
    x += A
print(cnt)

Submission status: Accepted

Solution code:
import math
a, b, t = map(int, input().split())
print(b * math.floor(t / a))

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys
def p(*a):
  s=" ".join(map(str,a))
  #print(s)
  sys.stderr.write(s+"\n")


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

print(t//a*b)

Submission status: Accepted

Solution code:
#A
A,B,T = map(int, input().split())

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

Submission status: Accepted

Solution code:
a,b,t=map(int,input().split())
i=(t+0.5)%a
c=(t+0.5-i)/a
print(int(c*b))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import sys
# ----------------------------------------------------------------
# Use Solve Function

def solve(lines):
    A,B,T = map(int, lines.pop(0).split(' '))
    res = 0
    S = A
    while S < T + 0.5:
        res += B
        S += A
    print(res)
lines = [x.strip() for x in sys.stdin.readlines()]
solve(lines)

Submission status: Accepted

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

print(B * int(T / A ))

Submission status: Accepted

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

i = 0
num = 0
while True:
    if i + a > t + 0.5:
        break
    i += a
    num += b

print(num)

Submission status: Accepted

Solution code:
A,B,T=map(int,input().split())
t=0
count=0
while True:
    t=t+A
    if t<T+0.5:
        count=count+B
    else:
        break
print(count)

Submission status: Accepted

Solution code:
in_list = input().split()
A = int(in_list[0])
B = int(in_list[1])
T = int(in_list[2])

count = 0

for i in range(int((T+0.5)/A)):
    count += B
    
print(count)

Submission status: Accepted

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

ans = 0
for i in range(A,T+1,A):
	ans += B
	#print(ans,i)
	
print(ans)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import math
import functools
import itertools
import numpy as np
import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

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

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

print(int(num))

Submission status: Accepted

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

sum = B * (T // A)
print(sum)

Submission status: Accepted

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

print(int(T / A) * B)

Submission status: Accepted

Solution code:
a, b, t = map(int, input().split())
time = 0
ans = 0
loop = 1

while True:
    time += loop * a
    if time > t + 0.5:
        break
    ans += b

print(ans)

Submission status: Accepted

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

a=0
ans = 0
for t in range(1,T+1):
	a += 1
	# print(t,a)
	if a == A:
		a=0
		ans+=B

print(ans)

Submission status: Accepted

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

num = t // a

print(num * b)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
a, b, t = map(int, input().split())
print((math.floor(t/a))*b)

Submission status: Accepted

Solution code:
import math
A, B, T= map(float, input().split())
r = math.floor(T / A) * B
print(int(r))

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

a = []

a = input().split()

print(int(a[1]) * (int(a[2]) // int(a[0])))

Submission status: Accepted

Solution code:
import sys
 
inp = map(int, raw_input().strip().split(" "))
 
print((inp[2]/(inp[0]))*inp[1])

Submission status: Accepted

Solution code:
a = input()
A=int(a.split()[0])
B=int(a.split()[1])
T=int(a.split()[2])

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

Submission status: Accepted

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

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

print(B * t)

Submission status: Accepted

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

x = int(t/a)

print(b*x)

Submission status: Accepted

Solution code:
# coding:utf-8


def main():
    A, B, T = map(int, input().split())
    ans = 0
    for i in range(1, T+1):
        if i % A == 0:
            ans += B
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
A, B, T = map(int,input().split())
a = T//A
print(a*B)

Submission status: Accepted

Solution code:
import sys
import collections
ns = lambda: sys.stdin.readline().rstrip()
ni = lambda: int(ns())
nm = lambda: map(int, sys.stdin.readline().split())
nl = lambda: list(nm())
nsl = lambda: map(str, sys.stdin.readline().split())

a, b, t = nm()
count = 0
aa = a
while(aa <= t + 0.5):
    count += b
    aa += a
print(count)

Submission status: Accepted

Solution code:
data = input()
split = data.split(' ')
A = int(split[0])
B = int(split[1])
T = int(split[2])

keika = A
goukei = 0

while keika < T + 0.5:
    goukei += B
    keika += A

print(goukei)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

print(math.floor(T / A) * B)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys

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

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

Submission status: Accepted

Solution code:
ll=lambda : list(map(int,input().split()))
[A,B,T]=ll()
print(int((T+0.5)//A)*B)

Submission status: Accepted

Solution code:
a,b,t=map(int,input().split())
c = (t+0.5)
d = c//a
print(int(d*b))

Submission status: Accepted

Solution code:
def a():
    N = raw_input().split(" ")
    A = int(N[0])
    B = int(N[1])
    T = int(N[2])

    print T / A * B


def main():
    a()
	
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
A=list(map(int,input().split()))
T=int((A[2]+0.5)/A[0])
print(A[1]*T)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
a,b,t = map(int, input().split())
print(math.floor(t/a) *b)

Submission status: Accepted

Solution code:
str =input().split()

a = int(int(str[2])/int(str[0]))

print(a*int(str[1]))

Submission status: Accepted

Solution code:
a,b,c = input().split()

print(int(int(c)/int(a))*int(b))

Submission status: Accepted

Solution code:
mount_list = list(map(int, input().split()))

print(mount_list[1]*(mount_list[2]//mount_list[0]))

Submission status: Accepted

Solution code:
A, B, T = map(int, input().strip().split(' '))

print(B*int(T/A))

Submission status: Accepted

Solution code:
import sys
# gcd
# from fractions import gcd
# 切り上げ，切り捨て
# from math import ceil, floor
# リストの真のコピー（変更が伝播しない）
# from copy import deepcopy
# 累積和。list(accumulate(A))としてAの累積和
# from itertools import accumulate
# l = ['a', 'b', 'b', 'c', 'b', 'a', 'c', 'c', 'b', 'c', 'b', 'a']
# S = Counter(l)  # カウンタークラスが作られる。S=Counter({'b': 5, 'c': 4, 'a': 3})
# print(S.most_common(2))  # [('b', 5), ('c', 4)]
# print(S.keys())  # dict_keys(['a', 'b', 'c'])
# print(S.values())  # dict_values([3, 5, 4])
# print(S.items())  # dict_items([('a', 3), ('b', 5), ('c', 4)])
# from collections import Counter
#
# input関係の定義
input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def li(): return list(input().rstrip())
# template


A, B, T = mi()

print(B * (T // A))

Submission status: Accepted

Solution code:
A, B, T = (int(i) for i in input().split())
print(int(T/A)*B)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# スペース区切りの整数の入力
a, b, t = map(int, input().split())

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
inpl = lambda: list(map(int,input().split()))
A, B, T = inpl()
print(B*(T//A))

Submission status: Accepted

Solution code:
a,b,t=map(int,input().split())
ans=0
for i in range(1,t+1):
    if i%a==0:
        ans+=b

print(ans)

Submission status: Accepted

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

print((T // A) * B)

Submission status: Accepted

Solution code:
A, B, T = map(int, input().split())
cookies = 0

for i in range(1,T+1):
    if i % A == 0:
        cookies += B
        
print(cookies)

Submission status: Accepted

Solution code:

if __name__ == '__main__':
    a,b,t = list(map(int, input().split()))
    t = t + 0.5

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a,b,t = list(map(int, input().split()))

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

Submission status: Accepted

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

cnt = 0
time = 0
while(1):
  if time > t:
    break
  cnt += b
  time += a
cnt -= b
print(cnt)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

print(int(t / a) * b)

Submission status: Accepted

Solution code:
k = input().split()
a = int(k[0])
b = int(k[1])
t = int(k[2])

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

Submission status: Accepted

Solution code:
def main():
    result = sub()
    print(result)


def sub():
    A, B, T = [int(x) for x in (input().split())]
    n = T / A
    return int(n) * B


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
A, B, T = map(int, input().split())
ans = B*(T // A)
print(ans)

Submission status: Accepted

Solution code:
a,b,t = [int(_) for _ in input().split()]

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

Submission status: Accepted

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

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

Submission status: Accepted

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

sum = 0

for i in range(A,T+1,A):
    sum += B

print(sum)

Submission status: Accepted

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



print(T//A*B)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
def main():
    A, B, T = map(int, input().split())

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

    print(B * times)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
#スペース入力
num = input().split()

T = int(num[2]) + 0.5

B = int(num[1])
A = int(num[0])

result = 0
t= A


while t < T:
    result = result + B
    t = t + A


print(result)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
x = input().split()
a = int(x[0])
b = int(x[1])
t = int(x[2])
print(int(((t+0.5)//a)*b))

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

A,B,T=MAP()
T+=0.5
print(int((T//A)*B))

Submission status: Accepted

Solution code:
a, b, t = map(int, input().split())
result = t // a * b
print(result)

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline


def main():
    a, b, t = [int(i) for i in input().split()]
    print(t // a * b)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
a,b,t = list(map(int,input().split()))
time = a
s = 0
while(time <= t + 0.5):
	s += b
	time += a
print(s)

Submission status: Accepted

Solution code:
A, B, T = map(int, input().split())
m = T//A
print(int(m*B))

Submission status: Accepted

Solution code:
import sys
input=sys.stdin.readline
A=list(map(int,input().split()))
print(int((A[2]+0.5)//A[0]*A[1]))

Submission status: Accepted

Solution code:
import numpy as np

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

time = T + 0.5
cnt = 0
while time > 0:
    time = time - A
    cnt += 1

if cnt != 0:
    cnt = cnt - 1

print(B * cnt)

Submission status: Accepted

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

Submission status: Accepted

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

S = T + 0.5

X = B * (S // A)

print(int(X))

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!

inp = input().split()

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

step = int(T / A)
count = B * step

print(count)

Submission status: Accepted

Solution code:
A, B, T = [int(x) for x in input().split(" ")]
s = 0
i = A
while i <= T + 0.5:
    s += B
    i += A

print(s)

Submission status: Accepted

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

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

Submission status: Accepted

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

print(int(t/a)*b)

Submission status: Accepted

Solution code:
import numpy as np
huga = list(map(int, input().split()))

A=huga[0]
B=huga[1]
T=huga[2]+0.5
u=T//A
v=u*B

print(round(v))

Submission status: Accepted

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


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


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


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


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


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

a,b,t=MAP()

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    A, B, T = map(int, input().split())

    t = A
    count = 0
    while t <= T:
        t += A
        count += B

    print(count)

main()

Submission status: Accepted

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

print(t // a * b)

Submission status: Accepted

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

biscuit = (T // A) * B
print(biscuit)

Submission status: Accepted

Solution code:
from collections import defaultdict
from string import ascii_uppercase
import sys, bisect, math
stdin = sys.stdin
read_int = lambda : list(map(int,stdin.readline().split()))
read_str = lambda : stdin.readline().rstrip()

a,b,t = read_int()

def solve():
    ans = 0
    c = int((t + 0.5) // a)
    ans = b*c
    return ans

if __name__ == "__main__":
    print(solve())

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a = input().split()
A = int(a[0])
B = int(a[1])
T = int(a[2])
C = T//A
res = C*B
print(res)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, b, t = map(int, input().split())
ans = 0

for i in range(100):
  if a * (i+1) <= t:
    ans += b

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding=utf-8

if __name__ == '__main__':
    A, B, T = map(int, input().split())
    print(int(((T+0.5)//A)*B))

Submission status: Accepted

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

qtd = (t+0.5)/a

qtd = int(qtd)

print(qtd*b)

Submission status: Accepted

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

count = 0
for i in range(0,T+1):
    if i % A == 0:
        count += B
print(count - B)

Submission status: Accepted

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

t = t + 0.5

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

Submission status: Accepted

Solution code:
def main():
    a, b, t = map(int, (input().split()))

    print((t//a)*b)
    # 3 5 7

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
A, B, T  = [int(i) for i in input().split()]



    
print(int(T/A) * B)

Submission status: Accepted

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

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

Submission status: Accepted

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

n = T // A
print(n * B)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
A,B,T= input().split() 
X=int(T)/int(A)
#print(X)
print(int(X)*int(B))

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
a,b,t = map(int, input().split())

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

Submission status: Accepted

Solution code:
import sys
import math

A, B, T = map(int, sys.stdin.readline().split())

time = math.floor(T/A)

print(B*time)

Submission status: Accepted

Solution code:
A, B, T = map(int, input().split())
t = T + 0.5
count = t//A
print(int(B*count))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
import io
import math
import re

datalist = input().split()
data_a = int(datalist[0])
data_b = int(datalist[1])
data_c = int(datalist[2])


print(int(data_c/data_a)*data_b)

Submission status: Accepted

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


if __name__ == '__main__':
    solve()

Submission status: Accepted

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

Submission status: Accepted

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

print((t//a)*b)

Submission status: Accepted

Solution code:
I=lambda:list(map(int,input().split()))
A,B,T=I()
print(T//A*B)

Submission status: Accepted

Solution code:
num_list = list(map(int, input().split()))
print(int(num_list[2] / num_list[0])* num_list[1])

Submission status: Accepted

Solution code:
import math
A, B, T = map(int, input().split())
answer = math.floor(T/A)*B
print("{}".format(answer))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    A, B, T = map(int, input().split())
    print(int((T + 0.5) // A * B))
main()

Submission status: Accepted

Solution code:
#!/usr/bin/env python
a, b, t = map(int, input().split())

count = 0
for i in range(1,21):
    if a * i <= t:
        count += 1
    else:
        break
print(count*b)

Submission status: Accepted

Solution code:
elem = input().split()
a = int(elem[0])
b = int(elem[1]) 
t = int(elem[2])
    
ans = (t // a) * b


print(ans)

Submission status: Accepted

Solution code:
A,B,T = map(int,input().split(" "))
ans = 0
if T % A == 0:
    print(int(B * (T / A)))
    #print("just")
else:
    for i in range(int(T / A)):
        ans += B
    print(ans)

Submission status: Accepted

Solution code:
def main():
    A, B, T = map(int, input().split())
    print(T // A * B)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

time = a
out = 0

while time <= t:
    out += b
    time += a

print(out)

Submission status: Accepted

Solution code:
a, b, t = map(int, input().split())
t = t+0.5
for i in range(100):
    if i * a <= t <= (i + 1) * a:
        print(i * b)
        exit()

Submission status: Accepted

Solution code:
a,b,c = map(int, input().split(' '))
r = 0
for i in range(1,c+1):
  if i%a == 0:
    r += b
print(r)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B,C = map(int,input().split())
D=(C+0.5)//A
print(B*int(D))

Submission status: Accepted

Solution code:
import math
import re

a,b,t = raw_input().split()
#s = list(raw_input())

a = int(a)
b = int(b)
t = int(t)

now = a
total = 0
while True:
    if now < t + 0.5:
        total += b
        now += a
    else:
        break

print total

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a, b, t = input().split(" ")
biscuit = (float(t)+0.5) // float(a) 
print(round(biscuit*int(b)))

Submission status: Accepted

Solution code:
import sys
from collections import Counter

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

print(str(int(b * int(t / a))))

Submission status: Accepted

Solution code:
A,B,T= list(map(int,input().split()))
print(int(T/A)*B)

Submission status: Accepted

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

ans = T // A * B
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#Biscuit Generator

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

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

def main():
    print(answer())


if __name__ == '__main__':
    main()

Submission status: Accepted

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

s = b * (t//a)

print(s)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
import sys
import math


def solve(A: int, B: int, T: int):
    print(math.floor(T/A)*B)
    return


# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    T = int(next(tokens))  # type: int
    solve(A, B, T)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a = [int(x) for x in input().split()]
count = 0
T = a[2]
while (T >= a[0]):
  count += a[1]
  T -= a[0]
print(count)

Submission status: Accepted

Solution code:
A, B, T = [int(i) for i in input().split()]
t = A
s = 0

while t <= T:
    s += B
    t += A

print(s)

Submission status: Accepted

Solution code:
data = input().split()
A = int(data[0])
B = int(data[1])
T = int(data[2])
print( int( ( T - (T % A) ) / A ) * B )

Submission status: Accepted

Solution code:
import numpy as np

s = input().split()
a = int(s[0])
b = int(s[1])
c = int(s[2])+0.5

w = np.floor(c/a)*b

print(int(w))

Submission status: Accepted

Solution code:
a,b,t = map(int,input().split())
s = t//a
print(b*s)

Submission status: Accepted

Solution code:
A,B,T = map(int,input().split())
ans = 0
while(A<=T):
        ans += B
        T -= A
print(ans)

Submission status: Accepted

Solution code:
[a,b,t] = map(int,input().split(" "))
print((t//a)*b)