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:
import importlib
import_module = lambda name:importlib.import_module(name)

input = import_module('sys').stdin.readline
input_int = lambda:int(input())
input_ints = lambda:map(int,input().split())
input_ints_list = lambda:list(input_ints())
input_str = lambda:input()
input_strs = lambda:input().split()
input_lines = lambda n,f:[f() for _ in range(n)]

gcd_base = lambda a,b:import_module('fractions').gcd(a,b) # 最大公約数（2値)
gcd = lambda a:import_module('functools').reduce(gcd_base,a) # 最大公約数（リスト）
lcm_base = lambda a,b:(a*b)//import_module('fractions').gcd(a,b) # 最小公倍数(2値)
lcm = lambda a:import_module('functools').reduce(lcm_base,a,1) # 最小公倍数(リスト)

permutations = lambda a,n:import_module('itertools').permutations(a,n) # 順列
combinations = lambda a,n:import_module('itertools').combinations(a,n) # 組み合わせ
product = lambda a,b:import_module('itertools').product(a,b) # 二つのリストの直積

init_array_1dim = lambda v,n:[v]*n
init_array_2dim = lambda v,n,m:[init_array_1dim for _ in range(m)]

# 四捨五入はround
ceil = lambda a:import_module('math').ceil(a) # 切り上げ
floor = lambda a:import_module('math').floor(a) # 切り捨て

# キュー
convert_list_to_queue = lambda a:import_module('collections').deque(a)
pop_q = lambda a:a.popleft()
push_q = lambda a,e:a.appendleft(e)
push_q_list = lambda a,l:a.extendleft(l) 

# プライオリティキュー
def init_head(a):import_module('heapq').heapify(a)
def heap_push(a,v):import_module('heapq').heappush(a,v)
heap_pop = lambda a:import_module('heapq').heappop(a) # 最小値を取り出す

# 二分探索
bisect_left = lambda a,x:import_module('bisect').bisect_left(a,x)
bisect_right = lambda a,x:import_module('bisect').bisect_left(a,x)
insert_left = lambda a,x:import_module('bisect').insert_left(a,bisect_left(a,x))
insert_right = lambda a,x:import_module('bisect').insert_right(a,bisect_right(a,x))

# 累積和、累積積、累積GCD
cumsum = lambda a:import_module('numpy').cumsum(import_module('numpy').array(a)) # 累積和
cumprod = lambda a:import_module('numpy').cumprod(import_module('numpy').array(a)) # 累積積
cumgcd = lambda a:import_module('numpy').frompyfunc(gcd, 2, 1).accumulate(a, dtype=import_module('numpy').object).astype(import_module('numpy').int) # 累積GCD

class UnionFind(object):
    def __init__(self, n):
        self.par = [i for i in range(n)]
        self.rank = [0 for _ in range(n)]
        self.size = [1 for _ in range(n)]

    def find(self, x):
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                x, y = y, x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            self.par[y] = x
            self.size[x] += self.size[y]

    def is_same(self, x, y):
        return self.find(x) == self.find(y)

    def get_size(self, x):
        x = self.find(x)
        return self.size[x]

# グラフで全部到達できる経路が何個あるか
def dfs_graph(v,n,graph,visited):
    if all(visited):return 1 # 全部到達できたら1を返す
    ans = 0
    for i in range(n):
        if not graph[v][i]:continue # 結ぶ線がないときはスキップ
        if visited[i]:continue # 到達済みだったらスキップ
        visited[i] = True
        ans += dfs_graph(i,n,graph,visited)
        visited[i] = False
    return ans

# ワーシャルフロイド（グラフの要素数、グラフ）
def warshall_floyd(n,graph):
    d = init_array_2dim(float("inf"),n,n)
    # 初期化
    for i in range(n):
        d[i][i] = 0
        for j in range(n):
            if graph[i][j]:d[i][j] = 1
    # 距離算出
    for k in range(n):
        for i in range(n):
            for j in range(n):
                d[i][j] = min(d[i][j],d[i][k] + d[k][j])
    return d

