Problem:


Score : 100 points

Problem Statement

N of us are going on a trip, by train or taxi.

The train will cost each of us A yen (the currency of Japan).

The taxi will cost us a total of B yen.

How much is our minimum total travel expense?

Constraints

All values in input are integers.

1 \leq N \leq 20

1 \leq A \leq 50

1 \leq B \leq 50

Input

Input is given from Standard Input in the following format:

N A B

Output

Print an integer representing the minimum total travel expense.

Sample Input 1

4 2 9

Sample Output 1

8

The train will cost us 4 \times 2 = 8 yen, and the taxi will cost us 9 yen, so the minimum total travel expense is 8 yen.

Sample Input 2

4 2 7

Sample Output 2

7

Sample Input 3

4 2 8

Sample Output 3

8



Sample input:
4 2 9


Sample output:
8

Submission status: Accepted

Solution code:
n, a, b = map(int, input().split())
l = [n*a, b]
print(min(l))

Submission status: Accepted

Solution code:
inpl = lambda: list(map(int,input().split()))
N, A, B = inpl()
print(min(A*N,B))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def solve():
  N, A, B = map(int, input().split())
  return min(N * A, B)

print(solve())

Submission status: Accepted

Solution code:
N, A, B = map(int, input().split() )
judge = min(N*A, B)
print(judge)

Submission status: Accepted

Solution code:
import numpy as np
import math
import sys
sys.setrecursionlimit(10000000)

def main():
    N, A, B = [int(c) for c in input().split()]
    print(min(N * A, B))

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def solve(inputs):
    [N, A, B] = string_to_int(inputs[0])

    train = N * A
    taxi = B

    return min(train, taxi)


def string_to_int(string):
    return list(map(lambda x: int(x), string.split()))


if __name__ == "__main__":
    ret = solve(inputs(1))
    print(ret)

Submission status: Accepted

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


ans = min(A * N, B)

print(ans)

Submission status: Accepted

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

if N*A < B:
    print(N*A)
else:
    print(B)

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline

N, A, B = map(int, input().strip().split(' '))

print(min(A * N , B))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(min(N*A, B))

Submission status: Accepted

Solution code:
n, a, b = map(int, input().split())
pa = n * a
print(min(pa, b))

Submission status: Accepted

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

if a * n < b:
    print(a * n)
else:
    print(b)

Submission status: Accepted

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

den = N * A
tax = B

print(min(den, tax))

Submission status: Accepted

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

debug = True
#debug = False

def dprint(*objects):
    if debug == True:
        print(*objects)


# n = int(input())
# a, b = map(int, input().split())
# int_list = list(map(int, input().split()))
# l = list(input().split())

def solve():
    n, a, b = map(int, input().split())
    den = n * a
    print(min(den, b))

solve()

Submission status: Accepted

Solution code:
def InputToInt():
    A = input().split()
    for i in range(len(A)):
        A[i] = int(A[i])
    return A
    
if __name__ == '__main__':
    N, A, B = InputToInt()
    print(min(N*A,B))

Submission status: Accepted

Solution code:
import sys


def input():
    return sys.stdin.readline()[:-1]


def main():
    n, a, b = map(int, input().split())
    print(n*a if n*a < b else b)


if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def swap(a,b):
    return (b,a)

def gcd(a,b):
    if (a<b):
        a,b = swap(a,b)
    if (b==0):
        return a
    else:
        return gcd(b,a%b)

def main():
    n,a,b = map(int,input().split())
    if n*a>b:
        print(b)
    else:
        print(n*a)
    return

if __name__ == '__main__':
    main()

Submission status: Accepted

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

tr = N * A
tx = B
if tr > tx:
    print(tx)
else:
    print(tr)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
