AtCoder Beginner Contest 125 - Biscuit Generator

A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A 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-----
3 5 7

-----Sample Output-----
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.

Source: atcoder | Difficulty: EASY


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


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


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


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


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


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


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


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


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


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


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


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


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


(A, B, C) = [int(s) for s in input().split()]
print(C // A * B)


import sys
import numpy as np
(a, b, t) = map(int, input().split())
print(b * (t // a))


(t, mul, tl) = map(int, input().split())
print(tl // t * mul)


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


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


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


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


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


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


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


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


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


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


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


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

def main():
	ans = T // A * B
	print(ans)

def __starting_point():
	main()
__starting_point()


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


(A, B, T) = map(int, input().split())
time = A
cnt = 0
while time < T + 0.5:
	time += A
	cnt += B
print(cnt)


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


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


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


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


(N, M, K) = map(int, input().split())
print(K // N * M)


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


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


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


import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007

def main():
	(A, B, T) = list(map(int, readline().split()))
	print(T // A * B)
	return

def __starting_point():
	main()
__starting_point()


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


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


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


(A, B, T) = map(int, input().split())
print(len(range(A, T + 1, A)) * B)


(A, B, T) = map(int, input().split())
ans = 0
for i in range(1, 21):
	if A * i < T + 0.5:
		ans += B
print(ans)


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


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


(a, b, t) = map(int, open(0).read().split())
print(t // a * b)


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


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


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


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


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


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


rStr = input()
A = int(rStr.split(' ')[0])
B = int(rStr.split(' ')[1])
T = int(rStr.split(' ')[2])
result = int((T + 0.5) / A) * B
print(result)


(a, b, t) = list(map(int, input().split()))
ans = 0
now = a
while now <= t:
	ans += b
	now += a
print(ans)


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


(A, B, T) = map(int, input().split())
cnt = 0
while T >= A:
	cnt += B
	T -= A
print(cnt)


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

def __starting_point():
	main()
__starting_point()


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


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


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


(x, y, z) = map(int, input().split())
print(int(z / x) * y)


(n, m, k) = map(int, input().split())
print(k // n * m)


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


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


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


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


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


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


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


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


def mapt(fn, *args):
	return tuple(map(fn, *args))

def Input():
	return mapt(int, input().split(' '))

def main():
	(a, b, k) = Input()
	ans = k // a * b
	print(ans)
main()


(a, b, t) = list(map(int, input().split()))
time = 1
biscuit = 0
while time < t + 0.5:
	if time % a == 0:
		biscuit += b
	time += 1
print(biscuit)


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


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


def count_biscuits_num() -> int:
	(after_a_sec, making_per_a, until_sec) = map(int, input().split())
	limited_time = float(until_sec) + 0.5
	spent_time = after_a_sec
	total_making = 0
	while True:
		if limited_time >= spent_time:
			total_making += making_per_a
			spent_time += after_a_sec
		else:
			return total_making
print(count_biscuits_num())


(A, B, T) = [int(v) for v in input().split(' ')]
T += 0.5
total = 0
time = A
while True:
	if time < T:
		total += B
		time += A
	else:
		break
print(total)


number = input().split(' ')
A = int(number[0])
B = int(number[1])
T = int(number[2])
time = T // A
print(B * time)


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


(a, b, t) = map(int, input().split())
bis = 0
for i in range(1, 30):
	time = a * i
	if time < t + 0.5:
		bis += b
print(bis)


(A, B, T) = (int(X) for X in input().split())
print(T // A * B)


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


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


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


(A, B, T) = list(map(int, input().split()))
i = 1
ans = 0
while i * A <= T + 0.5:
	ans += B
	i += 1
print(ans)


(a, b, t) = map(int, input().split())
time = t + 0.5
num = 0
cnt = 1
mtime = cnt * a
while float(mtime) < time:
	num += b
	cnt = cnt + 1
	mtime = cnt * a
print(num)