Problem:


Score : 100 points

Problem Statement

Takahashi likes the sound when he buys a drink from a vending machine.

That sound can be heard by spending A yen (the currency of Japan) each time.

Takahashi has B yen. He will hear the sound as many times as he can with that money, but at most C times, as he would be satisfied at that time.

How many times will he hear the sound?

Constraints

All values in input are integers.

1 \leq A, B, C \leq 100

Input

Input is given from Standard Input in the following format:

A B C

Output

Print the number of times Takahashi will hear his favorite sound.

Sample Input 1

2 11 4

Sample Output 1

4

Since he has not less than 8 yen, he will hear the sound four times and be satisfied.

Sample Input 2

3 9 5

Sample Output 2

3

He may not be able to be satisfied.

Sample Input 3

100 1 10

Sample Output 3

0



Sample input:
2 11 4


Sample output:
4

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().rstrip()

def main():
    A, B, C = map(int, input().split())
    print(min(C, B // A))

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import math
def main(a,b,c):
    temp = math.floor(b/a)
    return temp if temp <= c else c

a,b,c = map(int, input().split())
print(main(a,b,c))

Submission status: Accepted

Solution code:
def main(A,B,C):
    if (B // A) > C:
        return C
    else:
        return (B // A)
        
A,B,C = map(int,input().split())
print(main(A,B,C))

Submission status: Accepted

Solution code:
#120 a
a,b,c=map(int,input().split())
ans=int(b/a)
if ans>c:
    ans=c
print(ans)

Submission status: Accepted

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

r = b//a
if r >= c:
    print(c)
else:
    print(r)

Submission status: Accepted

Solution code:
import sys

INPUT = lambda: sys.stdin.readline().rstrip()
MAP = lambda: map(int, INPUT().split())

sys.setrecursionlimit(10 ** 9)


def main():
    A, B, C = MAP()

    tmp = B
    for i in range(C):
        tmp -= A
        if tmp < 0:
            print(i)
            break
    else:
        print(C)


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
A,B,C=map(int,input().split())
ans=int(0)
pay=int(0)
for i in range(1,C+1):
  pay+=A
  if pay<=B:
    ans+=1
  else:
    break
print(ans)

Submission status: Accepted

Solution code:
A,B,C=map(int,input().split())
ans=B//A
if ans>C:
  print(C)
else:
  print(ans)

Submission status: Accepted

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

if s[1]//s[0] > s[2]:
    print(s[2])
else:
    print(s[1]//s[0])

Submission status: Accepted

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

Submission status: Accepted

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

if c<int(b/a):
    print(c)
else:
    print(int(b/a))

Submission status: Accepted

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

if B-A*C>=0:
    print(C)
else:
    print(int(B/A))

Submission status: Accepted

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

Submission status: Accepted

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

x = b//a
print(x if x<c else c)

Submission status: Accepted

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

if b/a >= c:
    print(c)
else:
    print(b//a)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math
A, B, C =map(int, input().split())
if B >= A * C:
  print(C)
else:
  print(math.floor(B/A))

Submission status: Accepted

Solution code:
A,B,C= map(int, input().split())
print( C if B//A >= C else B//A)

Submission status: Accepted

Solution code:
import sys
 
stdin = sys.stdin

mod = 1000000007
inf = 1 << 60
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()
nas = lambda: stdin.readline().split()

a, b, c = na()
print(min(b // a, c))

Submission status: Accepted

Solution code:
import sys
import math
import itertools

a,b,c=list(map(int,input().split()))
count=math.floor(b/a)
if (count>=c):
	print(c)
	sys.exit()
print(count)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

if b//a > c:
    n = c
else:
    n = b//a
print(n)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B, C = map(int, raw_input().split())

sum = B/A
if sum > C:
    print C
else:
    print sum

Submission status: Accepted

Solution code:
A,B,C=map(int,raw_input().split())
if B/A>C:
    print C
else:
    print B/A

Submission status: Accepted

Solution code:
A, B, C= map(int, input().split())
if A*C <= B:
  print(C)
elif A <= B:
  print(B//A)
else:
  print(0)

Submission status: Accepted

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

ans = B // A

if ans > C:
    print(C)
else:
    print(ans)

Submission status: Accepted

Solution code:
def main():
    A, B, C = map(int, input().split(" "))
    print(min(B // A, C))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
"""
author : halo2halo
date : 16, Jan, 2020
"""

import sys
import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

A, B,C = map(int, readline().split())
print(min(B//A,C))

Submission status: Accepted

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

if A * C <= B:
    print(C)

else:
    print(B // A)

Submission status: Accepted

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

Submission status: Accepted

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

if a*c<b:
  print(c)
else:
  print(int(b/a))

Submission status: Accepted

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

Submission status: Accepted

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

def main():
    a, b, c = map(int, input().split())
    print(min(b//a, c))
    
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
import sys

a, b, c = map(int, sys.stdin.readline().split())

def main():
    return min(b // a, c)

if __name__ == '__main__':
    ans = main()
    print(ans)

Submission status: Accepted

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

print(min(b//a, c))

Submission status: Accepted

Solution code:
A,B,C = map(int,input().split())
if A*C <= B:
  r = C
else:
  r = B // A
 
print(r)

Submission status: Accepted

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

m = b//a

if m >= c:
    print(c)
else:
    print(m)

Submission status: Accepted

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

Submission status: Accepted

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

num = B//A
print(min(num,C))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

maximum = A * C

if maximum <= B:
    print(C)
else :
    print(B // A)

Submission status: Accepted

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

if b//a <= c:
  print(b//a)
else:
  print(c)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

a, b, c = list(map(int, input().split()))
cnt = math.floor(b / a)
if c <= cnt:
    print(c)
else:
    print(cnt)

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
print(B//A if B//A < C else C)

Submission status: Accepted

Solution code:
A,B,C=map(int,input().split())
if (B//A)>=C:
  print(C)
else:
  print(B//A)

Submission status: Accepted

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

print(min(int(B/A), C))

Submission status: Accepted

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

x = b / a
if (x >= c):
   print(c)
else:
   print(int(x))

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input():
    return sys.stdin.readline().rstrip()

def main():
    A,B,C=map(int,input().split())
    print(min(C,B//A))

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

if b >= a * c:
    print(c)
else:
    print(b // a)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B,C = list(map(int,input().split(" ")))
if B / A >= C:
    print(C)
else:
    print(B // A)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a,b,c=INTM()
    print(min(b//a,c))
if __name__ == '__main__':
    do()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
if B < C:
  print(0)
elif A * C < B:
  print(C)
else:
  print(B//A)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
print(C if B // A >= C else B // A)

Submission status: Accepted

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

print(min(li[1]//li[0],li[2]))

Submission status: Accepted

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

print(c if b//a > c else b//a)

Submission status: Accepted

Solution code:
A,B,C=map(int,input().split())
s=B//A
print(s if s<C else C)

Submission status: Accepted

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

print(min(c, b//a))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split()) 
D = B // A
if D > C: 
    print(C)
else:
    print(D)

Submission status: Accepted

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

print(min(b//a,c))

Submission status: Accepted

Solution code:
A,B,C = map(int, input().split())
s = B//A
if C<=s:
	print(C)
else:
	print(s)

Submission status: Accepted

Solution code:
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

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

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353


A, B, C = list(map(int, sys.stdin.buffer.readline().split()))

ans = B//A
ans = int(min(ans, C))
print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = list(map(int,input().split()))
if(N[1]//N[0]<=N[2]):
	print(N[1]//N[0])
else:
	print(N[2])

Submission status: Accepted

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

if(c<can):
    print(c)
else:
    print(can)

Submission status: Accepted

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

if b//a > c:
    ans = c
else:
    ans = b//a

print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, b, c = map(int, input().split())
times = 0
while times < c and b >= a:
    b -= a
    times += 1
print(times)

Submission status: Accepted

Solution code:
def solve():
    A, B, C = map(int, input().split())

    ans = B // A
    if C < ans:
        ans = C
    print(ans)


if __name__ == '__main__':
    solve()

Submission status: Accepted

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

ans = B // A
print(min(ans, C))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
if B // A < C:
    print(B//A)
else:
    print(C)

Submission status: Accepted

Solution code:
import math

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(min(b//a , c))

Submission status: Accepted

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

print(min(b // a ,c))

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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

if B >= A * C:
    print(C)
else:
    print(B // A)

Submission status: Accepted

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

Submission status: Accepted

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

if b//a >= c:
    print(c)

else:
    print(b//a)

Submission status: Accepted

Solution code:
A, B, C = list(map(int, input().split()))
if int(B / A) <= C :
	print(int(B / A))
else :
	print(C)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

if a*c <= b:
  print(c)
elif a*c > b:
  print(b//a)
else:
  print("0")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, b, c = [int(x) for x in input().split()]
times = b//a
if times > c:
    print(c)
else:
    print(times)

Submission status: Accepted

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

if B >= (A*C):
    print(C)
else:
    print(int(B/A))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, b, c = map(int, input().split())
i = 0
while i < c and a <= b:
    b -= a
    i += 1
print(i)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import os, sys, re, math

(A, B, C) = [int(n) for n in input().split()]

print (min(B // A, C))

Submission status: Accepted

Solution code:
A, B, C = [int(s) for s in input().split(' ')]
print(min(C, B // A))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
a, b, c = [int(x) for x in input().split()]
print(min(b//a, c))

Submission status: Accepted

Solution code:
a, b, c = map(int, input().split())
flag = True
count = 0
while flag:
  if c <= count or b - a < 0:
    break
  b -= a
  count += 1
print(count)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

if a*c <= b:
    print(c)
else:
    count = 0
    while a <= b:
        b -= a
        count += 1
    print(count)

Submission status: Accepted

Solution code:
A,B,C=map(int,input().split())
P=(B//A)
if C>P:
  print(P)
if C<=P:
  print(C)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

if t > c:
    print(c)
else:
    print(t)

Submission status: Accepted

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

print(min(c,b//a))

Submission status: Accepted

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

d = b // a

if d <= c:
  print(d)
else:
  print(c)

Submission status: Accepted

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

if B//A >= C:
    print(C)

else:
    print(B//A)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
xyz=input().split()
x=int(xyz[0])
y=int(xyz[1])
z=int(xyz[2])
k=y//x
if k>z:
    print(z)
else:
    print(k)

Submission status: Accepted

Solution code:
li=[int(i) for i in input().split()]
a=li[0]
b=li[1]
c=li[2]
d=b//a
if(d>c):
    print(c)
else:
    print(d)

Submission status: Accepted

Solution code:

from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations
import sys
import bisect
import string
import math
import time
from fractions import gcd
#import random


def I(): return int(input())


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


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


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


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


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YN = ['Yes', 'No']
MOD = 10**9+7
inf = float('inf')
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)


show_flg = False
# show_flg = True


def main():
    A, B, C = MI()

    print(min(B // A, C))


if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

ans=b//a

print(min(ans,c))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

for idx, ret in enumerate([B - A * cnt for cnt in range(C + 1)]):
    if ret < 0:
        print(idx - 1)
        break
else:
    print(idx)

Submission status: Accepted

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


if B//A > C:
    print(C)
else:
    print(B//A)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

def main():
    a, b, c = [int(x) for x in input().split()]

    max_listen = math.floor(b/a)

    print(min(c, max_listen))

    pass


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
A,B,C = map(int,input().split())
k = int(B/A)
if k > C :
  print(C)
else:
  print(k)

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline
def print_ans(A, B, C):
    """Test Case
    >>> print_ans(2, 11, 4)
    4
    >>> print_ans(3, 9, 5)
    3
    >>> print_ans(100, 1, 10)
    0
    """
    print(min(C, B // A))


if __name__ == '__main__':
    A, B, C = map(int, input().rstrip().split())
    print_ans(A, B, C)

Submission status: Accepted

Solution code:
A,B,C=tuple(map(int,input().split()))
if A*C<=B:
    print(C)
else:
    print(B//A)

Submission status: Accepted

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

if B>=A*C:
    print(C)
else:
    print(B//A)

Submission status: Accepted

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

possible_num = B//A 
print(min(possible_num,C))

Submission status: Accepted

Solution code:
a,b,c=map(int, input().split())
krps=0
while krps<c:
  if b-a>=0:
    krps+=1
    b-=a
  if b-a<0:
    break
print(krps)

Submission status: Accepted

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

if B//A >= C:
  print(C)
else:
  print(B//A)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
import math
import datetime

# 入力
#N = int(input())
#S = str(input())
A, B, C = map(int, input().split())

if A*C <= B :
  print (C)
else :
  print (math.floor(B/A))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

if b//a >= c:
  print(c)
else:
  print(b//a)

Submission status: Accepted

Solution code:
A, B, C = list(map(int, input().split()))
can_buy = B // A
if can_buy > C:
    print(C)
else:
    print(can_buy)

Submission status: Accepted

Solution code:
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

def main():
    a, b, c = map(int, read().split())
    print(min(b//a, c))


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


B_A = (B//A)

if B_A <= C:
    print(B_A)
else:
    print(C)

Submission status: Accepted

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

Submission status: Accepted

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

if B >= A * C:
    print(C)
else:
    print(B // A)

Submission status: Accepted

Solution code:
a, b, c = map(int, input().split())
count = 0
for i in range(0, c):
    if a <= b:
        count+=1
        b -= a
    else:
        break
print(count)

Submission status: Accepted

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

b = B
ans = 0
while ans < C:
    b -= A
    if b < 0:
        break
    ans += 1
print(ans)

Submission status: Accepted

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

if b // a >= c:
    print(c)
else:
    print(b//a)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

if a * c <= b:
  print(c)
else:
  print(b // a)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#Favorite Sound
A, B, C = map(int, input().split())
if B // A <= C:
    print(B//A)
else:
    print(C)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A,B,C = map(int,input().split(' '))
if B//A > C:
    print(C)
else:
    print(B//A)

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
if B // A <= C:
	print(B // A)
else:
	print(C)

Submission status: Accepted

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

count = int(data[1]/data[0])

if count > data[2]:
    print(data[2])
else:
    print(count)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# 2019-11-12 21:58:02(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np 

def main():
    a, b, c = [int(x) for x in sys.stdin.readline().split()]
    if b >= a * c:
        ans = c
    else:
        ans = b // a
    print(ans)


if __name__ == "__main__":
    main()

Submission status: Accepted

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

print(min(b//a, c))

Submission status: Accepted

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

ans = min(C, B // A)
print(ans)

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split())
D = B // A 
if D >=C:
  print(C)
else:
  print(D)

Submission status: Accepted

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

if b//a>=c:
  print(c)
else:
  print(b//a)

Submission status: Accepted

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

ans = 0
if b >= a*c:
    print(c)
else:
    ans = int(b/a)
    print(ans)

Submission status: Accepted

Solution code:
def main():
    a,b,c = map(int,input().split())
    ans = min(b//a,c)
    print(ans)


if __name__ == '__main__':
    main()

Submission status: Accepted

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

import math

if B  >= A * C:
    print(C)
else:
    print(math.floor(B/A))

Submission status: Accepted

Solution code:
A,B,C=map(int, input().split())
if B-A*C >=0:
    print(C)
else:
    print(int(B/A))

Submission status: Accepted

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

ret = min(c, b//a)

print(ret)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

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

print(min(math.floor(b/a), c))

Submission status: Accepted

Solution code:
import sys
def input(): return sys.stdin.readline().strip()

def main():
    a,b,c=map(int,input().split())
    print(min([b//a, c]))

main()

Submission status: Accepted

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

if A * C <= B:
  print(C)
else:
  print(B//A)

Submission status: Accepted

Solution code:
# ABC 120: A – Favorite Sound
a, b, c = [int(s) for s in input().split()]
print(c if a * c <= b else b // a)

Submission status: Accepted

Solution code:
import math
a,b,c = map(int, input().split())
print(min(c, (math.ceil(b // a))))

Submission status: Accepted

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

Submission status: Accepted

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

if b / a >= c:
    print(c);
else:
    print(int(b/a));

Submission status: Accepted

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

k = b//a

if c <= k:
	k = c
	
print(k)

Submission status: Accepted

Solution code:
A,B,C = map(int,input().split())
if B // A < C:
  print(B // A)
else:
  print(C)

Submission status: Accepted

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

bt = b // a

print(min(c, bt))

Submission status: Accepted

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

s = int(b / a)
if s > c:
    print(c)
else:
    print(s)

Submission status: Accepted

Solution code:
from sys import stdin

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

kai = b//a

if kai > c:
    print(c)
else:
    print(kai)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

needcost = a * c
if needcost >= b:
    ans = b // a
else:
    ans = c

print(ans)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

if many >= C:
    print(C)
else:
    print(many)

Submission status: Accepted

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

Submission status: Accepted

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

if b//a >= c:
    print(c)
else:
    print(b//a)

Submission status: Accepted

Solution code:
 # -*- coding: utf-8 -*-
     
[A, B, C] = [int(i) for i in input().split()]

number = B // A

if number > C:
    number = C

print(number)

Submission status: Accepted

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