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 sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from collections import Counter # a = Counter(A).most_common()
#from itertools import accumulate #list(accumulate(A))

A, B, T = mi()

print(B * (T//A))

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

c = T // A

d = c * B

print(d)

Submission status: Accepted

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

ans = 0

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

Submission status: Accepted

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

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

Submission status: Accepted

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

res = t // a
print(res * 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())
print(math.floor((t+0.5)//a*b))

Submission status: Accepted

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

Submission status: Accepted

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

print(cnt)

Submission status: Accepted

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

while cnt < T+0.5:
  if cnt%A == 0:
    ans = ans + B
  cnt += 1
print(ans)

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#create date: 2020-06-29 13:18

import sys
stdin = sys.stdin

def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))

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

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:
import sys
# from math import sqrt, gcd, ceil, log
from bisect import bisect
from collections import defaultdict, Counter
inp = sys.stdin.readline
read = lambda: list(map(int, inp().strip().split()))

# sys.setrecursionlimit(10**6)



def solve():
	a, b, t = read()
	print(int((t+.5)//a)*b)


	





		

if __name__ == "__main__":
	solve()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**6)

#a = int(input())
#b = list(map(int, input().split()))
a, b, t = map(int, input().split())
#s = input()
#s,t = input().split()
#a = [int(input()) for _ in range(n)]
#
#readline = sys.stdin.readline
#n,m = [int(i) for i in readline().split()]
#ab = [[int(i) for i in readline().split()] for _ in range(n)]

ans = 0
A = a

while A <= t+0.5:
    ans += b
    A += a
    
print(ans)

Submission status: Accepted

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

time_count = 0
biscuit_count = 0
for i in range(1, 100):
    time_count += A
    if time_count > T + 0.5:
        break
    biscuit_count += B

print(biscuit_count)

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

Submission status: Accepted

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

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

def LI():
    return list(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())
ans = 0
time = A
while time <= T:
    ans += B
    time += A
print(ans)

Submission status: Accepted

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

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

Submission status: Accepted

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

print((T//A)*B)

Submission status: Accepted

Solution code:
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict

# import fractions

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)
# lcm = lambda x, y: (x * y) // fractions.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    A, B, T = il()
    print(B*(T//A))


if __name__ == '__main__':
    main()

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

Submission status: Accepted

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

main()

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

ans = (t // a) * b

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
import sys

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

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


main()

Submission status: Accepted

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

a = 0
bis_num = 0
while True:
    a = a + A
    if a > T:
        break
    bis_num += B

print(bis_num)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

if __name__ == '__main__':
    solve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding: utf-8
# Your code here!
#n = int(input())
A,B,T= map(int, input().split())
# = list(map(int, input().split()))
print(T//A*B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input=sys.stdin.readline
sys.setrecursionlimit(10 ** 8)
from itertools import accumulate
from itertools import permutations
from itertools import combinations
from collections import defaultdict
from collections import Counter
import fractions
import math
from collections import deque
from bisect import bisect_left
from bisect import insort_left
import itertools
from heapq import heapify
from heapq import heappop
from heapq import heappush
import heapq
from copy import deepcopy
from decimal import Decimal
alf = list("abcdefghijklmnopqrstuvwxyz")
ALF = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
#import numpy as np
INF = float("inf")
#d = defaultdict(int)
#d = defaultdict(list)
A,B,T = map(int,input().split())
print(B*(T//A))

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

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

Submission status: Accepted

Solution code:
from sys import stdin, setrecursionlimit


def main():
    input = stdin.buffer.readline
    a, b, t = map(int, input().split())
    print((t // a) * b)


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()

Submission status: Accepted

Solution code:
import sys

input = lambda: sys.stdin.readline().rstrip()


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


if __name__ == '__main__':
    solve()

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

Submission status: Accepted

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

Submission status: Accepted

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

now = a
cnt = 0
t += (0.5 - a)
while(t > 0):
    cnt += b
    now += a
    t -= a
print(cnt)

Submission status: Accepted

Solution code:
import sys
from collections import defaultdict

def solve():
    input = sys.stdin.readline
    A, B, T = map(int, input().split())
    time = A
    count = 0
    while time < T + 0.5:
        count += B
        time += A
    print(count)

    return 0

if __name__ == "__main__":
    solve()

Submission status: Accepted

Solution code:
from sys import exit
import math
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
#from fractions import gcd
#from itertools import combinations # (string,3) 3回
#from collections import deque
from collections import defaultdict
#import bisect
#
#    d = m - k[i] - k[j]
#    if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#

import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
a,b,t = readInts()
ans = 0
time = 0
while True:
    ans += b
    #print(time,t+0.5)
    if time + a > t + 0.5:
        break
    else:
        time += a
print(ans - 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())
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())
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())

turn = t // a
count = b * turn

print(count)

Submission status: Accepted

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

print((t // a) * b)

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

Submission status: Accepted

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

ans=(t//a)*b

print(ans)

Submission status: Accepted

Solution code:
import sys

A, B, T = map(int, sys.stdin.readline().strip().split())
print(B * (T // A))

Submission status: Accepted

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

bai = int(t/a)

print(bai*b)

Submission status: Accepted

Solution code:
import math
def ip():return int(input())
def inp():return map(int,input().split())
def inpstr():return map(str,input().split())
def linp():return list(map(int,input().split()))
def linpstr():return list(map(str,input().split()))

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

Submission status: Accepted

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

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

Submission status: Accepted

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

sum = int((time // a) * b)

print(sum)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import itertools
import decimal
import math
import collections
import sys
input = sys.stdin.readline

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

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# coding = SJIS
a, b, t = map(int, input().split())
kai = t // a
ans = b * kai
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(b*(t//a))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

    ans = T // A * B

    print(ans)


resolve()

Submission status: Accepted

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

Submission status: Accepted

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

t = t + 0.5

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

Submission status: Accepted

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

main()

Submission status: Accepted

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

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

print(t//a*b)

Submission status: Accepted

Solution code:
from collections import defaultdict, deque
import sys

INF = float('inf')
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]


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

Submission status: Accepted

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

print(int(t/a) * b)

Submission status: Accepted

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

n = int(float(t/a))
ans = b * n

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

for i in range(1,90):
  if i*a > t+ (1/2):
    ans = i-1
    break
    
for j in range(1,ans+1):
  sum += b
  
  
print(sum)

Submission status: Accepted

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

if __name__ == '__main__':
    main()

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:
# 初期入力
import sys
input = sys.stdin.readline
A,B,T = (int(x) for x in input().split())
num =(T +0.5)//A
ans =B *num
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 = list(map(int, input().split()))
print(int((t+0.5)//a)*b)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

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

Submission status: Accepted

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

Submission status: Accepted

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

# check
print(T // A * B)

Submission status: Accepted

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
a,b,t=map(int,input().split())
a=float(a)
t=float(t)
j=a
c=0
n=2.0
while True:
    if j<=t+0.5:
        c+=b
        j=a*n
        n+=1.0
    else:
        break
print(c)

Submission status: Accepted

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

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

print(sum)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
from collections import Counter 
from collections import defaultdict
from collections import deque
import math
import itertools
import heapq
import numpy as np
import sys
sys.setrecursionlimit(10**6)

#n=int(input())
#n,m=list(map(int,input().split()))
#a=list(map(int,input().split()))
ceil=lambda x,y: (x+y-1)//y
input_list = lambda : list(map(int,input().split()))
import fractions

#n=int(input())
a,b,t=input_list()

c=(t+0.5)//a

print(int(c*b))

Submission status: Accepted

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

Submission status: Accepted

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

print(B * (T // A))

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

Submission status: Accepted

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

print(sum([B if(i%A==0) else 0 for i in range(A,T+1)]))

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 += 1
print(count * 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())

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


if __name__ == "__main__":
    main()

Submission status: Accepted

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

import sys
# import math
# from string import ascii_lowercase, ascii_upper_case, ascii_letters, digits, hexdigits
# import re                                    # re.compile(pattern) => ptn obj; p.search(s), p.match(s), p.finditer(s) => match obj; p.sub(after, s)
# from operator import itemgetter              # itemgetter(1), itemgetter('key')
# from collections import deque                # deque class. deque(L): dq.append(x), dq.appendleft(x), dq.pop(), dq.popleft(), dq.rotate()
# from collections import defaultdict          # subclass of dict. defaultdict(facroty)
# from collections import Counter              # subclass of dict. Counter(iter): c.elements(), c.most_common(n), c.subtract(iter)
# from heapq import heapify, heappush, heappop # built-in list. heapify(L) changes list in-place to min-heap in O(n), heappush(heapL, x) and heappop(heapL) in O(lgn).
# from heapq import nlargest, nsmallest        # nlargest(n, iter[, key]) returns k-largest-list in O(n+klgn).
# from itertools import count, cycle, repeat   # count(start[,step]), cycle(iter), repeat(elm[,n])
# from itertools import groupby                # [(k, list(g)) for k, g in groupby('000112')] returns [('0',['0','0','0']), ('1',['1','1']), ('2',['2'])]
# from itertools import starmap                # starmap(pow, [[2,5], [3,2]]) returns [32, 9]
# from itertools import product, permutations  # product(iter, repeat=n), permutations(iter[,r])
# from itertools import combinations, combinations_with_replacement
# from itertools import accumulate             # accumulate(iter[, f])
# from functools import reduce                 # reduce(f, iter[, init])
# from functools import lru_cache              # @lrucache ...arguments of functions should be able to be keys of dict (e.g. list is not allowed)
# from bisect import bisect_left, bisect_right # bisect_left(a, x, lo=0, hi=len(a)) returns i such that all(val<x for val in a[lo:i]) and all(val>-=x for val in a[i:hi]).
# from copy import deepcopy                    # to copy multi-dimentional matrix without reference
# from fractions import gcd                    # for Python 3.4 (previous contest @AtCoder)


def main():
    mod = 1000000007                # 10^9+7
    inf = float('inf')              # sys.float_info.max = 1.79...e+308
    # inf = 2 ** 64 - 1               # (for fast JIT compile in PyPy) 1.84...e+19
    sys.setrecursionlimit(10**6)    # 1000 -> 1000000
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    a, b, t = mi()
    print(b * (t // a))


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def q1():
    A, B, T = (int(i) for i in input().split())
    d,_ = divmod(T, A)
    ans = B * d
    return ans

if __name__ == '__main__':
    print(q1())

Submission status: Accepted

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

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

print(int(bisc))

Submission status: Accepted

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

print((T//A) * B)

Submission status: Accepted

Solution code:
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
a, b, t = M()
print((t//a)*b)