# グラフを初期化（グラフの要素数、グラフの線の両端、有向無向）
def init_graph(n,a,directed=False):
    visited = init_array_1dim(False,n)
    graph = init_array_2dim(False,n,n)
    for e in a:
        graph[e[0]-1][e[1]-1] = True
        if not directed:graph[e[1]-1][e[0]-1] = True # 無向グラフの場合
    return visited,graph

def two_pointers(s,threshold,ope='sum'):
    l,r = 0,0
    base = 0 
    if ope == 'sum':base = 0
    if ope == 'prd':base = 1
    diff = 0
    while r < len(s):
        val = 0
        if ope == 'sum':val = base+s[r]
        if ope == 'prd':val = base*s[r]
        if val <= threshold:
            if ope == 'sum':base += s[r]
            if ope == 'prd':base *= s[r]
            diff = max(diff, r-l+1)
            r += 1
        elif l == r:
            r += 1
            l += 1
        else:
            if ope == 'sum':base -= s[l]
            if ope == 'prd':base //= s[l]
            l += 1
    return diff

def solution():
    # ここに実装
    A,B,T = input_ints()
    print((T//A)*B)
	
if __name__ == '__main__':
    solution()

Submission status: Accepted

Solution code:
# coding: utf-8

data = input().split(" ")
during = int(data[0])
makes = int(data[1])
times = int(data[2])

work = times // during * makes

print(work)

Submission status: Accepted

Solution code:
loop, kosu, time = map(int, input().split(" "))
print(kosu * (time//loop))

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:
a, b, t = list(map(int, input().split()))
sum = 0
for i in range(int(t / a)):
    sum += b
print(sum)

Submission status: Accepted

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

t=1
b=0
while t<T+0.5:

    if(t%A==0):
        b = b + B
    
    t = t + 1

print(b)

Submission status: Accepted

Solution code:
def count_sum_generated_biscuit():
  generation_interval_sec,\
  biscuit_per_generation,\
  initial_target_sec = [int(x) for x in input().split()]
  
  target_sec = initial_target_sec + 0.5
  sum_generated_biscuit\
  = (target_sec // generation_interval_sec) * biscuit_per_generation
  
  return int(sum_generated_biscuit)
  
if __name__ == '__main__':
  print(count_sum_generated_biscuit())

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

time = T + 0.5

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

Submission status: Accepted

Solution code:

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

biscuit = 0

for i in range(A * 10, T*10 + 5, A * 10):
    biscuit += B

print(biscuit)

Submission status: Accepted

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

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
a, b, t = map(int, sys.stdin.readline().split())
total = (t//a)*b
print(total)

Submission status: Accepted

Solution code:
import sys
a, b, t = map(int, sys.stdin.readline().split())
total = 0
a_i = a
for i in range(1, t + 1, 1):
  if a_i <= i:
    total += b
    a_i = a_i + a
print(total)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    l = input().split()
    a, b, t = int(l[0]), int(l[1]), int(l[2])
    
    t = t + 0.5
    print(int(t/float(a))*b)

if __name__=="__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

tmp = t // a
ans = tmp * b

print(ans)

Submission status: Accepted

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

if T < A:
    pass
    
else:
    for i in range(A, T, A):
        #print(i)
        biscuit += B

print(biscuit)

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

Submission status: Accepted

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

Submission status: Accepted

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

i = 1

while i * a <= t:
	i += 1

print((i-1)*b)

Submission status: Accepted

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

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 = (int(x) for x in input().split())
print(int(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:
a=list(map(int,input().split()))
bisket=(a[2]//a[0])*a[1]
print(bisket)

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())
ans = 0
for i in range(1,100):
    if(i*a > t+0.5):
        break
    ans += b
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys

a,b,t = input().split()
A = int(a)
B = int(b)
T = int(t)

cnt = 0

i = A
while i < T + 0.5:
    cnt += B
    i += A

print(cnt)

Submission status: Accepted

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

Submission status: Accepted

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

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

bis = 0
i = 0
time = 0
while True:
    i +=1
    time += A
    if T+0.5>time:
        bis += B
    else:
        break
print(bis)

Submission status: Accepted

Solution code:
A, B, T = [int(s) if s.isdigit() else s for s in 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((t // a) * b)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

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

print(  (T // A) * B   )

Submission status: Accepted

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

k = t // a
if k >= 0:
  print(k * b)
elif a>t:
  print(0)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a,b,t = map(int,input().split())
ans = ((t - t%a)/a)*b
print(int(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 = (int(i) for i in input().split())
print(B * (T//A))

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

Submission status: Accepted

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

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

n = 0

while a*n <= t+0.5:
    n += 1

print(b*(n-1))

Submission status: Accepted

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

Submission status: Accepted

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

count = T//A

print(count*B)

Submission status: Accepted

Solution code:
def solve(a, b, t):
    return (t // a) * b

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

Submission status: Accepted

Solution code:
def solve():
    A, B, T = [int(_) for _ in raw_input().split()]
    ret = int((T + 0.5) / A) * B
    print str(ret)

if __name__ == '__main__':
    solve()

Submission status: Accepted

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

time = float(T) + 0.5
i = 1
bisk = 0

while A*i < time:
    bisk = bisk + B
    i = i+1

print(bisk)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
A, B, T = list(map(int, input().split()))
print(sum(B for i in range(A, T+1, A)))

Submission status: Accepted

Solution code:
inputs = list(map(int, input().split()))
 
A = inputs[0]
B = inputs[1]
T = inputs[2]
 
Q = int(T / A)
#print(Q)
X = Q* B
print(X)

Submission status: Accepted

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

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

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:
def input_nums():
    return [ int(i) for i in input().split(" ") ]
nums = input_nums()
A = nums[0]
B = nums[1]
T = nums[2]

biscut = 0
cnt = 1
for t in range(T):
	if (cnt==A):
		biscut += B
		cnt=1
	else:
		cnt+=1
print(biscut)

Submission status: Accepted

Solution code:
str=input().split(' ')
a,b,t=eval(str[0]),eval(str[1]),eval(str[2])
ans=0
a1=a
while a<=t+0.5:
  ans+=b
  a+=a1
print(ans)

Submission status: Accepted

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

print(b*(x//a))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(total)

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(b * (t // 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 = (int(i) for i in input().split()) 
j = 0
for i in range(21):
  if T >= i * A:
    j = i
ans = 0
ans = j * B
print(ans)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
span, num, period = map(float, input().split(' '))
print(int(((period + 0.5) // span) * num))

Submission status: Accepted

Solution code:
import math
val = input().split()
A = int(val[0])
B = int(val[1])
T = int(val[2])+0.5
print(math.floor(T/A)*B)

Submission status: Accepted

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

for i in range(1, 21):
    if a * i < t + 0.5:
        count += b

print(count)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/bin/env python
  
import sys

def validate(input):
    if input < 0 or input > 20:
        return False
    return True

def biscuitGen(input_a, input_b, input_t):
    biscuits = 0
    if validate(input_a) and validate(input_b) and validate(input_t):
        biscuits = int(input_t / input_a) * input_b
    return biscuits

if __name__=='__main__':
    '''
    print how many biscuit will be generated 
    A: Seconds to generate biscuit
    B: Number of biscuit pieces to generate once
    T: Limit of the seconds to generate biscuit
    1 <= A,B,T <= 20
    '''
    biscuit = 0
    inarray = list(map(int,input().split()))
    if len(inarray) != 3:
        print("Please input 3 numbers")
        sys.exit()
    biscuit = biscuitGen(inarray[0], inarray[1], inarray[2])
    print(biscuit)

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

Submission status: Accepted

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

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

n = T // A

sum = 0
for i in range(n):
  sum = sum + B
  
print(sum)

Submission status: Accepted

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

Submission status: Accepted

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

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

print(int(all_val))

Submission status: Accepted

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

d = a
e = 0

while d <= c:
  e += b
  d += a
  
print(e)

Submission status: Accepted

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

print(t//a*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(" "))
t = 0
count = 0
while True:
    t += a
    if t > c:
        print(count)
        exit()
    else:
        count += b
print(count)

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# A秒おきにB枚ずつ
# T秒後

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

print(int(t / a) * b)

Submission status: Accepted

Solution code:
# _*_ using utf-8 _*_

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

ans = (T//A) * B

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
list = input().split()
A = int(list[0])
B = int(list[1])
T = int(list[2])+0.5
now = 0
Biscuit = 0

while True:
    now += A
    if now <= T:
        Biscuit += B
    else:
        break

print(Biscuit)

Submission status: Accepted

Solution code:
#スペース区切りの整数の入力
A, B, T= map(int, input().split())
ans = (int(T/A))*B
print("{}".format(ans))

Submission status: Accepted

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

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

print(x * B)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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 = [int(x) for x in input().split()]

ans = B * (T // A)

print(ans)

Submission status: Accepted

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

S = 0

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

print(S)

Submission status: Accepted

Solution code:
#coding:utf-8

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


if __name__ == "__main__":
    biscuit()

Submission status: Accepted

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

#かけた回数と要素二番目をかける
result = T//i*j
print (result)

Submission status: Accepted

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

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

print(cookie)

Submission status: Accepted

Solution code:
aa, bb, tt = map(int, input().split())
nn = int((tt+0.5)/aa)
print(bb*nn)

Submission status: Accepted

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

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

print(count)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8

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

x = b * (t // a)
print(x)

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

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

print(b*(t//a))

Submission status: Accepted

Solution code:
A, B, T = map(int, input().split(" "))
if A>T:
    print(0)
else:
    count = (T-T%A)/A
    ans = B * count
    print(int(ans))

Submission status: Accepted

Solution code:
def main():

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

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

    print(int(ans))


if __name__ == "__main__":
    main()

Submission status: Accepted

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

while True:
    time += A
    if time > T:
        break
    count += B
print(count)

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
A,B,T=(int(x) for x in input().split())
if (T+0.5 > A):
    sum=(int(T/A))*B
else:
    sum=0
print(sum)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

x = floor((t+0.5)/a)
print(b*x)

Submission status: Accepted

Solution code:
#整数を入力
A,B,T=(int(x) for x in input().split())

#秒数を整数化、ビスケットの枚数を計算
y=(T+0.5)/A

z=B*int(y)

print(z)

Submission status: Accepted

Solution code:
a, b, c = map(int, input().split())
print("{}".format((c // 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 = [int(i) for i in input().split()]
ans = int(t/a) * b
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

print(result)

Submission status: Accepted

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

Submission status: Accepted

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

print((T//A)*B)

Submission status: Accepted

Solution code:
import sys
import math
input = sys.stdin.readline

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

Submission status: Accepted

Solution code:
from math import floor
import unittest


class BiscuitGenerator:
    def __init__(self, product_count, interval_sec):
        self.product_count = product_count
        self.interval_sec = interval_sec

    def product(self, second):
        return self.product_count * floor(second / self.interval_sec)


def parse_argument(input):
    args = [int(arg) for arg in input.split(" ")]
    return args


def main(input):
    args = parse_argument(input)
    generator = BiscuitGenerator(interval_sec=args[0], product_count=args[1])
    print(generator.product(args[2]))


if __name__ == "__main__":
    main(input())

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
data = input()
list = data.split(' ')
result = 0
for i in range(int(list[2])//int(list[0])):
  result += int(list[1])
print(result)