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:
in_str = input()
str_num = in_str.split()
num = []
for i in range(3):
    num.append(int(str_num[i]))

bis = 0
i = 1

while True:
    if num[0] * i > num[2] + 0.5:
        break
    bis += num[1]
    i += 1

print(bis)

Submission status: Accepted

Solution code:
ABT=input().split()
A=[int(i) for i in ABT]
A[2]+=0.5
print(int(A[2]/A[0])*A[1])

Submission status: Accepted

Solution code:
A, B, C = [int(i) for i in input().split()] 
 
#n = int(input())
#e = [[int(i) for i in input().split()] for i in range(n)] 
# print(A, B, C)
# print(int(C / A) * C)
print(int(C / A) * B)

Submission status: Accepted

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

print(T // A * B)

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

Submission status: Accepted

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

print(t // a * b)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
from sys import stdin
# import numpy as np
# import sys
# sys.setrecursionlimit(10**4)

s_in = lambda: stdin.readline()[:-1]  # s = s_in()
d_in = lambda: int(stdin.readline())  # N = d_in()
ds_in = lambda: list(map(int, stdin.readline().split()))  # List = ds_in()


A, B, T = ds_in()

print(B * (T//A))

Submission status: Accepted

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

Submission status: Accepted

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

T = float(data[2]) + 0.5
A = int(data[0])
B = int(data[1])

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# A - Biscuit Generator

A, B, T = map(int, input().split())
ans = 0
T += 0.5

while T > A:
    T -= A
    ans += B
print(ans)

Submission status: Accepted

Solution code:
# A - Biscuit Generator

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

print((t//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:
#https://atcoder.jp/contests/abc125
# -*- coding: utf-8 -*-


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

count = 0
for i in range(t):
        if (i+1)%a is 0:
                count += b

print(count)

Submission status: Accepted

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

count  = int(t/a)

bis = count * b

print(bis)

Submission status: Accepted

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

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

Submission status: Accepted

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

print(B * (T // A))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

ans = 0
for i in range(T+1):
    if i >= A and 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:
cookle = 0
A,B,T =map(int ,input().split())
P = int(T/A)

for i in range (P+1):
    cookle = B*i

print(cookle)

Submission status: Accepted

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

Submission status: Accepted

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

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

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 -*-

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

Submission status: Accepted

Solution code:
A, B, T = [int(n) for n in input().split(' ')]
print(T//A*B)

Submission status: Accepted

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

print((T//A)*B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import exit

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

ans = 0

_A = A

while _A < T + 0.5:
    ans += B
    _A += A

print(ans)

Submission status: Accepted

Solution code:
#[A,B,T] = [20,20,19]
[A,B,T] = list(map(int,input().split()))
print((T // A)*B)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
a,b,t=map(int,input().split(" "))
t+=0.5
ans=0
if(t>a):
    ans=(t-t%a)/a*b
print(round(ans))

Submission status: Accepted

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

print(B*(T//A))

Submission status: Accepted

Solution code:
import sys
import subprocess
import re
import datetime
import os


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

print(ans)

Submission status: Accepted

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

# 何回生産出来るか
p = int((t+0.5)//a)

ans = p*b

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

bis_sum = 0
start = 0
end = A
while True:
    if start < T+0.5 and end > T+0.5:
        break
    start += A
    end += A
    bis_sum += B

print(bis_sum)

Submission status: Accepted

Solution code:
a, b, t = map(int, input().split())
cnt = 0
temp = a
while t+0.5 > temp:
    cnt += 1
    temp += a
print(b*cnt)

Submission status: Accepted

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

Submission status: Accepted

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


def solve(A: int, B: int, T: int):
    ret = (T // A) * B
    print(ret)
    return


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

Submission status: Accepted

Solution code:
A,B,T=map(int,input().split())
count=0
while T>=A:
	T=T-A
	count+=1
print(count*B)

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

Submission status: Accepted

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

i = 0
t += 0.5
while 1:
  t -= a
  if t < 0:
    break
  i += 1

i *= b
print(i)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

count = int(c/a)

print(count*b)

Submission status: Accepted

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

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

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

Submission status: Accepted

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

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

print(int(T/A)*B)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(T // A * B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from math import floor

# input process
inputData = input().split()
# A秒後
A = int(inputData[0])
# B枚ずつ
B = int(inputData[1])
# T+0.5秒後まで
T = int(inputData[2])

# calculation process
prodCount = int(floor((float(T) + 0.5) // float(A)))
biscuitTotal = prodCount * B

# output process
print(biscuitTotal)

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

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

Submission status: Accepted

Solution code:
import sys
a, b, t = map(int, sys.stdin.readline().split())
print((t//a) * b)

Submission status: Accepted

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

import sys
import copy

sys.setrecursionlimit(1000000)

# input = sys.stdin.readline

# ~~~~~~~~~~~~~~~~~~~~~_(＾～＾ ｣ ∠)_~~~~~~~~~~~~~~~~~~~~~

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

print(T // A * B)

Submission status: Accepted

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

print(B * (T // A))

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

print((T//A)*B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin

A, B, T = [int(x) for x in stdin.readline().rstrip().split()]

print((T // A) * B)

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:
import math

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

print(math.floor(T / 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:
N = list(input().split())
A = int(N[0])
B = int(N[1])
T = int(N[2])
time = int(T/A)
ans = time * B
print(ans)

Submission status: Accepted

Solution code:
a, b, t = map(int, (input().split()))
ans = 0
cnt = 1
while True:
  if a * cnt <= t + 0.5:
    ans += b
    cnt += 1
  else:
    break
    
print(ans)

Submission status: Accepted

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

count = T // A
bsc = B * count

print(bsc)

Submission status: Accepted

Solution code:
# /usr/bin/python
# -*- coding: utf-8 -*-
import sys
import math



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

print(t//a * b)

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(" "))
n = t//a
print("{}".format(n*b,'d'))

Submission status: Accepted

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

while time <= T:
    bis += B
    time += A

print(bis)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,t=map(int,input().split())
t2=t+0.5
for i in range(22):
  if a*i<t2 and a*(i+1)>t2:
    print(b*i)
    break

Submission status: Accepted

Solution code:
a, b, t = map(int, input().split())
i = 1
num = 0
while i <= t:
    if i % a == 0:
        num += b
    i += 1

print(num)

Submission status: Accepted

Solution code:
if __name__ == '__main__':
    line = input()
    [A, B, T] = map(int, line.rstrip().split())

    print(T // A * B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#abc125a

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

Submission status: Accepted

Solution code:
import sys 
A, B, T = list(map(int, sys.stdin.readline().strip().split()))
print(T // A * B)

Submission status: Accepted

Solution code:
a,b,t = map(int,input().split())
 
nums = range(1,21,1)
nums = list(map(lambda x: x * a, nums))
 
nums.append(t+0.5)
print(sorted(nums).index(t+0.5) * b)

Submission status: Accepted

Solution code:
s= 0
A,B,T=map(int,input().split())
for i in range(T//A):
  s+=B
print(s)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def get_result(A, B, T):
    return (T//A)*B

A, B, T = [int(s) for s in input().split(" ")]
result = get_result(A, B, T)
print(result )

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())
n=0
summ=0
while True:
  n+=1
  if(n*A>T):
    break
  else:
    summ+=B
print(summ)

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

Submission status: Accepted

Solution code:
# ABC125A - Biscuit Generator
a, b, t = list(map(int, input().rstrip().split()))
print(int((t + 0.5) // a * b))

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

s=raw_input().split()
a=int(s[0])
b=int(s[1])
t=int(s[2])

k=0
for i in range(a,t+1,a):
	k+=b
print(k)

Submission status: Accepted

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

times = (T + 0.5) // A
result = int(B * times)

print(result)

Submission status: Accepted

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

c = c + 0.5

d = c // a

print(int(b * d))

Submission status: Accepted

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

times = (T + 0.5) // A
result = int(B * times)

print(result)

Submission status: Accepted

Solution code:
l = [int(i) for i in input().split()]
print(int((l[2] + 0.5) // l[0] * l[1]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def biscuit_generator(A: int, B: int, T: int)->int:
    return (T//A) * B


if __name__ == "__main__":
    A, B, T = map(int, input().split())
    ans = biscuit_generator(A, B, T)
    print(ans)

Submission status: Accepted

Solution code:
A,B,T=map(int, input().split())  #複数数値入力　「A B」みたいなスペース空いた入力のとき

def calc_biscuit(A, B, T):
  	return int((T+0.5) /A)*B
    
print(calc_biscuit(A, B, T))

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B, T = input().split()
A_ = int(A)
B_ = int(B)
T_ = int(T)
#N回ビスケットを生産する
N = (T_ + 0.5)//A_
X = int(N*B_)
print(X)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin
##  input functions for me
def ria(sep = ''):
    if sep == '' :
        return list(map(int, input().split())) 
    else: return list(map(int, input().split(sep)))
def rsa(sep = ''):
    if sep == '' :
        return input().split() 
    else: return input().split(sep)
def ri(): return int(input())
def rd(): return float(input())
def rs(): return input()
##

## main ##

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

Submission status: Accepted

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

print(b * (t // a))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)


def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(A, B, T):
    return B * (T//A)


def main():
    A, B, T = read_int_n()
    print(slv(A, B, T))


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

for i , t in enumerate(range(200)):
    if i == 0 :
        continue;
    if i * a > T :
        break;
    result += b;

print(result)

Submission status: Accepted

Solution code:
a, b, t = list(map(int, input().split()))
print(sum([b for _ in range(a, t+1, a)]))

Submission status: Accepted

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

p=time*b
print(p)

Submission status: Accepted

Solution code:
a,b,t = (int(i) for i in input().split())
d = a
c = 0
if a>t :
    print(0)
else:
    while d<=t + 0.5:
        c = c + b
        d = d + a
    print(c)

Submission status: Accepted

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

Submission status: Accepted

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

print(calc)

Submission status: Accepted

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

print("{}".format(d * b))

Submission status: Accepted

Solution code:
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [A, B, T] = [int(input_raw[0]), int(input_raw[1]), int(input_raw[2])]
    print (T/A) * B

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
a, b , t = map(int, input().split())  #複数数値入力
count = 0

for i in range(1,t+1):
    an = a * i
    
    if an > t + 0.5:
        break
    count += 1
    

print(count * b)

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

Submission status: Accepted

Solution code:
i=list(map(int,input().split()))
a=i[2]+0.5
b=a//i[0]
c=b*i[1]
d=int(c)
print(d)

Submission status: Accepted

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

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:
C = list(map(float,input().split()))
c = C[0]
T = C[2]+0.5
Bis = 0
while(c<T):
      Bis += C[1]
      c += C[0]

print(int(Bis))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

cnt=0
bcnt=0

for i in range(1,30):
    cnt=i*A
    if cnt > T:
        break
    else:
        bcnt+=B

print(bcnt)

Submission status: Accepted

Solution code:
import os, sys, re, math

a,b,t = [s for s in input().split(' ')]
A = int(a)
B = int(b)
T = int(t) + 0.5
t = A
ret = 0
while  t < T:
  ret += B
  t += A

print(ret)

Submission status: Accepted

Solution code:
import math

abt = input().split()

count = math.floor(int(abt[2]) / int(abt[0])) * int(abt[1])
print(count)

Submission status: Accepted

Solution code:
A,B,T = [ int(e) for e in input().split()]
bis = 0;
i=1;

while (A*i) <= (T + 0.5):
    bis+=B;
    i+=1;

print(bis)

Submission status: Accepted

Solution code:
import numpy as np

#入力
N = input()
#入力値を取り出す
A, B, T = np.array(list(map(int,N.split( ))))

T = T + 0.5
S = 0
n = 1
A1 = A
while A1<T:
  n = n + 1
  A1 = n * A
  S = S + B
print (S)

Submission status: Accepted

Solution code:
a,b,t=(int(x) for x in input().split())
n=(t+0.5)//a
print(int(b*n))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

while i * A <= T:
  ans += B 
  i+=1
print(ans)

Submission status: Accepted

Solution code:
# A

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

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

Submission status: Accepted

Solution code:
# ビスケット生産装置を起動すると、起動してから A 秒後、2A 秒後、3A 秒後、
# ... (A の倍数秒後) に
# B枚ずつビスケットを生産します。
 
# ビスケット生産装置を起動してから T+0.5秒後までに生産されるビスケットの
# 合計枚数を求めてください。

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

cnt=1
sum=0
for i in range(T):

  if (i+1) % A*cnt == 0:
    sum=sum+B
    cnt=cnt+1
#    print(i+1,sum)
    
print(sum)

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:
def spaceinput():
    return list(map(int,input().split(" ")))

a,b,t=spaceinput()

print((t//a)*b)

Submission status: Accepted

Solution code:
import queue
 
(N,M,R) = (int(i) for i in input().split(" "))
 
 
print(int(R/N)*M)

Submission status: Accepted

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

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

print(ans)

Submission status: Accepted

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

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

ans = B * tmp

print(ans)

Submission status: Accepted

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

count = 0
while((count+1) * A < T+0.5):
     count += 1
print(B*count)

Submission status: Accepted

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

main()

Submission status: Accepted

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

x=t//a

print(x*b)

Submission status: Accepted

Solution code:
import re
import sys
from fractions import gcd
from functools import reduce
from itertools import product

import numpy as np

sys.setrecursionlimit(200000)


def input():
    return sys.stdin.readline()[:-1]


def ii(t: type = int):
    return t(input())


def il(t: type = int):
    return list(map(t, input().split()))


def imi(N: int, t: type = int):
    return [ii(t) for _ in range(N)]


def iml(N: int, t: type = int):
    return [il(t) for _ in range(N)]


def solve():
    A, B, T = il()
    ans = (T + 0.5) // A * B
    return int(ans)


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

Submission status: Accepted

Solution code:

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

N=(T+0.5)//A

print(int(N*B))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

t_unit,bis_unit,fin_time=map(int,input().split())
time=0
count=-bis_unit
fin_time=fin_time+0.5
while time <= fin_time:
    time+=t_unit
    count+=bis_unit

print(count)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin

A, B, T = [int(x) for x in stdin.readline().rstrip().split()]

times = int((T + 0.5) / A)
biscuits = B * times

print(biscuits)

exit(0)

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

Submission status: Accepted

Solution code:

import math

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

if __name__ == '__main__':
    a, b, t = read_input()

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

Submission status: Accepted

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

while True:
    kake += 1
    if A * kake > T:
        break  
print(B * (kake - 1))

Submission status: Accepted

Solution code:
mi = lambda: map(int, input().split())

A, B, T = mi()

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

Submission status: Accepted

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

i = 1
count = 0
while A*i <= (T+0.5):
  count += B
  i += 1
  
print(count)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

count = 0
num_bisket = 0
while True:
    count += A
    if count > T:
        break
    
    num_bisket += B
    

print(num_bisket)

Submission status: Accepted

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

Submission status: Accepted

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

def sum(a, b, x):
  sum = (x // a) * b
  return sum

a = int(str[0])
b = int(str[1])
x = int(str[2])

print(sum(a,b,x))

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(" ")))
count = 0
while True:
    count += 1
    time = count * a
    if time >= t + 0.5:
        break
print((count - 1) * b)

Submission status: Accepted

Solution code:
A,B,T = input().split()
A = int(A)
B = int(B)
T = int(T)
s = 0
for X in range(1,21):
  if A*X <= T + 0.5:
    s = B*X
  if A*X >=T + 0.5:
    break
print(s)

Submission status: Accepted

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

Submission status: Accepted

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

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

print(int(B * i))

Submission status: Accepted

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

Submission status: Accepted

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

T_time=T+0.5
x=int(T_time/A)

print(B*x)

Submission status: Accepted

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

Submission status: Accepted

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

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