AtCoder A
"""

import sys, math, random
import numpy as np

# N = int(input())
# A = list(map(int,input().split())) # N row 1 column
# A = [int(input()) for _ in range(N)] # 1 row N column
# S = str(input()) # str(input()) == input() -> 'abc'
# S = list(input()) # abc -> ['a','b','c']
# S.replace('ABC','X') # "testABCABC" -> "testXX"
# S=numpp.assaray(S)=="#"
inf = 10**20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(): return [list(map(int, l.split())) for l in sys.stdin.readlines()]
def LLS(): return [list(sys.stdin.readline().rstrip()) for _ in sys.stdin.readlines()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()



def main():
    N, A, B = list(map(int,input().split()))
    if N*A>B:
        print(B)
    else:
        print(A*N)
    
    
if __name__ == "__main__":
    main()

Submission status: Accepted

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

ans = min(N*A, B)

print(ans)

Submission status: Accepted

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



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



if __name__ == '__main__':
    main()

Submission status: Accepted

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

if n*a>b:
  print(b)
else:
  print(n*a)

Submission status: Accepted

Solution code:
import sys
from fractions import gcd
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]

def main():
    n, a, b = LI()
    print(min(n * a, b))




if __name__ == "__main__":
    main()

Submission status: Accepted

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

ans = min(N*A, B)
print(ans)

Submission status: Accepted

Solution code:
N,A,B = map(int,input().split())
K = A*N
if (K>B):
  print(B)
else:
  print(K)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(min(B,N*A))

Submission status: Accepted

Solution code:
N, A, B = map(int, input().split())		# 5 7 2

print( min(N*A, B) )

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np
import math
n, a, b = (int(i) for i in input().split()) 

print(min(a *n , b))

Submission status: Accepted

Solution code:
#!venv/bin/python
#from collections import defaultdict 
from itertools import combinations
import math
import datetime
N, A, B = [int(x) for x in input().split()]
#ELEMENT = 10 ** 9 + 7

print(min(A*N,B))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n1, n2, n3 = [int(i) for i in input().split()]

r1 = n3

if (n1 * n2) < n3:
    r1 = n1 * n2

print(r1)

Submission status: Accepted

Solution code:
from sys import stdin

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

input = lambda: stdin.readline()
main()

Submission status: Accepted

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

print(min(N*A, B))

Submission status: Accepted

Solution code:
n,a,b = map(int,input().split())
value = n*a
print(min(value,b))

Submission status: Accepted

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

print(min(B, A * N))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N, A, B = map(int, input().split())
train = N * A
taxi = B
print(min(train, taxi))

Submission status: Accepted

Solution code:
N, a, b = (int(_) for _ in input().split())  
print(min(N*a, b))

Submission status: Accepted

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

if a*n < b:
    print(str(a*n))
else:
    print(str(b))

Submission status: Accepted

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

if A * N > B:
    print(B)
else:
    print(A*N)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N, S, K = list(map(int, input().split()))
print(min([N*S, K]))

Submission status: Accepted

Solution code:
from sys import stdin

N, A, B = [int(x) for x in stdin.readline().rstrip().split()]
print(min(A * N, B))

Submission status: Accepted

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

tmp1 = N * A
ans = min(tmp1, B)
print(ans)

Submission status: Accepted

Solution code:
def main():
    N, A, B = list(map(int, input().split()))
    print(min(A * N, B))

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
n,a,b=map(int, input().split())
train=n*a
taxi=b
if train <= taxi:
    print(train)
else:
    print(taxi)

Submission status: Accepted

Solution code:
# coding: utf-8
n,a,b = map(int, input().split())
if n*a < b:
    print(n*a)
else:
    print(b)

Submission status: Accepted

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

if N*A <= B:
  print(N*A)
else:
  print(B)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 20 20:47:47 2019

@author: Owner
"""

import numpy as np
import sys
import collections
import scipy.misc
import math
from operator import itemgetter
import itertools
import copy
import bisect
import heapq

#素因数を並べる
def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   
# 桁数を吐く
def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []
    
def getNearestValueIndex(list, num):
    """
    概要: リストからある値に最も近い値のインデックスを取得する関数
    @param list: データ配列
    @param num: 対象値
    @return 対象値に最も近い値
    """

    # リスト要素と対象値の差分を計算し最小値のインデックスを取得
    idx = np.abs(np.asarray(list) - num).argmin()
    return idx

