input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
def fx(x):
return (a*x // b) - a * (x//b)
a,b,n = [int(x) for x in input().split()]
if(n < b):
print((fx(n)))
else:
print((fx((n//b)*b -1)))
| def fx(x):
return (a*x // b) - a * (x//b)
a,b,n = [int(x) for x in input().split()]
if(n < b):
print((fx(n)))
else:
print((fx(b -1))) | p02696 |
A,B,N = list(map(int,input().split()))
score = 0
for i in range(N+1):
temp = int(A*i/B)-A*int(i/B)
score = max(temp, score)
print(score) | A,B,N = list(map(int,input().split()))
score = 0
if N>=B:
x = B-1
else:
x = N
score = int(A*x/B)-A*int(x/B)
print(score) | p02696 |
a, b, n = list(map(int, input().split()))
Max = 0
for x in range(1, n + 1):
Max = max(Max, (a * x) // b - a * (x // b))
print(Max)
| def f(a, b, n):
if b == 1:
print((0))
else:
Max = 0
step = 1 if b // a == 0 else b // a
for x in range(b // a, n + step, step):
res = (a * x) // b - a * (x // b)
if res > Max:
Max = res
print(Max)
a, b, n = list(map(in... | p02696 |
A,B,N= list(map(int,input().split()))
floor_num=[]
if N >=B:
floor_num.append(int(A*(B-1)/B))
else:
for x in range(0,N+1):
floor_num.append(int(A*x/B)-A*int(x/B))
print((max(floor_num)))
| A,B,N= list(map(int,input().split()))
floor_num=[]
if N >=B:
floor_num.append(int(A*(B-1)/B))
else:
floor_num.append(int(A*N/B))
print((max(floor_num)))
| p02696 |
import math
def input_number():
return int(eval(input()))
def input_1line_list(number_of_input):
return [eval(input()) for i in range(number_of_input)]
def input_1line():
return list(map(int, input().split()))
# def print_unique_length(input_list):
# print(len(set(input_list)))
def ma... | import math
def input_number():
return int(eval(input()))
def input_1line_list(number_of_input):
return [eval(input()) for i in range(number_of_input)]
def input_1line():
return list(map(int, input().split()))
# def print_unique_length(input_list):
# print(len(set(input_list)))
def f(... | p02696 |
import math
def main():
A, B, N = list(map(int, input().split(" ")))
max_score = -float("inf")
log = []
for x in range(1, min(B, N)+1):
score = math.floor((A*x)/B) - A*math.floor(x/B)
log.append(score)
max_score = max(max_score, score)
print(max_score)
if __na... | import math
def main():
A, B, N = list(map(int, input().split(" ")))
max_score = -float("inf")
if B <= N:
x = B-1
else:
x = N
score = math.floor((A*x)/B) - A*math.floor(x/B)
print(score)
if __name__ == "__main__":
main() | p02696 |
a, b, n = list(map(int, input().split()))
cnt = 1
buf = []
buf.append(int(a * n / b) - a * (int(n / b)))
while True:
x = cnt * b - 1
if n < x :
break
calc = int(a * x / b) - a * (int(x / b))
if calc > max(buf):
buf.append(calc)
cnt += 1
ans = max(buf)
print(ans... | a, b, n = list(map(int, input().split()))
cnt = 1
buf = []
if n < b:
buf.append(int(a * n / b) - a * (int(n / b)))
else:
buf.append(int(a * (b - 1) / b) - a * (int((b - 1) / b)))
while True:
if n / b > 10 ** 6:
break
x = cnt * b - 1
if n < x :
break
calc = ... | p02696 |
A, B, N = [int(x) for x in input().split()]
max_val = 0
for x in range(N+1):
if (A*x)//B -A*(x//B) > max_val:
max_val = (A*x)//B -A*(x//B)
print(max_val) | A, B, N = [int(x) for x in input().split()]
max_val = 0
j = min(B-1,N)
x = (A*j)//B - A*(j//B)
print(x)
| p02696 |
import math
A,B,N= list(map(int,input().split()))
if N>=B:
N=B
max=0
for i in reversed(list(range(1, N+1))):
y=math.floor(A*i/B)-A*math.floor(i/B)
if max < y :
max=y
print((int(max))) | import math
A,B,N= list(map(int,input().split()))
max=0
if N>B:
N=B-1
y=math.floor(A*N/B)-A*math.floor(N/B)
print((int(y)))
elif N==B:
N=B-1
y=math.floor(A*N/B)-A*math.floor(N/B)
print((int(y)))
else:
y=math.floor(A*N/B)-A*math.floor(N/B)
print((int(y)))
| p02696 |
import sys
import itertools
if sys.platform =='ios':
sys.stdin=open('input_file.txt')
a,b,n=list(map(int,input().split()))
cnt=0
for i in range(n+1):
cnt=max(cnt,(a*i)//b-a*(i//b))
print(cnt) | import sys
import itertools
if sys.platform =='ios':
sys.stdin=open('input_file.txt')
a,b,n=list(map(int,input().split()))
cnt=0
if n//b>0:
print((a*(b-1)//b-a*((b-1)//b)))
else:
print((a*(n)//b-a*((n)//b))) | p02696 |
import sys
import itertools
if sys.platform =='ios':
sys.stdin=open('input_file.txt')
a,b,n=list(map(int,input().split()))
cnt=0
if n//b>0:
print((a*(b-1)//b-a*((b-1)//b)))
else:
print((a*(n)//b-a*((n)//b))) | a,b,n=list(map(int,input().split()))
if n>=b-1:
print(((a*(b-1))//b-a*((b-1)//b)))
else:
print(((a*n)//b-a*(n//b))) | p02696 |
import math
def solve():
a, b, n = list(map(int, input().split()))
ans = 0
for x in range(1, n+1):
ans = max(ans, math.floor(a*x/b) - a*math.floor(x/b))
return ans
print((solve()))
| import math
def solve():
a, b, n = list(map(int, input().split()))
if n < b:
return math.floor(a*n/b) - a*math.floor(n/b)
elif n >= b:
return math.floor(a*(b-1)/b) - a*math.floor((b-1)/b)
print((solve()))
| p02696 |
import math
a,b,n = list(map(int,input().split()))
ans = 0
start = b // a
count = 0
check = start % b
count = 0
for i in range(start,n+1):
dum1 = (a * i / b) // 1
dum2 = a * ((i / b)//1)
dum3 = dum1 - dum2
#print(dum1,dum2)
ans = max(ans,dum3)
if i % b == check and count != 0:
... | import math
a,b,n = list(map(int,input().split()))
if b-1 <= n:
print((math.floor((a*(b-1))/b)-(a*math.floor((b-1)/b))))
else:
print((math.floor((a * (n)) / b) - (a * math.floor((n) / b)))) | p02696 |
A, B, N = list(map(int, input().split()))
maxFloor = 0
def floor(x):
num = int(x // 1)
return num
for x in range(N + 1):
check = floor(A * x / B) - A * floor(x / B)
maxFloor = max(maxFloor, check)
print(maxFloor)
| A, B, N = list(map(int, input().split()))
maxFloor = 0
def floor(x):
num = int(x // 1)
return num
if B - 1 <= N:
check = floor(A * (B - 1) / B) - A * floor((B - 1) / B)
print(check)
else:
check = floor(A * N / B) - A * floor(N / B)
print(check) | p02696 |
import math
A,B,N = list(map(int,input().split()))
ans = list()
x = 1
while x <= N:
ans.append(math.floor(A*x/B)-A*math.floor(x/B))
if x+1 <= N and ans[x-1] > (math.floor(A*(x+1)/B)-A*math.floor((x+1)/B)):
break
else:
x += 1
print((max(ans))) | import math
A,B,N = list(map(int,input().split()))
x = min(B-1,N)
print((math.floor(A*x/B)-A*math.floor(x/B))) | p02696 |
import math
a,b,n = list(map(int,input().split()))
ans = -10000000000
for i in range(0,n+1):
kari = math.floor(a*i/b) - a*math.floor(i/b)
if ans <= kari:
ans = kari
else:
break
print(ans)
| import math
a,b,n = list(map(int,input().split()))
if b <= n:
print((math.floor(a*(b-1)/b)-a*math.floor((b-1)/b)))
else:
print((math.floor(a*n/b)-a*math.floor(n/b))) | p02696 |
from decimal import Decimal
import math
a,b,n = list(map(str,input().split()))
a = Decimal(a)
b = Decimal(b)
n = int(n)
ans = 0
for x in range(1,n+1):
tmp = math.floor((a*x)/b) - a*math.floor(x/b)
ans = max(ans,tmp)
print(ans) | from decimal import Decimal
import math
a,b,n = list(map(str,input().split()))
a = Decimal(a)
b = Decimal(b)
n = int(n)
ans = 0
kouho = [min(b-1,n)]
for x in kouho:
tmp = math.floor((a*x)/b) - a*math.floor(x/b)
ans = max(ans,tmp)
print(ans) | p02696 |
from decimal import Decimal
def main():
a, b, n = list(map(int, input().split()))
floor_list = []
for i in range(n+1):
floor_1 = int(Decimal(a*i/b))
floor_2 = a * int(Decimal(i/b))
floor_list.append(floor_1 - floor_2)
#print(floor_list)
#floor_lis... | def main():
a, b, n = list(map(int, input().split()))
limit = 0
if n >= b-1:
limit = b-1
else:
limit = n
floor_sub = int(limit * a / b) - int(limit / b) * a
print(floor_sub)
if __name__ == '__main__':
main() | p02696 |
import math
a, b, n = list(map(int, input().split(" ")))
print((max([math.floor(a*i / b) - a * math.floor(i / b) for i in range(1, b + 1 if b < n else n + 1)]))) | import math
a, b, n = list(map(int, input().split(" ")))
i = min([b-1 , n])
print(( math.floor(a*i / b) - a * math.floor(i / b) )) | p02696 |
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, ... | from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, ... | p02696 |
import math
A,B,N= list(map(int,input().split()))
x=[]
AB=A/B
for i in range(1,N+1):
x.append(math.floor(AB*i)-A*(i//B))
x.sort()
print((x.pop(N-1))) | import math
A,B,N= list(map(int,input().split()))
x=[]
AB=A/B
if B==1:
print("0")
elif N<B:
#x.append(math.floor(AB*N-1)-A*(N//B)
print((math.floor(AB*N)))
else:
x=[math.floor(AB*N)-A*(N//B)]
for i in range(N//B):
x.append(math.floor(AB*((i+1)*B-1))-i)
print((max(x))) | p02696 |
import math
def readInt():
return int(eval(input()))
def readInts():
return list(map(int, input().split()))
def readChars():
return input().split()
a,b,n = readInts()
res = -1000
for x in range(min(b,n)+1):
y = (a*x)//b-a*(x//b)
#print(y)
if y>res:
res = y
print(res)
| import math
def readInt():
return int(eval(input()))
def readInts():
return list(map(int, input().split()))
def readChars():
return input().split()
a,b,n = readInts()
x = min(b-1,n)
print((x*a//b))
| p02696 |
A, B, N = input().split()
max = 0
for i in range(int(N)+1):
temp = i/int(B) -int(i/int(B))
if temp > max:
max = temp
print((int(max*int(A)))) | A, B, N = input().split()
f = 0
if int(N) >= int(B):
f = (int(B) - 1) / int(B)
f = f - int(f)
else:
f = int(N) / int(B)
f = f - int(f)
print((int(f*int(A)))) | p02696 |
from math import gcd
a,b,n=list(map(int,input().split()))
t=a*b//gcd(a,b)
if a==1:
print((0))
exit()
ans=0
if n%t!=0:
n%=t
for i in range(1,n+1):
y=int(a*i/b)-a*int(i/b)
ans=max(ans,y)
print(ans)
|
a,b,n=list(map(int,input().split()))
def f(x):
return a*x//b-a*(x//b)
print((f(min(n,b-1)))) | p02696 |
import math
a, b, n = [int(a) for a in input().split()]
def calc(a, b, x):
# print(a, b, x, math.floor(a*x/b), math.floor(x/b))
return math.floor(a*x/b) - a * math.floor(x/b)
ans = -1
for x in range(1, n+1):
r = calc(a, b, x)
if r > ans:
ans = r
# print(x)
print(ans) | import math
a, b, n = [int(a) for a in input().split()]
def calc(a, b, x):
# print(a, b, x, math.floor(a*x/b), math.floor(x/b))
return math.floor(a*x/b) - a * math.floor(x/b)
ans = 0
max_x = b
if b > n:
max_x = n
for x in range(1, max_x+1)[::-1]:
r = calc(a, b, x)
if r > ans:
... | p02696 |
def main():
a, b, n = [int(x) for x in input().split()]
gen = (a * x // b - x // b * a for x in range(min(b, n) + 1))
return max(gen)
if __name__ == '__main__':
print((main()))
| def main():
a, b, n = [int(x) for x in input().split()]
# gen = (a * x // b - x // b * a for x in range(min(b, n) + 1))
if n >= b - 1:
x = b - 1
else:
x = n
return a * x // b - x // b * a
if __name__ == '__main__':
print((main()))
| p02696 |
A, B, N = list(map(int, input().split()))
def function(a, b, x):
return (a*x)//b - a*(x//b)
print((max([function(A, B, i) for i in range(max([1, N-N%B-1]), N+1)]))) | A, B, N = list(map(int, input().split()))
def function(a, b, x):
return (a*x)//b - a*(x//b)
print((max([function(A, B, N), function(A, B, max([1, N-N%B-1]))]))) | p02696 |
#d
A,B,N=list(map(int,input().split()))
b=[]
for i in range(1,(N//B)+1):
b.append(i*B-1)
b.append(N)
a=0
for x in b:
p=(A*x)//B-A*(x//B)
if p>a:
a=p
print(a) | #d
A,B,N=list(map(int,input().split()))
b=[]
if N>=B:
b.append((N//B)*B-1)
b.append(N)
a=0
for x in b:
p=(A*x)//B-A*(x//B)
if p>a:
a=p
print(a) | p02696 |
import math
a,b,n=list(map(int,input().split()))
l=[]
for i in range(n+1):
ans= math.floor(a*i/b)-a*(math.floor(i/b))
l.append(ans)
print((max(l))) | a,b,n=list(map(int,input().split()))
s=0
if b<=n:
x=b-1
s=(a*x)//b-a*(x//b)
else:
x=n
s=(a*x)//b-a*(x//b)
print(s) | p02696 |
import time
def floor(y):
return int(y)
def main():
a, b, n = list(map(int, input().split()))
ans = [floor(a*x/b) - a*floor(x/b) for x in range(1, n+1)]
print((max(ans)))
if __name__ == "__main__":
main() | import math
a, b, n = list(map(int, input().split()))
x = min(b-1, n)
print((math.floor(a*(x%b)/b))) | p02696 |
a,b,n = list(map(int,input().split()))
ans =0
for x in range(1,n+1):
ans = max( ans , (a * x) // b - a* (x // b))
print(ans) | a,b,n = list(map(int,input().split()))
ans =0
# for x in range(1,n+1):
x = min(b-1,n)
ans = max( ans , (a * x) // b - a* (x // b))
print(ans) | p02696 |
a,b,n=[int(x) for x in input().split()]
ma=0
for i in range(1,min(b,n)+1):
ma=max(ma,(i*a)//b-a*(i//b))
print(ma)
| a,b,n=[int(x) for x in input().split()]
i=min(b-1,n)
print(((i*a)//b-a*(i//b))) | p02696 |
from math import floor
A, B, N = list(map(int, input().split()))
mv = 0
while N > 0:
mv = max(mv, floor(A*N/B) - A*floor(N/B))
N -= 1
print(mv) | from math import floor
A, B, N = list(map(int, input().split()))
if B > N:
print((floor(A*N/B) - A*floor(N/B)))
else:
N = B - 1
print((floor(A*N/B) - A*floor(N/B)))
| p02696 |
A,B,N = list(map(int,input().split()))
max_num = 0
num = 0
for i in range(1,N+1):
if (A*i//B) - A*(i//B) > max_num:
max_num = (A*i//B) - A*(i//B)
num = i
print(max_num) | A,B,N = list(map(int,input().split()))
num = min(B-1,N)
print(((A*num//B)-A*(num//B))) | p02696 |
A, B, N = list(map(int,input().split()))
L = []
def floor(x):
return (A * x // B) - A * (x // B)
L.append(floor(N))
for i in range(N):
while B * (i + 1) - 1 < N:
L.append(floor(B * (i + 1) - 1))
print((max(L))) | A, B, N = list(map(int,input().split()))
def floor(x):
return (A * x // B) - A * (x // B)
print((floor(min(B - 1, N)))) | p02696 |
# D - Floor Function
from math import floor
A, B, N = list(map(int, input().split()))
mx = -1 * float('inf')
i = 0
for i in range(N + 1):
result = floor(A * i / B) - A * floor(i / B)
if mx <= result:
mx = result
print(mx)
| # D - Floor Function
from math import floor
A, B, N = list(map(int, input().split()))
if B <= N:
mx = floor(A * (B - 1) / B) - A * floor((B - 1) / B)
else:
mx = floor(A * N / B) - A * floor(N / B)
# mx = -1 * float('inf')
# i = 0
# for i in range(N + 1):
# result = floor(A * i / B) - A *... | p02696 |
A, B, N = list(map(int, input().split()))
def calc(x):
return (A*x)//B - A*(x//B)
index = 1
prev = -1
max_num = 0
flag = True
if B == 1:
flag = False
max_num = 0
while flag and index <= min(N,B):
tmp = calc(index)
if tmp < prev:
flag = False
else:
prev ... | A, B, N = list(map(int, input().split()))
def calc(x):
return (A*x)//B - A*(x//B)
print((calc(min(B-1, N))))
| p02696 |
a, b, n = list(map(int, input().split()))
m = max(1, n - b)
c = 0
for i in range(n, m, - 1):
d = (a * i) // b - a * (i // b)
if d >= c:
c = d
print(c) | a, b, n = list(map(int, input().split()))
if n <= b - 1:
print(((a * n) // b - a * (n // b)))
else:
print(((a * (b - 1)) // b - a * ((b - 1) // b))) | p02696 |
A,B,N = list(map(int, input().split()))
if N < B:
floor = int(A*N/B) - A*int(N/B)
elif N == B:
floor = int(A*(N-1)/B) - A*int((N-1)/B)
else:
floor = max([(int(A*(x-1)/B) - A*int((x-1)/B)) for x in range(B,N,B)])
print(floor) | A,B,N = list(map(int, input().split()))
if B == 1 or A == 1:
floor = 0
else:
if N < B:
floor = int(A*N/B) - A*int(N/B)
elif N == B:
floor = int(A*(N-1)/B) - A*int((N-1)/B)
else:
floor = max([(int(A*(x-1)/B) - A*int((x-1)/B)) for x in range(B,N,B)])
print(floor) | p02696 |
A, B, N = list(map(int, input().split()))
result = []
cnt = 0
for _ in range(N):
cnt += 1
result.append(int(A*cnt/B)-A*int(cnt/B))
print((max(result))) | A, B, N = list(map(int, input().split()))
cnt = min(B-1, N)
result = int(A*cnt/B)-A*int(cnt/B)
print(result) | p02696 |
A, B, N = list(map(int, input().split()))
def floor(t):
return int(t)
max = 0
for x in range(N+1):
y = floor(A*x/B)-A*floor(x/B)
if y > max:
max = y
print(max) | A, B, N = list(map(int, input().split()))
def g(x):
return int(A*x/B)-A*int(x/B)
print((g(min(B-1, N)))) | p02696 |
A,B,N=list(map(int,input().split()))
answer=0
for i in range(1,N+1):
f=int(A*i/B)-A*int(i/B)
if f>answer:
answer=f
if f<answer:
break
#print(f)
print(answer)
| import math
A,B,N=list(map(int,input().split()))
def f(x):
return int(A*x/B)-A*int(x/B)
print((f(min(N,B-1))))
| p02696 |
import math
mf=math.floor
a,b,n=list(map(int,input().split()))
d=0
for i in range(n+1):
c=mf(a*i/b)-a*mf(i/b)
d=max(d,c)
print(d)
| import math
mf=math.floor
a,b,n=list(map(int,input().split()))
d=0
if n<b:
i=n
elif n>=b:
i=b-1
c=mf(a*i/b)-a*mf(i/b)
print(c)
| p02696 |
import math
def main():
a,b,n = list(map(int,input().split()))
m = math.floor(a * 0 /b) - a * math.floor(0/b)
for i in range(1,min(b-1,n)+1):
if m < math.floor(a * i / b) - a * math.floor(i/b):
m = math.floor(a * i / b) - a * math.floor(i/b)
print(m)
if __name__ == "__m... | import math
def main():
a,b,n = list(map(int,input().split()))
# m = math.floor(a * 0 /b) - a * math.floor(0/b)
# for i in range(1,min(b-1,n)+1):
# if m < math.floor(a * i / b) - a * math.floor(i/b):
# m = math.floor(a * i / b) - a * math.floor(i/b)
i = min(b-1,n)
m =... | p02696 |
import math
A,B,N = list(map(int, input().split()))
judge = 0
for i in range(N+1):
if judge < math.floor(A*i/B) - A*math.floor(i/B):
judge = math.floor(A*i/B) - A*math.floor(i/B)
print(judge) | import math
A,B,N = list(map(int, input().split()))
if B > N:
a = N
else:
a = B-1
judge = math.floor(A*a/B) - A*math.floor(a/B)
print(judge)
| p02696 |
A,B,N = list(map(int, input().split()))
import math
ans=0
if N < B:
end = N + 1
else:
end = B
for x in range(1,end):
tmp=math.floor(A*x/B) - A * math.floor(x/B)
if tmp > ans:
ans = tmp
for x in range(B-1,N,B):
tmp=math.floor(A*x/B) - A * math.floor(x/B)
if tmp > ans:
ans = tmp
... | A,B,N = list(map(int, input().split()))
import math
ans=0
if N < B:
end = N
else:
end = B -1
x = end
tmp=math.floor(A*x/B) - A * math.floor(x/B)
print(tmp)
| p02696 |
import math
a, b, n = list(map(int, input().split(" ")))
_max = 0
for i in range(n + 1):
val = math.floor((a * i) / b) - (a * math.floor(i / b))
if _max > 0 and _max > val: break
_max = max(_max, val)
print(_max) | import math
a, b, n = list(map(int, input().split(" ")))
k = min(n, b - 1)
print((math.floor(a * k / b) - a * math.floor(k / b))) | p02696 |
import math
a,b,n=list(map(int,input().split()))
def Ans(x):
s=math.floor(a*x/b)
t=a*math.floor(x/b)
return s-t
ans=0
for i in range(b//a,n+1):
ans=max(Ans(i),ans)
print((Ans(min(b-1,n)))) | import math
a,b,n=list(map(int,input().split()))
def Ans(x):
s=math.floor(a*x/b)
t=a*math.floor(x/b)
return s-t
ans=0
print((Ans(min(b-1,n)))) | p02696 |
n,m,q=list(map(int,input().split()))
import math
a=[]
for i in range(1,q+1):
a.append(math.floor(n*i/m)-n*math.floor(i/m))
print((max(a))) | A, B, N = list(map(int, input().split()))
from math import floor
def f(A, B, N):
return floor(A*N/B)-A*floor(N/B)
print((f(A, B, min(B-1, N))))
| p02696 |
import sys
input = sys.stdin.readline
a, b, c= list(map(int, input().split()))
t_7 = 2/7
f_table = [a*t//b for t in range(b)]
if c >= b:
print((f_table[-1]))
else:
x = c
c_amari = c%b
c_sho = c//b
ans =f_table[c_amari]
print(ans)
| import sys
input = sys.stdin.readline
a, b, c= list(map(int, input().split()))
#f_table = [a*t//b for t in range(b)]
if c >= b:
print(((a * (b-1)) // b))
else:
x = c
c_amari = c%b
c_sho = c//b
ans =(a * c_amari) //b
print(ans)
| p02696 |
a, b, n = list(map(int, input().split()))
ans = 0
for x in range(n+1):
tmp = a*x//b - a*(x//b)
if tmp > ans:
ans = tmp
print(ans)
| a, b, n = list(map(int, input().split()))
x = n
if n >= b-1:
x = b-1
ans = (a*(x%b))//b
print(ans)
| p02696 |
A,B,N=list(map(int,input().split()))
def f(x):
return ((A*x)//B)-A*(x//B)
if N<=10**6:
ans=0
for x in range(1,N+1):
ans=max(ans,f(x))
print(ans)
elif B<=10**6:
ans=0
for x in range(1,min(B+1,N+1)):
ans=max(ans,f(x))
print(ans)
elif B>=A:
x=0
ans=0
... | A,B,N=list(map(int,input().split()))
def f(x):
return ((A*x)//B)-A*(x//B)
print((f(min(B-1,N)))) | p02696 |
a,b,n=list(map(int,input().split()))
s=n//b
ans=0
for i in range(0,s+1):
x=min(b*i+b-1,n)
ans=max((a*x)//b-a*i,ans)
print(ans) | a,b,n=list(map(int,input().split()))
x=min(b-1,n)
print((a*x//b)) | p02696 |
def floor(x) :
return int(x)
s = input().split(" ")
a = int(s[0])
b = int(s[1])
n = int(s[2])
M = 0
for i in range(1,n+1) :
if M<(floor(a*i/b)-a*floor(i/b)) :
M = (floor(a*i/b)-a*floor(i/b))
print(M)
| s = input().split()
a = int(s[0])
b = int(s[1])
n = int(s[2])
if b==1 :
print((0))
else :
c = min(b-1,n)
m = (a*c)//b
print(m) | p02696 |
a, b, n = list(map(int, input().split()))
max = 0
for x in range(n+1):
y = ((a*x)//b) - (a * (x//b))
if y > max:
max = y
print(max) | a, b, n = list(map(int, input().split()))
x = min(b-1, n)
print(((a*x)//b)) | p02696 |
a, b, n = list(map(int, input().split()))
if b>n:
print((a*n//b - a*((n)//b)))
else:
print((a*((n//b)*b-1)//b - a*(((n//b)*b-1)//b)))
| a,b,n=list(map(int,input().split()))
print((a*min(b-1,n)//b)) | p02696 |
A, B, N = list(map(int, input().split()))
ans = 0
for i in range(N+1):
tmp = ((A*i)//B) - (A*(i//B))
if tmp >= ans:
ans = tmp
else:
break
print(ans)
| A, B, N = list(map(int, input().split()))
ans = 0
i = 1
while True:
i += max(1, (B-1)//A+1)
if i > N:
break
tmp = ((A*i)//B) - (A*(i//B))
if tmp > ans:
ans = tmp
else:
break
print(ans) | p02696 |
import math
a,b,n=list(map(int,input().split()))
ans=0
for x in range(n+1):
y = math.floor(a*x/b) - a* math.floor(x/b)
ans=max(ans,y)
print(ans) | import math
a,b,n=list(map(int,input().split()))
if n<b:
print((math.floor(a*n/b)))
else:
print((math.floor(a*(b-1)/b))) | p02696 |
a,b,n=list(map(int,input().split()))
nb=n//b
xmax=0
if n<b:
xmax=a*n//b
else:
xmax=0
for xb in range(nb):
xv=(a*xb*b+a*(b-1))//b-a*xb
xmax=max(xmax,xv)
xb=nb
xv=(a*xb*b+a*n%b)//b-a*xb
xmax=max(xmax,xv)
print(xmax)
| a,b,n=list(map(int,input().split()))
nb=n//b
#xmax=0
if n<b:
xmax=a*n//b
else:
xmax=0
# for xb in range(nb):
# xv=(a*xb*b+a*(b-1))//b-a*xb
# xmax=max(xmax,xv)
xb=nb-1
xv=(a*xb*b+a*(b-1))//b-a*xb
xmax=max(xmax,xv)
xb=nb
xv=(a*xb*b+a*n%b)//b-a*xb
xmax=ma... | p02696 |
a,b,n = list(map(int, input().split()))
max_score = 0
for x in range(1,min(b+1, n+1)):
score = int(a*x/b) - a*int(x/b)
if (score > max_score):
max_score = score
print(max_score) | import math
a,b,n = list(map(int, input().split()))
for x in range(min(b, n), 0, -1):
score = math.floor((a*x)/b) - math.floor(a*(x//b))
if (score > 0):
print(score)
break
else:
print((0)) | p02696 |
A,B,N=list(map(int,input().split()))
if B==1:print((0));exit()
if N<=B:
print((max((A*(N-1))//B-A*((N-1)//B),(A*N)//B-A*(N//B))))
else:print((A-1)) | A,B,N=list(map(int,input().split()))
#if B==1:print(0);exit()
if N>=B:print(((A*(B-1))//B))
else:
print(((A*N)//B-A*(N//B))) | p02696 |
a, b, n = list(map(int, input().split(' ')))
c = 0
d = 0
for x in range(n+1):
c = int(a*x/b) - a*int(x/b)
if c > d:
d = c
print(d) | a, b, n = list(map(int, input().split(' ')))
r = min(b-1, n)
c = int(a*r/b) - a*int(r/b)
print(c) | p02696 |
inputs = input().split(' ')
a = int(inputs[0])
b = int(inputs[1])
n = int(inputs[2]) + 1
output = 0
loop_cnt = n if n < b else b
for x in range(1, loop_cnt):
buf = (a*x//b)
if buf > output:
output = buf
print(output) | inputs = input().split(' ')
a = int(inputs[0])
b = int(inputs[1])
n = int(inputs[2]) + 1
x = (n if n < b else b) - 1
output = (a*x//b)
print(output) | p02696 |
import math
A,B,N=list(map(int, input().split()))
a=0
b=0
for i in range(max(N-B+1,1),N+1):
a=i%B
if b<a:
b=a
c=math.floor(A*b/B)-A*math.floor(b/B)
print(c) | import math
A,B,N=list(map(int, input().split()))
b=0
if N>=B:
b=B-1
else:
b=N
c=math.floor(A*b/B)-A*math.floor(b/B)
print(c) | p02696 |
A, B, N = list(map(int, input().split()))
max_r = 0
for i in range(B):
if i <= N:
max_r = max(max_r, i/B)
res = int(max_r * A)
print(res) | A, B, N = list(map(int, input().split()))
max_d = min(B - 1, N)
max_r = max_d / B
res = int(max_r * A)
print(res) | p02696 |
def check(A, B, mid):
return (A * mid // B) - A * (mid // B)
def resolve():
A, B, N = list(map(int, input().split()))
ans = 0
max_int = min(N, B)
for i in range(1, max_int + 1):
tmp = check(A, B, i)
ans = max(tmp, ans)
print(ans)
resolve() | def resolve():
A, B, N = list(map(int, input().split()))
print((A * min(N, B - 1) // B))
resolve() | p02696 |
A,B,N=list(map(int,input().split()))
ans=0
t=min(B+1,N+1)
t_min=min(0,t-100)
for x in range(t_min,t):
a=int(A*x/B)
b=A * int(x/B)
ans=max(ans,a-b)
print(ans) | A,B,N=list(map(int,input().split()))
ans=0
t=min(B+1,N+1)
for x in range(t-2,t):
a=int(A*x/B)
b=A * int(x/B)
ans=max(ans,a-b)
print(ans) | p02696 |
#copy
import math
a, b, n = list(map(int, input().split()))
x = min(b-1,n)
ans = math.floor(a*x/b)-a*math.floor(x/b)
print(ans)
| import math
a,b,n = list(map(int,input().split()))
c = min(n,b - 1)
ans = math.floor(a * c / b) - a * math.floor(c / b)
print(ans) | p02696 |
import sys
import math
sys.setrecursionlimit(10 ** 7)
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
A, B, N = list(map(int, input().split()))
ans = 0
if N < B - 1:
ans = math.floor(A * N / B) - A * math.floor(N / B)
else:
c = B - 1
... | import sys
import math
sys.setrecursionlimit(10 ** 7)
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
A, B, N = list(map(int, input().split()))
ans = 0
if N < B - 1:
ans = math.floor(A * N / B) - A * math.floor(N / B)
else:
c = B - 1
... | p02696 |
from math import floor
A, B, N = list(map(int, input().split()))
ans = 0
for x in range(N+1):
ans = max(ans, floor(A*x/B)-A*floor(x/B))
print(ans) | from math import floor
A, B, N = list(map(int, input().split()))
x = B-1 if B <= N else N
ans = floor((A*x)/B)
print(ans) | p02696 |
A, B, N = list(map(int, input().split())) # 入力
ans = None
a_max = None
for _x in range(N):
x = min((B - 1), N) * (_x+1)
if x > N:
break
# print(x)
a = x/B-int(x / B)
# print(int(a * A))
sa = int(a*A)
# s = int((A * x) / B) - A * int(x / B)
if a_max == None:
... | A, B, N = list(map(int, input().split())) # 入力
ans = None
a_max = None
for _x in range(1):
x = min((B - 1), N) * (_x+1)
if x > N:
break
# print(x)
a = x/B-int(x / B)
# print(int(a * A))
sa = int(a*A)
# s = int((A * x) / B) - A * int(x / B)
if a_max == None:
... | p02696 |
import math
a, b, n = list(map(int, input().split()))
if n < b:
print(((a*n)//b))
else:
ans = -1
for x in range(b+1):
tmp = math.floor((a*x)/b) - a*math.floor(x/b)
if tmp > ans:
ans = tmp
elif tmp < ans:
break
print(ans) | a, b, n = list(map(int, input().split()))
def f(x):
return (a*x)//b-a*(x//b)
if n < b:
print((f(n)))
else:
print((f(b-1))) | p02696 |
a,b,n = list(map(int,input().split()))
ans = -int(1e18)
for i in range(min(b, n+1)):
ans = max(ans,(a*i//b)-a*(i//b))
print(ans)
| a,b,n = list(map(int,input().split()))
# ans = -int(1e18)
# for i in range(min(b, n+1)):
# ans = max(ans,(a*i//b)-a*(i//b))
ans = a*min(b-1, n)//b
print(ans)
| p02696 |
import math
a,b,n =list(map(int, input().split()))
MAX =0
for i in range(1,n+1):
A =math.floor(a*i/b) -a *math.floor(i/b)
if A >= MAX:
MAX =A
print(MAX) | import math
a,b,n =list(map(int, input().split()))
x =min(b-1, n)
A =math.floor(a*x/b) -a *math.floor(x/b)
print(A) | p02696 |
import math
a,b,n=list(map(int,input().split(' ')))
ans=0
for x in range(1,n+1):
q=math.trunc(a*x/b)-a*math.trunc(x/b)
if ans<q:
ans=q
print((int(ans))) | import math
a,b,n=list(map(int,input().split(' ')))
ans=0
x=min(n,b-1)
q=math.trunc(a*x/b)-a*math.trunc(x/b)
if ans<q:
ans=q
print((int(ans))) | p02696 |
import sys
input = sys.stdin.readline
a, b, n = [int(x) for x in input().split()]
i = 0
ans = 0
flag = 0
while i <= n:
x = (a*i//b) - (a*(i//b))
if x > 0:
flag = 1
if flag and x == 0:
print(ans)
sys.exit()
ans = max(ans, x)
i += 1
print(ans) | import sys
input = sys.stdin.readline
a, b, n = [int(x) for x in input().split()]
if n >= b - 1:
print(((a*(b - 1)//b) - (a*((b - 1)//b))))
else:
print(((a*n//b) - (a*(n//b)))) | p02696 |
import math
A, B, N = list(map(int, input().split(" ")))
def tgt(A,B,d):
return math.floor(A * d / B) - A * math.floor(d/B)
if N >= B-1:
d_max = B-1
else: # N< B-1
d_max = N
ret = 0
for d in range (d_max+1):
tmp = tgt(A,B,d)
if ret <= tmp:
ret = tmp
print(ret)
| import math
A, B, N = list(map(int, input().split(" ")))
def tgt(A,B,d):
return math.floor(A * d / B)
if N >= B-1:
d_max = B-1
else: # N< B-1
d_max = N
ret = tgt(A,B,d_max)
print(ret)
| p02696 |
a,b,n=list(map(int,input().split()))
ans=0
for i in range(1,n+1):
t=int((a*i)/b)-a*int(i/b)
ans=max(ans,t)
print(ans) | a,b,n=list(map(int,input().split()))
def f(x):
return int(a*x/b)-a*int(x/b)
print((f(min(b-1,n)))) | p02696 |
import math
from math import floor
A,B,N = list(map(int,input().split()))
maxi = 0
Npower = 0
diff = 0
S = N
while S/10 >= 1:
Npower += 1
S /=10
if Npower >= 7:
for i in range(0,10**6+10**5):
maxi = max(floor((A*i)/B)-A*floor(i/B),maxi)
for i in range(N-3*10**6,N+1):
maxi =... | import math
from math import floor
A,B,N = list(map(int,input().split()))
def f(x):
return floor(A*x/B) - A*floor(x/B)
print((f(min(B-1,N)))) | p02696 |
A, B, N = list(map(int, input().split())) #数字
import math
D = []
for x in range(1, N+1):
D.append((A * (x % B) - A * (x % B) % B)/B)
print((int(max(D)))) | A, B, N = list(map(int, input().split())) #数字
def X(x):
return (A * (x % B) - A * (x % B) % B)/B
if N < B - 1:
print((int(X(N))))
else:
print((int(X(B-1)))) | p02696 |
import math
A,B,N=list(map(int,input().split()))
max = 0
for i in range(N+1):
value = math.floor(A*i/B) - A*math.floor(i/B)
if value > max:
max=value
print(max)
| import math
A,B,N=list(map(int,input().split()))
def f(x):
return math.floor(A*x/B) - A*math.floor(x/B)
print((f(min(N,B-1))))
| p02696 |
import math
a, b, n = (int(x) for x in input().split())
x = 0
max_x = 0
while x <= n:
val = math.floor(a * x / b) - a * math.floor(x / b)
if val > max_x:
max_x = val
x += 1
print(max_x) | import math
a, b, n = (int(x) for x in input().split())
if b > n:
print((math.floor(a * n / b) - a * math.floor(n / b)))
else:
print((math.floor(a * (b -1) / b) - a * math.floor((b -1) / b))) | p02696 |
A, B, N = list(map(int,input().split()))
import math
x3 = min(N,B-1)
def f(x):
t = math.floor((A*x)/B) - A * math.floor(x/B)
return int(t)
print((f(x3))) | A, B, N = list(map(int,input().split()))
import math
x1 = N
x2 = min(N,B-1)
def f(x):
return A*x//B - A*(x//B)
print((max(f(x1),f(x2)))) | p02696 |
#
def main():
a, b, n = list(map(int, input().split(" ")))
fac = 0
for i in range(n + 1):
j = i // b
if j == 0:
if fac < i:
fac = i
else:
break
ans = a * fac // b - a * (fac // b)
print(ans)
if __name__ == '__main__... | #
def main():
a, b, n = list(map(int, input().split(" ")))
fac = 0
start = min(b, n)
if b <= n:
fac = start - 1
else:
fac = start
ans = a * fac // b - a * (fac // b)
print(ans)
if __name__ == '__main__':
main()
| p02696 |
a,b,n = list(map(int,input().split()))
#(a*x)//b - a*(x//b) の最大値を求める
ax_list = [a*i for i in range(1,n+1)]
if b > n:
# ax//b だけ考えればいい
print((a*n//b))
else:
# ax//b か bより大きいx で探す
x = 2*b-1
first = a*(b-1)//b
second = (a*x)//b - a*(x//b)
print((first if first >= second else second)) | a,b,n = list(map(int,input().split()))
#(a*x)//b - a*(x//b) の最大値を求める
if b > n:
# ax//b だけ考えればいい
print((a*n//b))
else:
# ax//b か bより大きいx で探す
x = 2*b-1
first = a*(b-1)//b
second = (a*x)//b - a*(x//b)
print((first if first >= second else second)) | p02696 |
A,B,N=list(map(int,input().split()))
p=(N+1)//B
result=0
if p!=0:
for a in range(1,p+1):
x=a*B-1
s=(A*x)//B - A*(a-1)
if result < s:
result=s
else:
result=A*N//B -A*(N//B)
print(result) | A,B,N=list(map(int,input().split()))
if B!=1:
p=(N+1)//B
result=0
if p!=0:
for a in range(1,p+1):
x=a*B-1
s=(A*x)//B - A*(a-1)
if result < s:
result=s
else:
result=A*N//B -A*(N//B)
print(result)
else:
print((0)) | p02696 |
import sys
import os
import math
import bisect
import collections
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()... | import sys
import os
import math
import bisect
import collections
import itertools
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.r... | p02696 |
import math
A,B,N=list(map(int,input().split()))
Ans=[0]
for i in range(N+1):
ans=math.floor(A*i/B)-A*(math.floor(i/B))
Ans.append(ans)
if Ans[i-1]>Ans[i]:
break
else:
pass
#print(Ans)
print((max(Ans)))
| A,B,N=list(map(int,input().split()))
x=min(N,B-1)
Ans=int(A*x/B)-A*int(x/B)
#print(Ans)
print(Ans)
| p02696 |
a,b,n=list(map(int,input().split()))
import math
ans=0
d=min(n,b)
e=b-1
for i in range(d):
ans=max(ans,math.floor(a*i/b)-a*math.floor(i/b))
if b>d:
print((math.floor(a*d/b)-a*math.floor(d/b)))
else:
print((math.floor(a*e/b)-a*math.floor(e/b))) | a,b,n=list(map(int,input().split()))
import math
ans=0
d=min(n,b)
e=b-1
if b>d:
print((math.floor(a*d/b)-a*math.floor(d/b)))
else:
print((math.floor(a*e/b)-a*math.floor(e/b))) | p02696 |
A, B, N = list(map(int, input().split()))
print(((lambda x: int(A * x / B) - A * int(x / B))(min(B - 1, N))))
| print(((lambda a, b, n: a * min(b - 1, n) // b - min(b - 1, n) // b * a)(*list(map(int, input().split())))))
| p02696 |
import sys
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
a,b,x=MAP()
def f(n):
return (a*n)//b-a*(n//b)
ans=0
pre=0
for i in range(1,x+1):
pre=f(i)
#... | import sys
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
a,b,x=MAP()
def f(n):
return (a*n)//b-a*(n//b)
if b<=x:
print((f(b-1)))
else:
print((f(x)))
| p02696 |
a, b, n = list(map(int, input().split()))
ans = 0
for i in range(1, n + 1):
num = (a * i) // b - a * (i // b)
if ans < num:
ans = num
print(ans)
| a, b, n = list(map(int, input().split()))
if b > n:
x = n
else:
x = b - 1
print(((a * x) // b))
| p02696 |
#!/usr/bin/env python3
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
import sys
def solve(A: int, B: int, N: int):
def f(x: int) -> int:
return int(A*x/B) - A*int(x/B)
print((max(list(map(f, list(range(min(B, N)+1)))))))
def main():
def iterate_tokens():
... | #!/usr/bin/env python3
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
import sys
def solve(A: int, B: int, N: int):
def f(x: int) -> int:
return int(A*x/B) - A*int(x/B)
print((f(min(B-1, N))))
def main():
def iterate_tokens():
for line in sys.stdin:
... | p02696 |
#!/usr/bin/env python3
import sys
def solve(A: int, B: int, N: int):
m = -1
for i in range(N+1):
x = i
m = max([m, int((A*x)/B) - A * int(x/B)])
return m
# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remo... | #!/usr/bin/env python3
import sys
def solve(A: int, B: int, N: int):
if A == 1: return 0
if N < B:
x = N
else:
md = N % B
x = int(N - (md + 1))
return int((A*x)//B) - A * int(x//B)
# m = -1
# for i in range(N+1):
# x = i
# m = max([m, ... | p02696 |
A, B, N = list(map(int, input().split()))
for i in range(N,-1,-1):
if (N+1)//B-1 == i//B:
ans_i = i
break
if N//B == 0:
ans_i = N
print(((A*ans_i)//B - A*(ans_i//B)))
| A, B, N = list(map(int, input().split()))
if N//B == 0:
ans_i = N
else :
ans_i = B*(N//B)-1
print(((A*ans_i)//B - A*(ans_i//B)))
| p02696 |
A, B, N = list(map(int, input().split()))
tmp = 0
a = 0
i = 0
for i in range(B - 1, N + 1, B):
if (s := (A * i) // B - A * (a)) > 0:
tmp = max(s, tmp)
else:
break
if i >= N - B:
for i in range(N, N - N % B - 1, -1):
if (s := (A * i) // B - A * (i // B)) > 0:
... | global A, B
A, B, N = list(map(int, input().split()))
def f(num):
return(A * num) // B - A * (num // B)
print((f(min(B - 1, N)))) | p02696 |
a, b, n = list(map(int, input().split()))
def function(x, a=a, b=b):
return int(a * x / b) - a * int(x / b)
ans = function(0)
for i in range(n):
if i * b - 1 > n:
ans = max(ans, function(n))
break
ans = max(ans, function(i * b - 1))
print(ans) | a, b, n = list(map(int, input().split()))
def function(x, a=a, b=b):
return int(a * x / b) - a * int(x / b)
ans = function(0)
for i in range(b):
if i * b - 1 > n:
ans = max(ans, function(n))
break
ans = max(ans, function(i * b - 1))
print(ans) | p02696 |
A, B, N = list(map(int, input().split()))
def floor(t):
return int(t)
list = []
for x in range(N+1):
list.append(floor((A*x)/B) - A*floor(x/B))
print((max(list))) | A, B, N = list(map(int, input().split()))
def floor(t):
return int(t)
list = []
if N+1 > B:
print((floor((A*(B-1))/B) - A*floor((B-1)/B)))
else:
print((floor((A*N/B) - A*floor(N/B)))) | p02696 |
import math
a,b,n = list(map(int,input().split()))
x=0
ans = (math.floor(a * x / b) - a * math.floor(x / b))
while(True):
if x>=n:break
x+=1
ans_tmp = (math.floor(a * x / b) - a * math.floor(x / b))
if ans>0 and ans_tmp==0: break
else: ans=ans_tmp
print(ans) | import math
a,b,n = list(map(int,input().split()))
if b-1>=n:
x=n
else:x=b-1
print((math.floor(a*x/b)-a*math.floor(x/b))) | p02696 |
import math
from sys import stdin
def get_result(data):
A, B, N = data
x = [B*(i+1)-1 for i in range(N//B+1)]
ans = []
for val in x:
if val > N:
val = N
ans.append(math.floor(A*val/B) - A*math.floor(val/B))
return max(ans)
if __name__ == '__main__':
... | import math
from sys import stdin
def get_result(data):
A, B, N = data
if B == 1:
return 0
length = N//B+1
x = [B*(i+1)-1 for i in range(length)]
ans = []
for val in x:
if val > N:
val = N
ans.append(math.floor(A*val/B) - A*math.floor(val/B))
... | p02696 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.