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:
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())
 
Tmp = B//A
if Tmp > C:
  print(C)
else:
  print(Tmp)

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())
x=0
if b>=a*c:
  x=c
else:
  x=b//a
print(x)

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())
 
if b//a >= c:
  print(c)
  
elif b//a < c:
  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())
print(min(B//A, C))

Submission status: Accepted

Solution code:

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

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

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:
A,B,C = map(int,input().split())
 
print(min(B//A,C))

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
"""
# 標準入力取得
## 文字列
 = sys.stdin.readline().rstrip()
 = list(sys.stdin.readline().rstrip())

## 数値
 = int(sys.stdin.readline())
 = map(int, sys.stdin.readline().split())
 = list(map(int, sys.stdin.readline().split()))
 = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  # 二次元配列入力　二次元マップみたいな入力のとき

# 0埋め, 小数点出力桁指定時のときの出力
a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654

# 文字列をリストに格納
char_list = list("abcd") # ["a","b","c","d"]
"""

import math
import sys
import itertools
import queue
from fractions import gcd

def lcm(a, b):
    return a * b // gcd(a, b)

mod = 1000000007

if __name__ == "__main__":
    A, B, C = map(int, sys.stdin.readline().split())
    cnt = 0
    while True:
        if B < A or cnt >= C:
            print(cnt)
            exit()
        B -= A
        cnt += 1

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(int(B//A))
else:
    print(int(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:
N = input().split()
A = int(N[0])
B = int(N[1])
C = int(N[2])

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

Submission status: Accepted

Solution code:
#120 Favorite Sound

A, B, C = map(int, input().rstrip().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() )

cnt = 0
  
while b >= a:
  b = b - a
  cnt += 1
  if cnt >= c:
    break
    
    
print  (cnt)

Submission status: Accepted

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

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

# print(A)
# print(B)
# print(C)

# print(int(B / A))

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

Submission status: Accepted

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

D = B // A

Ans = min(C, D)
print(Ans)

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(c) if b//a > c else print(b//a)

Submission status: Accepted

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

print(n if n<c else 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())
if B>=A*C:
	print(C)
else:
	print(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 math
A,B,C = map(int, input().split())
print(min(math.floor(B/A), C))

Submission status: Accepted

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

count = b // a

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

Submission status: Accepted

Solution code:
#0120
a, b, c = (int(_) for _ in input().split())
times = b // a
if times <= c:
    print(times)
else:
    print(c)

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import math

n = list(map(int, input().split()))
a = n[0]
b = n[1]
c = n[2]

pn = math.floor(b / a)

print(int(min(pn,c)))

Submission status: Accepted

Solution code:
S = input()
 
S = list(map(int, S.split()))
 
A = S[0]
B = S[1]
C = S[2]
 
D = int(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:
import math
a,b,c = map(int, input().split())
print(min(c,math.floor(b/a)))

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())
print(c if c < b//a else b//a)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

d = b//a

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
"""
# 標準入力取得
## 文字列
 = sys.stdin.readline().rstrip()
 = list(sys.stdin.readline().rstrip())

## 数値
 = int(sys.stdin.readline())
 = map(int, sys.stdin.readline().split())
 = list(map(int, sys.stdin.readline().split()))
 = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  # 二次元配列入力　二次元マップみたいな入力のとき

# 0埋め, 小数点出力桁指定時のときの出力
a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654

# 文字列をリストに格納
char_list = list("abcd") # ["a","b","c","d"]
"""

import math
import sys
import itertools
import queue
from fractions import gcd

def lcm(a, b):
    return a * b // gcd(a, b)

mod = 1000000007

if __name__ == "__main__":
    A,B,C = map(int, sys.stdin.readline().split())

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

Submission status: Accepted

Solution code:
str_in = input().split()
a = int(str_in[0])
b = int(str_in[1])
c = int(str_in[2])

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

Submission status: Accepted

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

res=min(c,b//a)

print(res)

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:
list = [int(i) for i in input().split(" ")]
a = list[0]
b = list[1]
c = list[2]

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

Submission status: Accepted

Solution code:
l = [int(i) for i in input().split()]

A = l[0]
B = l[1]
C = l[2]

D = B//A

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

Submission status: Accepted

Solution code:
from copy import *
from sys import *
import math
import queue
from collections import defaultdict,Counter,deque
from fractions import Fraction as frac

setrecursionlimit(1000000)

#s[i] is linked with t[len(s)-i-1]
def main():
	a,b,c = map(int,input().split())
	print(min(b//a,c))

def zip(a):
	mae = a[0]
	ziparray = [mae]
	for i in range(1,len(a)):
		if(mae != a[i]):
			ziparray.append(a[i])
			mae = a[i]
	return ziparray

def is_prime(n):
	if n < 2: return False

	for k in range(2, int(math.sqrt(n)) + 1):
		if n % k == 0:
			return False

	return True

def list_replace(n,f,t):
	return [t if i==f else i for i in n]

def base_10_to_n(X, n):
	X_dumy = X
	out = ''
	while X_dumy>0:
		out = str(X_dumy%n)+out
		X_dumy = int(X_dumy/n)
	if(out == ''): return '0'
	return out

def gcd(m,n):
	x = max(m,n)
	y = min(m,n)
	while(x%y!=0):
		z = x%y
		x = y
		y = z
	return y

class Queue():
	def __init__(self):
		self.q = deque([])
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.popleft()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class Stack():
	def __init__(self):
		self.q = []
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.pop()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class graph():
	def __init__(self):
		self.graph = defaultdict(list)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
		self.graph[t].append(f)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
		self.graph[t].remove(f)
	def linked(self,f):
		return self.graph[f]

class dgraph():
	def __init__(self):
		self.graph = defaultdict(set)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
	def linked(self,f):
		return self.graph[f]

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())
print(min(b//a,c))

Submission status: Accepted

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

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:
import sys
s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in ss]
ss2nnn = lambda ss: [s2nn(s) for s in ss]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [sys.stdin.readline().rstrip() for _ in range(n)]
ii2sss = lambda n: [list(sys.stdin.readline().rstrip()) for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    A, B, C = i2nn()
    n = min(B // A, C)
    print(n)

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:
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 = list(map(int, input().split()))
ans = B // A
if ans > C:
    ans = C
print(ans)

Submission status: Accepted

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

count = b // a
if count < c:
    print(count)
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())

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

Submission status: Accepted

Solution code:
price, money, satisfaction = map(int, input().split())

print(min(money // price, satisfaction))

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())
if A * C <= B :
    print(C)
else:
    print(B//A)

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:
def resolve(input_: str):
    A, B, C = map(int, input_.split(' '))

    B_divide_A = B // A
    print(min([B_divide_A, C]))


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

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:
# -*- coding: utf-8 -*-

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

# solve & output
print(C if int(B / A) >= C else int(B / A))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
num = input().split()
if int(num[1])//int(num[0])>int(num[2]): print(int(num[2]))
else: print(int(num[1])//int(num[0]))

Submission status: Accepted

Solution code:
print(*[ x[2] if x[0]*x[2]<x[1]+1 else x[1]//x[0] for x in [[int(x) for x in input().split()]]])

Submission status: Accepted

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

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

Submission status: Accepted

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

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

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 = 0
for i in range(c):
    if b < a:
        break
    ans += 1
    b -= a

print(ans)

Submission status: Accepted

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

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

Submission status: Accepted

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

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(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=list(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()]
X = int(B/A)
if B / A >= C:
    print(C)
else:
    print(X)

Submission status: Accepted

Solution code:
def main():

    """ convenient functions
    # for i, a in enumerate(iterable)
    # q, mod = divmod(a, b)
    # divmod(x, y) returns the tuple (x//y, x%y)
    # Higher-order function: reduce(operator.mul, xyz_count, 1)
    # manage median(s) using two heapq https://atcoder.jp/contests/abc127/tasks/abc127_f
    """

    """convenient decorator
    # @functools.lru_cache():
    # to facilitate use of recursive function
        # ex:
        # from functools import lru_cache
        # import sys
        # sys.setrecursionlimit(10**9)
        # @lru_cache(maxsize=None)
        # def fib(n):
        #     if n < 2:
        #         return n
        #     return fib(n-1) + fib(n-2)
        # print(fib(1000))
    """
    
    # import numpy as np
    import sys
    sys.setrecursionlimit(10**7)
    from itertools import accumulate, combinations, permutations, product # https://docs.python.org/ja/3/library/itertools.html
    # accumulate() returns iterator! to get list: list(accumulate())
    from math import factorial, ceil, floor, sqrt
    def factorize(n):
        """return the factors of the Arg and count of each factor
        
        Args:
            n (long): number to be resolved into factors
        
        Returns:
            list of tuples: factorize(220) returns [(2, 2), (5, 1), (11, 1)]
        """
        fct = []  # prime factor
        b, e = 2, 0  # base, exponent
        while b * b <= n:
            while n % b == 0:
                n = n // b
                e = e + 1
            if e > 0:
                fct.append((b, e))
            b, e = b + 1, 0
        if n > 1:
            fct.append((n, 1))
        return fct
    def combinations_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        # TODO: How should I do when n - r is negative?
        if n < 0 or r < 0:
            raise Exception('combinations_count(n, r) not defined when n or r is negative')
        if n - r < r: r = n - r
        if r < 0: return 0
        if r == 0: return 1
        if r == 1: return n
        numerator = [n - r + k + 1 for k in range(r)]
        denominator = [k + 1 for k in range(r)]
        for p in range(2,r+1):
            pivot = denominator[p - 1]
            if pivot > 1:
                offset = (n - r) % p
                for k in range(p-1,r,p):
                    numerator[k - offset] /= pivot
                    denominator[k] /= pivot
        result = 1
        for k in range(r):
            if numerator[k] > 1:
                result *= int(numerator[k])
        return result
    def combinations_with_replacement_count(n, r):
        """Return the number of selecting r pieces of items from n kinds of items allowing individual elements to be repeated more than once.
        
        Args:
            n (long): number
            r (long): number
        
        Raises:
            Exception: not defined when n or r is negative
        
        Returns:
            long: number
        """
        if n < 0 or r < 0:
            raise Exception('combinations_with_replacement_count(n, r) not defined when n or r is negative')
        elif n == 0:
            return 1
        else:
            return combinations_count(n + r - 1, r)
    from bisect import bisect_left, bisect_right
    from collections import deque, Counter, defaultdict # https://docs.python.org/ja/3/library/collections.html#collections.deque
    from heapq import heapify, heappop, heappush, heappushpop, heapreplace,nlargest,nsmallest # https://docs.python.org/ja/3/library/heapq.html
    from copy import deepcopy, copy # https://docs.python.org/ja/3/library/copy.html
    import operator
    from operator import itemgetter
    # ex1: List.sort(key=itemgetter(1))
    # ex2: sorted(tuples, key=itemgetter(1,2))
    from functools import reduce, lru_cache
    def chmin(x, y):
        """change minimum
        if x > y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current minimum value
            y (long): potential minimum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x > y:
            x = y
            return (x, True)
        else:
            return (x, False)
    def chmax(x, y):
        """change maximum
        if x < y, x = y and return (x, True).
        convenient when solving problems of dp[i]
        
        Args:
            x (long): current maximum value
            y (long): potential maximum value
        
        Returns:
            (x, bool): (x, True) when updated, else (x, False)
        """
        if x < y:
            x = y
            return (x, True)
        else:
            return (x, False)

    from fractions import gcd # Deprecated since version 3.5: Use math.gcd() instead.
    def gcds(numbers):
        return reduce(gcd, numbers)
    def lcm(x, y):
        return (x * y) // gcd(x, y)
    def lcms(numbers):
        return reduce(lcm, numbers, 1)

    # first create factorial_list
    # fac_list = mod_factorial_list(n)
    INF = 10 ** 18
    MOD = 10 ** 9 + 7
    modpow = lambda a, n, p = MOD: pow(a, n, p) # Recursive function in python is slow!
    def modinv(a, p = MOD):
        # evaluate reciprocal using Fermat's little theorem:
        # a**(p-1) is identical to 1 (mod p) when a and p is coprime
        return modpow(a, p-2, p)
    def modinv_list(n, p = MOD):
        if n <= 1:
            return [0,1][:n+1]
        else:
            inv_t = [0,1]
            for i in range(2, n+1):
                inv_t += [inv_t[p % i] * (p - int(p / i)) % p]
            return inv_t
    def modfactorial_list(n, p = MOD):
        if n == 0:
            return [1]
        else:
            l = [0] * (n+1)
            tmp = 1
            for i in range(1, n+1):
                tmp = tmp * i % p
                l[i] = tmp
            return l
    def modcomb(n, k, fac_list = [], p = MOD):
        # fac_list = modfactorial_list(100)
        # print(modcomb(100, 5, modfactorial_list(100)))
        from math import factorial
        if n < 0 or k < 0 or n < k: return 0
        if n == 0 or k == 0: return 1
        if len(fac_list) <= n:
            a = factorial(n) % p
            b = factorial(k) % p
            c = factorial(n-k) % p
        else:
            a = fac_list[n]
            b = fac_list[k]
            c = fac_list[n-k]
        return (a * modpow(b, p-2, p) * modpow(c, p-2, p)) % p
    def modadd(a, b, p = MOD):
        return (a + b) % MOD
    def modsub(a, b, p = MOD):
        return (a - b) % p
    def modmul(a, b, p = MOD):
        return ((a % p) * (b % p)) % p
    def moddiv(a, b, p = MOD):
        return modmul(a, modpow(b, p-2, p))

    """ initialize variables and set inputs
    # initialize variables
        # to initialize list, use [0] * n
        # to initialize two dimentional array, use [[0] * N for _ in range(N)]
    # set inputs
        # open(0).read() is a convenient method:
        # ex) n, m, *x = map(int, open(0).read().split())
        #     min(x[::2]) - max(x[1::2])
        # ex2) *x, = map(int, open(0).read().split())
        #     don't forget to add comma after *x if only one variable is used
    # preprocessing
        # transpose = [x for x in zip(*data)]
        # ex) [[1, 2, 3], [4, 5, 6], [7, 8, 9]] => [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
        # flat = [flatten for inner in data for flatten in inner]
        # ex) [[1, 2, 3], [4, 5, 6], [7, 8, 9]] => [1, 2, 3, 4, 5, 6, 7, 8, 9]
    # calculate and output
        # output pattern
        # ex1) print(*l) => when l = [2, 5, 6], printed 2 5 6
    """

    # functions used
    r = lambda: sys.stdin.readline().strip()
    r_int = lambda: int(r())
    R = lambda: list(map(int, r().split()))
    Rmap = lambda: map(int, r().split())
    Rfloat = lambda: list(map(float, r().split()))
    Rtuple = lambda: tuple(map(int, r().split()))

    """ how to treat input
    # single int: int(r())
    # single string: r()
    # single float: float(r())
    # line int: R()
    # line string: r().split()
    # line (str, int, int): [j if i == 0 else int(j) for i, j in enumerate(r().split())]
    # lines int: [R() for _ in range(n)]
    """

    if __name__ != '__main__':
        # for test
        sys.stdin = open('sample.txt')

    # ----------------------------------
    # main

    A, B, C = R()
    print(min(B//A, C))
    # N, A, B, C = Rmap()
    # L = [R() for _ in range(N)]
    
    # for  combinations(L, )
    
    # end of main
    # ----------------------------------

    """memo: how to use defaultdict of list
    # initialize
    Dic = defaultdict(list)
    # append / extend
    Dic[x].append(y)
    # for
    for k, v in Dic.items():
    """

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

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

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

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

Submission status: Accepted

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

cnt = 0
while True:
    if c == cnt or b - a < 0:
        print(cnt)
        break
    else:
        b = b - a
        cnt += 1

Submission status: Accepted

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

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

num=B//A

print(min(num,C))

Submission status: Accepted

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

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

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())
m = B // A
if m >= C:
    print(C)
else:
    print(m)

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:
def smaller(x, y):
	if x < y: return x
	return y

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

Submission status: Accepted

Solution code:
S = input()
S = S.split()
howMuch = int(S[0])
Ihave = int(S[1])
sutis = int(S[2])
 
if (Ihave // howMuch) < sutis:
    print(Ihave // howMuch)
else:
    print(sutis)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
A, B, C = map(int, input().split()) # 横に2個

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
price, wallet, m = map(int, input().split())
if wallet // price >= m:
  print(m)
else:
  print(wallet // price)

Submission status: Accepted

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

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())
count = 0
while b >= 0:
    b -= a
    if b >= 0:
	    count += 1
if count >= c:
    print(c)
else:
    print(count)

Submission status: Accepted

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

Submission status: Accepted

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

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

if __name__ == '__main__':
    main()

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())
sound = B//A
if C<sound:
  print(C)
else:
  print(sound)

Submission status: Accepted

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

Submission status: Accepted

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

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 k > c:
    print(c)
else:
    print(k)

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

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

Submission status: Accepted

Solution code:
a,b,c = list(map(int,input().split(" ")))
print (   min (int(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()))
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 = (int(x) for x in input().split())
if (A*C)<=B:
  print(C)
elif (A*C)>=B:
  print(int(B/A))
else:
  print(0)

Submission status: Accepted

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