def find_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default

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

    def find(self, x):
        """
        x が属するグループを探索
        """
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        """
        x と y のグループを結合
        """
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                x, y = y, x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            self.par[y] = x
            self.size[x] += self.size[y]

    def is_same(self, x, y):
        """
        x と y が同じグループか否か
        """
        return self.find(x) == self.find(y)

    def get_size(self, x):
        """
        x が属するグループの要素数
        """
        x = self.find(x)
        return self.size[x]
    

"""
N, X = map(int, input().split())

x = list(map(int, input().split()))

P = [0]*N
Y = [0]*N
for n in range(N):
    P[n], Y[n] = map(int, input().split())

# 多次元配列の宣言（あとでintにすること。）（タプルにすること。）
dp = np.zeros((N+1, 4,4,4))
    
all(nstr.count(c) for c in '753')

# 複数配列を並び替え
ABT = zip(A, B, totAB)
result = 0
# itemgetterには何番目の配列をキーにしたいか渡します
sorted(ABT,key=itemgetter(2))
A, B, totAB = zip(*ABT)
A.sort(reverse=True)

# 2進数のbit判定
(x >> i) & 1

# dp最小化問題
dp = [np.inf]*N
for n in range(N):
    if n == 0:
        dp[n] = 0
    else:
        for k in range(1,K+1):
            if n-k >= 0:
                dp[n] = min(dp[n], dp[n-k] + abs(h[n]-h[n-k]))
            else:
                break
# 累積和
add = 1 # 問題によって決まる
res = 0
sums = [0]*(len(nums)+1)
for i in range(len(nums)):
    sums[i+1] = sums[i] + nums[i]
for i in range(0, len(nums), 2):
    left = i
    right = min(i+add, len(nums))
    tmp = sums[right] - sums[left]
    res = max(tmp, res)

#２分探索
li, ri = bisect.bisect_left(p_ac, l[i]-1), bisect.bisect_right(p_ac, r[i]-1)    

#ソート関数
org_list = [3, 1, 4, 5, 2]
new_list = sorted(org_list)
print(org_list)
print(new_list)
# [3, 1, 4, 5, 2]
# [1, 2, 3, 4, 5]

#Distance Transformation
    for h in range(0,H):
        for w in range(0,W):
            if h == 0 and w == 0:
                pass
            elif h == 0:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h-1][W-w]+1)
            elif w == 0:   
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1)
            else:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1, D[H-h-1][W-w]+1, D[H-h][W-w]+2)
            d_max = max(D[H-h-1][W-w-1], d_max)

"""


N, A, B = list(map(int, input().split()))

    
def main(): 
    print(min(N*A, B))
                
                
                
            
            
                

    
if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

ans = min(n*a, b)
print(ans)

Submission status: Accepted

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

print(min(B,A*N))

Submission status: Accepted

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

print(min(N * A, B))

Submission status: Accepted

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

