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

Submission status: Accepted

Solution code:
a, b, n = [int(i) for i in input().split(" ")]
print(n // 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:
# -*- coding: utf-8 -*-
def inpl(): return list(map(int, input().split()))
A, B, T = inpl()
ans = 0
for i in range(1, T+1):
    if i%A == 0:
        ans += B
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, b, t = map(int,open(0).read().split())

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

Submission status: Accepted

Solution code:
import math

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

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

print(c // a * b  )

Submission status: Accepted

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

Submission status: Accepted

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

print(b * int(t / a))

Submission status: Accepted

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

print((t//a)*b)

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
from sys import stdin
import math

a, b, t = [int(x) for x in stdin.readline().rstrip().split()]

sum = math.floor(t / a) * b

print(sum)

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from sys import stdin
A,B,T = [int(_) for _ in stdin.readline().rstrip().split()]
print(T//A*B)

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:
#!/usr/bin/env python3


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
cnt=0
while time<=t+0.5:
    time+=a
    cnt+=b

print(cnt)

Submission status: Accepted

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

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

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

if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
# [input]
# n = int(input())
# (string) s = input()
# a, b, c = map(int, input().split())
# h = list(map(int, input().split()))


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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
#https://atcoder.jp/contests/abc125/tasks/abc125_a

ABT = [int(i) for i in input().split()]
A = ABT[0]
B = ABT[1]
T = ABT[2]

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import atexit
import io
import sys

buff = io.BytesIO()
sys.stdout = buff


@atexit.register
def write():
    sys.__stdout__.write(buff.getvalue())

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

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

print((t//a)*b)

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:

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

print(T//A * B)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
a,b,t = input().split()
a = int(a)
b = int(b)
t = int(t)
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 = 0
for i in range(1, T+1):
    if i % A == 0:
        ans += 1
print(ans*B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B, T = map(int,input().split())
ans = 0
for t in range(1,T+1):
    if t%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 = [int(a) for a in input().split()]

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
# import bisect
# import math
# import itertools
# import numpy as np
# import collections

"""Template"""


class IP:
    """
    入力を取得するクラス
    """

    def __init__(self):
        self.input = sys.stdin.readline

    def I(self):
        """
        1文字の取得に使います
        :return: int
        """
        return int(self.input())

    def S(self):
        """
        1文字の取得(str
        :return: str
        """
        return self.input()

    def IL(self):
        """
        1行を空白で区切りリストにします(int
        :return: リスト
        """
        return list(map(int, self.input().split()))

    def SL(self):
        """
        1行の文字列を空白区切りでリストにします
        :return: リスト
        """
        return list(map(str, self.input().split()))

    def ILS(self, n):
        """
        1列丸々取得します(int
        :param n: 行数
        :return: リスト
        """
        return [int(self.input()) for _ in range(n)]

    def SLS(self, n):
        """
        1列丸々取得します（str
        :param n: 行数
        :return: リスト
        """
        return [self.input() for _ in range(n)]

    def SILS(self, n):
        """
        Some Int LineS
        横に複数、縦にも複数
        :param n: 行数
        :return: list
        """
        return [self.IL() for _ in range(n)]

    def SSLS(self, n):
        """
        Some String LineS
        :param n: 行数
        :return: list
        """
        return [self.SL() for _ in range(n)]


class Idea:
    def __init__(self):
        pass

    def HF(self, p):
        """
        Half enumeration
        半分全列挙です
        pの要素の和の組み合わせを作ります。
        ソート、重複削除行います
        :param p: list : 元となるリスト
        :return: list : 組み合わせられた和のリスト
        """
        return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))

    def Bfs2(self, a):
        """
        bit_full_search2
        bit全探索の改良版
        全探索させたら2進数のリストと10進数のリストを返す
        :return: list２つ : １個目 2進数(16桁)  2個目 10進数
        """
        # 参考
        # https://blog.rossywhite.com/2018/08/06/bit-search/
        # https://atcoder.jp/contests/abc105/submissions/4088632
        value = []
        for i in range(1 << len(a)):
            output = []

            for j in range(len(a)):
                if self.bit_o(i, j):
                    """右からj+1番目のiが1かどうか判定"""
                    # output.append(a[j])
                    output.append(a[j])
            value.append([format(i, 'b').zfill(16), sum(output)])

        value.sort(key=lambda x: x[1])
        bin = [value[k][0] for k in range(len(value))]
        val = [value[k][1] for k in range(len(value))]
        return bin, val

    def S(self, s, r=0, m=-1):
        """
        ソート関係行います。色々な設定あります。
        :param s: 元となるリスト
        :param r: reversするかどうか 0=False 1=True
        :param m: （2次元配列）何番目のインデックスのソートなのか
        :return: None
        """
        r = bool(r)
        if m == -1:
            s.sort(reverse=r)
        else:
            s.sort(reverse=r, key=lambda x: x[m])

    def bit_n(self, a, b):
        """
        bit探索で使います。0以上のときにTrue出します
        自然数だからn
        :param a: int
        :param b: int
        :return: bool
        """
        return bool((a >> b & 1) > 0)

    def bit_o(self, a, b):
        """
        bit探索で使います。1のときにTrue出すよ
        oneで1
        :param a: int
        :param b: int
        :return: bool
        """
        return bool(((a >> b) & 1) == 1)

    def ceil(self, x, y):
        """
        Round up
        小数点切り上げ割り算
        :param x: int
        :param y: int
        :return: int
        """
        return -(-x // y)

    def ave(self, a):
        """
        平均を求めます
        :param a: list
        :return: int
        """
        return sum(a) / len(a)

    def gcd(self, x, y):
        if y == 0:
            return x
        else:
            return self.gcd(y, x % y)


"""ここからメインコード"""


def main():
    # 1文字に省略
    r, e, p = range, enumerate, print
    ip = IP()
    id = Idea()
    mod = 10 ** 9 + 7

    """この下から書いてね"""
    a, b, t = ip.IL()
    print(int(((t+0.5) // a) * b))


main()

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

Submission status: Accepted

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

result = int(t/a) * b

print(result)

Submission status: Accepted

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

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

Submission status: Accepted

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

tmp = (T+0.5) // A

print(int(B*tmp))

Submission status: Accepted

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

T = T + 0.5

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

Submission status: Accepted

Solution code:
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque, OrderedDict
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from math import ceil, floor
from sys import setrecursionlimit

import heapq
import itertools
import operator


# globals
inf = float('inf')
N = 0


def set_inputs():
    global N
    return


def main():
    setrecursionlimit(100000)
    set_inputs()
    # ----------MAIN----------
    a, b, t = get_li()
    print((t // a) * b)
    return


def get_int():
    return int(input())


def get_float():
    return float(input())


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


def get_li():
    return [int(i) for i in input().split()]


def get_lf():
    return [float(f) for f in input().split()]


def get_lc():
    return list(input().strip())


def get_data(n, types, sep=None):
    if len(types) == 1:
        return [types[0](input()) for _ in range(n)]
    return list(zip(*(
        [t(x) for t, x in zip(types, input().split(sep=sep))]
        for _ in range(n)
    )))


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def main():
    input = sys.stdin.readline
    try:
        a,b,t = map(int, input().split())
        result = 0
        for i in range(a, t+1, a):
            result += b
        print(result)

    finally:
        input = None

import sys; sys.setrecursionlimit(50000)
if __name__ == "__main__":
    main()

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

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

Submission status: Accepted

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

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:
from operator import itemgetter
import sys
sys.setrecursionlimit(1000000)


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

print((t//a)*b)

Submission status: Accepted

Solution code:
a,b,t = map(int,input().split())
now = 0
ans = 0
while now+a < t+0.5:
    now += a
    ans += 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 = (int(x) for x in input().split())

print(int(T/A) * B)

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:
a, b, t = [int(elem) for elem in input().split()]

print(b * (t // a))

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

Submission status: Accepted

Solution code:
#125 A

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

print(b*(c//a))

Submission status: Accepted

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

print(B*(T // A))

Submission status: Accepted

Solution code:
words = lambda t : list(map(t, input().split()))
a,b,t = words(int)
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, raw_input().split())

val = int(T / A)

print (B * val)

Submission status: Accepted

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

res = (n//a)*b 

print(res)

Submission status: Accepted

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

print(int(t / a) * b)

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 = [int(item) for item in 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:
a,b,t = map(int,input().split())

x = t//a

print(x*b)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from heapq import heappush,heappop
import queue
import re

def int_raw():
    return int(input())

def ss_raw():
    return input().split()

def ints_raw():
    return list(map(int, ss_raw()))

INF = 1<<29

def make1d_arr(n,val=INF):
    return [val for i in range(n)]

def make2d_arr(h,w,val =INF):
    return [[val for i in range(w)]for i in range(h)]


A,B,T = ints_raw()


def main():

    return (T//A)*B
    
print(main())

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

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

Submission status: Accepted

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

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

num = t//a

print(b*num)

Submission status: Accepted

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

print(int(t/a)*b)

Submission status: Accepted

Solution code:

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

Submission status: Accepted

Solution code:


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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

print((T // A) * B )

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

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

Submission status: Accepted

Solution code:
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    a,b,t = f()
    print(t//a *b)

solve()

Submission status: Accepted

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

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

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

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(i) for i in 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())
num = 0
for _ in range(A, T + 1, A):
    num += B
print(num)

Submission status: Accepted

Solution code:
from functools import reduce
import math

def main():
    # 文字列の2進数を数値にする
    # '101' → '5'
    # 文字列の頭に'0b'をつけてint()にわたす
    # binary = int('0b'+'101',0)

    # 2進数で立っているbitを数える
    # 101(0x5) → 2
    # cnt_bit = bin(5).count('1')
    
    # N! を求める
    # f = math.factorial(N)

    # N の逆元
    # N_inv = pow(N,MOD-2,MOD)

    # nCr
    # Nの階乗 * rの階乗の逆元 * n-rの階乗の逆元
    
    # 切り捨て
    # 4 // 3
    # 切り上げ
    #-(-4 // 3)
    
    # 初期値用:十分大きい数(100億)
    INF = float("inf")

    # 大きな素数
    MOD = 10**9+7
    
    # 1文字のみを読み込み
    # 入力:2
    # a = input().rstrip()
    # 変数:a='2'
    
    # スペース区切りで標準入力を配列として読み込み
    # 入力:2 4 5 7
    # a, b, c, d = (int(_) for _ in input().split())  
    # 変数:a=2 b=4 c=5 d =7
    
    # 1文字ずつ標準入力を配列として読み込み
    # 入力:2 4 5 7
    # a = list(int(_) for _ in input().split())
    # 変数:a = [2, 4, 5, 7]    

    # 1文字ずつ標準入力を配列として読み込み
    # 入力:2457
    # a = list(int(_) for _ in input())
    # 変数:a = [2, 4, 5, 7]    
    a, b, t = (int(_) for _ in input().split())
    
    print((t//a)*b)
    
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:
import sys

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

Submission status: Accepted

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

Submission status: Accepted

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

print(int(c/a) *b)

Submission status: Accepted

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

Submission status: Accepted

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


main()

Submission status: Accepted

Solution code:
import sys
stdin = sys.stdin
 
sys.setrecursionlimit(10**5) 
 
def li(): return map(int, stdin.readline().split())
def li_(): return map(lambda x: int(x)-1, stdin.readline().split())
def lf(): return map(float, stdin.readline().split())
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())

a,b,t = li()
print(b * (t//a))

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:
# encoding:utf-8
import copy
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math

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

ans = (T//A)*B

print(ans)

Submission status: Accepted

Solution code:
def input_ints():
    return list(map(int, input().split()))

def main():
    a, b, t = input_ints()
    print(t // a * b)

if __name__ == '__main__':
    main()

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

Submission status: Accepted

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


def solve(A: int, B: int, T: int):
    ret = B * (T // A)
    print(ret)
    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,c = map(int ,input().split())
print((c//a)*b)

Submission status: Accepted

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

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

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

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python
from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip
else:
    _str = str
    str = lambda x=b"": x if type(x) is bytes else _str(x).encode()


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


# region template

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._buffer = BytesIO()
        self._fd = file.fileno()
        self._writable = "x" in file.mode or "r" not in file.mode
        self.write = self._buffer.write if self._writable else None

    def read(self):
        if self._buffer.tell():
            return self._buffer.read()
        return os.read(self._fd, os.fstat(self._fd).st_size)

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self._buffer.tell()
            self._buffer.seek(0, 2), self._buffer.write(b), self._buffer.seek(ptr)
        self.newlines -= 1
        return self._buffer.readline()

    def flush(self):
        if self._writable:
            os.write(self._fd, self._buffer.getvalue())
            self._buffer.truncate(0), self._buffer.seek(0)


class ostream:
    def __lshift__(self, a):
        if a is endl:
            sys.stdout.write(b"\n")
            sys.stdout.flush()
        else:
            sys.stdout.write(str(a))
        return self


def print(*args, **kwargs):
    sep, file = kwargs.pop("sep", b" "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", b"\n"))
    if kwargs.pop("flush", False):
        file.flush()


sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
cout, endl = ostream(), object()

readline = sys.stdin.readline
readlist = lambda var=int: [var(n) for n in readline().split()]
input = lambda: readline().rstrip(b"\r\n")

# endregion

if __name__ == "__main__":
    main()

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())
ans = 0

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

Submission status: Accepted

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

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

Submission status: Accepted

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

print((T//A) * B)

Submission status: Accepted

Solution code:
from sys import exit
A,B,C = [int(n) for n in input().split()]
# N = int(input())
# a = [int(input()) for _ in range(N)]
# S = str(input())
# L = len(S)
# T = str(input())
# exit()
print((C//A)*B)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from statistics import mean, median,variance,stdev
import numpy as np
import sys
import math
import fractions
import itertools
import copy
import collections
from operator import itemgetter
#以下てんぷら
def j(q):
    if q==1: print("Yes")
    else:print("No")
    exit(0)


def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")

def ip():
    return int(input())
def printrow(a):
    for i in range(len(a)):
        print(a[i])
def combinations(n,r):
    if n<r:return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations(n,r):
    if n<r:return 0
    return math.factorial(n) // math.factorial(n - r)

#n = ip()                                     #入力整数1つ
a,b,t= (int(i) for i in input().split())       #入力整数横2つ以上
#a = [int(i) for i in input().split()]        #入力整数配列
#a = input()                                  #入力文字列
#a = input().split()                          #入力文字配列
#k = ip()                      #入力セット(整数改行あり)(1/2)
#a=[ip() for i in range(n)]    #入力セット(整数改行あり)(2/2)
#a=[input() for i in range(n)]    #入力セット(整数改行あり)(2/2)
#jの変数はしようできないので注意
#全足しにsum変数使用はsum関数使用できないので注意
#こっから本文
s = t//a*b
print(s)