ans = min(N*A, B)
print(ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [N, A, B] = [int(input_raw[0]), int(input_raw[1]), int(input_raw[2])]
    print min(A * N,  B)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

print(min(n*a, b))

Submission status: Accepted

Solution code:
x = input()
x = x.split()

print(min(int(x[0])*int(x[1]), int(x[2])))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(1000000)
 
n,a,b = map(int,input().split())

print(min(n*a,b))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

if A*N >= B:
    print(B)
else:
    print(A*N)

Submission status: Accepted

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

if A*N > B:
    print(B)
else:
    print(A*N)

Submission status: Accepted

Solution code:
n, a, b = input().split()
print(min([int(n)*int(a), int(b)]))

Submission status: Accepted

Solution code:
from sys import stdin
import math
import fractions
from collections import deque
from collections import Counter
import itertools

INF = 10 ** 10

N, A, B = [int(x) for x in stdin.readline().rstrip().split()]

ans1 = A*N
ans2 = B

print(min(ans1, ans2))

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

def main(): 
    N, A, B = LI()
    print(min(N*A, B))




main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n,a,b  = list(map(lambda x: int(x),input().split()))
print(min(n*a,b))

Submission status: Accepted

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

print(min(A * N, B))

Submission status: Accepted

Solution code:
#A

n,a,b = (int(x) for x in input().split())
x = min(n*a, b)
print(x)

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-


def solve():
    N, A, B = list(map(int, input().split()))
    return min(N * A, B)


def main():
    print(solve())


if __name__ == "__main__":
    main()

Submission status: Accepted

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

if N*A < B:
    print(N*A)
else:
    print(B)

Submission status: Accepted

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

if N*A<=B:
    print(N*A)
else:
    print(B)

Submission status: Accepted

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

import sys
input = sys.stdin.readline
sys.setrecursionlimit(1000000)


n,a,b = list(map(int,input().split()))
print(min(n*a,b))

Submission status: Accepted

Solution code:
n, train, taxi = map(int, input().split())
print(min(n * train, taxi))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/python3
# -*- coding: utf-8 -*-

import sys

def rl(proc=None):
    if proc is not None:
        return proc(sys.stdin.readline())
    else:
        return sys.stdin.readline().rstrip()

def srl(proc=None):
    if proc is not None:
        return list(map(proc, rl().split()))
    else:
        return rl().split()

def main():
    n, a, b = srl(int)
    print(min(n*a, b))

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
from collections import defaultdict, Counter, deque
from itertools import accumulate, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right, bisect
from heapq import heappop, heappush
from fractions import gcd
from math import ceil, floor, sqrt, cos, sin, pi
from copy import deepcopy

# If you use recursive call, uncomment this code
#sys.setrecursionlimit(10**6)

def main():
    n,a,b = map(int, input().split())
    print(min(n*a,b))

if __name__ == '__main__':
    main()

Submission status: Accepted

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

t = n  * a

if t >= b:
    print(b)
    exit()
print(t)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys

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

X = N * A

print(min(X, B))

Submission status: Accepted

Solution code:
import sys

input = sys.stdin.readline
N, A, B = map(int, input().split())
print(min(A*N, B))

Submission status: Accepted

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

if(N * A < B):
    print(N * A)
else:
    print(B)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np

a = input().split(" ")
N = int(a[0])
A = int(a[1])
B = int(a[2])

print(min(A*N,B))

Submission status: Accepted

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

print(N*A) if N*A < B else print(B)

Submission status: Accepted

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

out = min(A*N, B)
print(out)

Submission status: Accepted

Solution code:
import sys

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

if __name__ == "__main__":
    n, a, b = map(int, input().split())

    print(min(n * a, b))

Submission status: Accepted

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


main()

Submission status: Accepted

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

if a*n<=b:
    print(n*a)
else:
    print(b)

Submission status: Accepted

Solution code:
n,a,b = map(int,raw_input().split())
print min(n*a,b)

Submission status: Accepted

Solution code:
N, A, B = (int(i) for i in input().split())
x = N*A
if x >= B:
  print(B)
else:
  print(x)

Submission status: Accepted

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

if (N*A)> B:
  print(B)
else:
  print(N*A)

Submission status: Accepted

Solution code:
N, A, B = map(int, input().split())
train = N*A
taxi = B
print(min(train, taxi))

Submission status: Accepted

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

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

else:
    print(B)

Submission status: Accepted

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

print(min(A*N,B))

Submission status: Accepted

Solution code:
n, a, b = map(int, input().split())
p = min(n*a, b)
print(p)

Submission status: Accepted

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

if b > a*n:
	print(a*n)
else:
	print(b)

Submission status: Accepted

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

if A * N <= B:
    print(A * N)
else:
    print(B)

Submission status: Accepted

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

print(min(a * n, b))

Submission status: Accepted

Solution code:
#!/usr/bin/env python
n, a, b = map(int, input().split())
if n*a <= b:
    print(n*a)
else:
    print(b)

Submission status: Accepted

Solution code:
n,a,b = map(int, input().split(' '))
tr = n*a
tax = b
print(min(tr,tax))

Submission status: Accepted

Solution code:
import math, string, itertools, fractions, heapq, collections, re,  array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10**7)
inf = 10 ** 20
eps = 1.0 / 10**10
mod = 10**9+7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def _I(): return int(sys.stdin.readline())
def _F(): return float(sys.stdin.readline())
def _pf(s): return print(s, flush=True)

N, A , B = LI()

print(min(N*A, B))

Submission status: Accepted

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

print(min(n * m,b))

Submission status: Accepted

Solution code:
N, A, B = map(int, input().split())
AA = N * A
print(min(AA, B))

Submission status: Accepted

Solution code:

N,A,B=tuple(map(int,input().split(' ')))

print(min([N*A,B]))

Submission status: Accepted

Solution code:
#!/usr/bin/env python
# coding: utf-8

def ri():
    return int(input())

def rl():
    return list(input().split())

def rli():
    return list(map(int, input().split()))

def main():
    n, a, b = rli()
    print(min(a*n, b))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
def solve():
    N, A, B = map(int, input().split())
    print(min(N * A, B))


if __name__ == '__main__':
    solve()

Submission status: Accepted

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

Submission status: Accepted

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

if N * A < B:
    print(N*A)
else:
    print(B)

Submission status: Accepted

Solution code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy,copy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

def main():
    n,a,b=MAP()
    print(min(n*a,b))

if  __name__=='__main__':
    main()

Submission status: Accepted

Solution code:
n,a,b = map(int,input().split())
#l = list(map(int,input().split()))
#a = int(input())
print(min(b,n*a))

Submission status: Accepted

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

def readInts():
  return [int(s) for s in input().split(" ")]

def main():
  N, A, B = readInts()
  if A * N < B:
    print(A * N)
  else:
    print(B)

if __name__ == "__main__":
  main()

Submission status: Accepted

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

Submission status: Accepted

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


def solve(N: int, A: int, B: int):
    if A * N < B:
        print(A*N)
    else:
        print(B)
    return


# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    solve(N, A, B)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

def main():
    n, a, b = map(int, input().split())
    print(min(n*a,b))

if __name__ == "__main__":
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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


def solve(N: int, A: int, B: int):
    print(min(N*A, B))
    return


# Generated by 1.1.4 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = int(next(tokens))  # type: int
    B = int(next(tokens))  # type: int
    solve(N, A, B)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
# coding: utf-8
n, a, b = list(map(int, input().split()))
if n*a > b:
    print(b)
else:
    print(n*a)

Submission status: Accepted

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

d = n * a
t = b

print(min(d, t))

Submission status: Accepted

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

def solve():
    N, A, B = map(int, input().split())
    res = min(N*A, B)
    return str(res)

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

Submission status: Accepted

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

print(min(n*a,b))

Submission status: Accepted

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


main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
###template###
import sys
def input(): return sys.stdin.readline().rstrip()
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
import heapq
INF = float("inf")
sys.setrecursionlimit(10**7)
# 4近傍（右, 下, 左, 上）
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def inside(y: int, x: int, H: int, W: int) -> bool: return 0 <= y < H and 0 <= x < W
def mi(): return map(int, input().split())
def ii(): return int(input())
###template###

N, A, B = mi()

alld = A*N
print(min(alld, B))

Submission status: Accepted

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

Submission status: Accepted

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

if B > A*N:
    print(A*N)
else:
    print(B)

Submission status: Accepted

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

print(min(n * a,b))

Submission status: Accepted

Solution code:
N, A, B = [int(nab) for nab in input().split()]
print(min(N*A, B))

Submission status: Accepted

Solution code:
n, a, b = map(int, input().split())
ans1 = n * a
ans2 = b
print(min(ans1, ans2))

Submission status: Accepted

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


def read_h(typ=int):
    return list(map(typ, input().split()))


def read_v(n, m=1, typ=int):
    return [read_h() if m > 1 else typ(input()) for _ in range(n)]


def main():
    N, A, B = read_h()
    print(min(A * N, B))


if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
t = [int(i) for i in input().split()] 
print(min(t[0]*t[1],t[2]))

Submission status: Accepted

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

Submission status: Accepted

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