problem_id stringlengths 6 6 | user_id stringlengths 10 10 | time_limit float64 1k 8k | memory_limit float64 262k 1.05M | problem_description stringlengths 48 1.55k | codes stringlengths 35 98.9k | status stringlengths 28 1.7k | submission_ids stringlengths 28 1.41k | memories stringlengths 13 808 | cpu_times stringlengths 11 610 | code_sizes stringlengths 7 505 |
|---|---|---|---|---|---|---|---|---|---|---|
p02696 | u442855260 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import numpy as np\nA,B,N=map(int,input().split())\nx = np.array([j for j in range(B+1)])\nval=np.floor(A*x/B)-A*np.floor(x/B)\nprint(int(np.max(val)))', 'import math\nA,B,N=map(int,input().split())\nif(N<B):\n x = N\nelse:\n x =B-1 \n\nprint(int( math.floor(A*x/B)-A*math.floor(x/B) ))'] | ['Wrong Answer', 'Accepted'] | ['s442691935', 's288834220'] | [2078780.0, 9176.0] | [2279.0, 20.0] | [147, 134] |
p02696 | u442877951 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A,B,N = map(int,input().split())\nans = 0\nif B <= N:\n for x in range(B-1,N+1,B):\n ans = max(ans, (A*x)//B - A*(x//B))\nelse:\n ans = floor((A*N)/B) - A*floor(N/B)\nprint(ans)', 'from math import floor\nA,B,N = map(int,input().split())\nans = 0\nif B <= N:\n ans = floor(A*(B-1)/B) - A*floor((B-1)/B)\nelse:\n ans = floor((A*N)/B) - A*floor(N/B)\nprint(ans)'] | ['Runtime Error', 'Accepted'] | ['s911056871', 's938809050'] | [9208.0, 9180.0] | [2205.0, 22.0] | [176, 174] |
p02696 | u449822557 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\na, b, n = list(map(int,input().split()))\nif b > n:\n print(math.floor(a*n/b))\nelif n < 2*b - 1:\n print(max(math.floor(a*n/b)-a,math.floor(a*(b-1)/b))\nelse:\n print(a+math.floor((-1)*a/b))', 'import math\na, b, n = list(map(int,input().split()))\nif b > n:\n print(math.floor(a*n/b))\nelif n < 2*b - 1:\n print(max(math.floor(a*n/b)-a,math.floor(a*(b-1)/b)))\nelse:\n print(a+math.floor((-1)*a/b))'] | ['Runtime Error', 'Accepted'] | ['s331479559', 's045043882'] | [8912.0, 9192.0] | [26.0, 23.0] | [206, 207] |
p02696 | u451206510 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\nA,B,N = map(int, input().split())\nprint(math.floor((A*(B-1))/B) - A*math.floor((B-1)/B))', 'import math\nA,B,N = map(int, input().split())\nprint(math.floor((A*(B-1))/B) - A*math.floor((B-1)//B))\n', 'import math\nA,B,N = map(int, input().split())\n\nif (B-1) <= N:\n print(math.floor((A*(B-1))/B) - A*math.floor((B-1)/B))\nelse:\n print(math.floor(A*N/B) - A*math.floor(N/B))\n'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s161053046', 's783334187', 's281560437'] | [9148.0, 9032.0, 9176.0] | [23.0, 22.0, 22.0] | [100, 102, 176] |
p02696 | u453634575 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a, b,n = list(map(int, input().split()))\nres = 0\nfor x in range(1, n+1):\n print((a*x)//b, a *(x//b) )\n if a *(x//b) != 0:\n break\n if res < (a*x)//b - a *(x//b):\n res = (a*x)//b - a *(x//b)\n\nprint(res)', 'a, b,n = list(map(int, input().split()))\nif b > n:\n print((a*n)//b - a *(n//b))\nelif b <= n:\n print((a*(b-1))//b )'] | ['Wrong Answer', 'Accepted'] | ['s978189111', 's006597363'] | [13092.0, 9172.0] | [2223.0, 21.0] | [224, 120] |
p02696 | u455957070 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n = map(int, input().split())\nfor i in range(b-1):\n tmp = (a*i) // b - a*(i // b)\n ans = 0\n ans = max(tmp,ans)\nprint(ans)', 'import math\na, b, n = map(int, input().split())\nx = min(b-1, n)\nprint(math.floor(a*x/b)-a*math.floor(x/b))'] | ['Runtime Error', 'Accepted'] | ['s813735725', 's150048787'] | [9116.0, 9160.0] | [2205.0, 24.0] | [128, 106] |
p02696 | u463864151 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['# -*- coding: utf-8 -*-\n"""\n@author: H_Hoshigi\n"""\ndef main():\n N, M, Q = map(int, input().split())\n r_list = []\n for i in range(Q):\n r_list.append(list(map(int, input().split())))\n max_score = 0\n a1 = 1\n for a2 in range(a1, M+1):\n for a3 in range(a2, M+1):\n for a4 in range(a3, M+1):\n for a5 in range(a4, M+1):\n for a6 in range(a5, M+1):\n for a7 in range(a6, M+1):\n for a8 in range(a7, M+1):\n for a9 in range(a8, M+1):\n for a10 in range(a9, M+1):\n a_list = [a1,a2,a3,a4,a5,a6,a7,a8,a9,a10]\n score = 0\n for r in r_list:\n if a_list[r[1]-1] - a_list[r[0]-1] == r[2]:\n score += r[3]\n max_score = max(score, max_score)\n print(max_score)\n\nif __name__ == "__main__":\n main()\n\n\n', '# -*- coding: utf-8 -*-\n"""\n@author: H_Hoshigi\n"""\nimport math\nA, B, N = map(int, input().split())\n\ndef f(x):\n return math.floor(A*x/B) - A * math.floor(x/B)\n\ndef main():\n print(f(min(N, B-1)))\n\nif __name__ == "__main__":\n main()\n\n'] | ['Runtime Error', 'Accepted'] | ['s675286168', 's328807110'] | [9264.0, 9180.0] | [20.0, 22.0] | [1116, 240] |
p02696 | u464205401 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n=list(map(int,input().split()))\n\n#for x in range(n+1):\nx=b-1\nans=int(a*x/b)-a*int(x/b)\nprint(ans)', 'a,b,n=list(map(int,input().split()))\nx=n-1 if b==n else b-1 if n-1>=b else n\nprint(int(a*x/b)-a*int(x/b))'] | ['Wrong Answer', 'Accepted'] | ['s125809150', 's754641609'] | [8976.0, 9164.0] | [22.0, 23.0] | [102, 105] |
p02696 | u464627439 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a, b, n = map(int, input().split())\n\nx = 0\nbuf = []\nwhile True:\n calc = int(a * x / b) - a * int(x / b)\n buf.append(calc)\n \n\n if a < x:\n break\n x += 1\n\nans = max(buf)\nprint(ans)', 'a, b, n = map(int, input().split())\n\ncnt = 1\nbuf = []\nbuf.append(int(a * n / b) - a * (int(n / b)))\n\nwhile True:\n if n / b > 10 ** 6:\n break\n x = cnt * b - 1\n if n < x :\n break\n calc = int(a * x / b) - a * (int(x / b))\n if calc > max(buf):\n buf.append(calc)\n cnt += 1\n \nbuf.append(int(a * (b - 1) / b) - a * (int((b - 1) / b)))\n\nans = max(buf)\nprint(ans)', 'a, b, n = map(int, input().split())\n\ncnt = 1\nbuf = []\nif n < b:\n buf.append(int(a * n / b) - a * (int(n / b)))\nelse:\n buf.append(int(a * (b - 1) / b) - a * (int((b - 1) / b)))\n \n\nwhile True:\n if n / b > 10 ** 6:\n break\n x = cnt * b - 1\n if n < x :\n break\n calc = int(a * x / b) - a * (int(x / b))\n if calc > max(buf):\n buf.append(calc)\n cnt += 1\n \nif n / b > 10 ** 6 and n >= b:\n buf.append(int(a * (b - 1) / b) - a * (int((b - 1) / b)))\n\nans = max(buf)\nprint(ans)'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s566670420', 's811057942', 's214119967'] | [17012.0, 9216.0, 9176.0] | [531.0, 21.0, 22.0] | [199, 396, 518] |
p02696 | u469936642 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a, b, n = map(int, input().split())\n\nif b == 1 or a == 1:\n print(0)\nelse:\n r = min(b-1, n) \n s = (a * r) // b - a * (r // b)\n print(r)', 'a, b, n = map(int, input().split()) \nif b == 1 or a == 1: \n print(0) \nelse: \n r = min(b-1, n) \n s = (a * r) // b - a * (r // b) \n print(s)\n'] | ['Wrong Answer', 'Accepted'] | ['s850673094', 's137562524'] | [9124.0, 9032.0] | [21.0, 24.0] | [146, 154] |
p02696 | u473430959 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\nA,B,N= map(int,input().split())\n\n \n\nmax=0\nfor i in reversed(range(1, N+1)):\n y=float(math.floor(A*i/B))-A*float((math.floor(i/B)))\n if max < y :\n max=y\nprint(max)\n ', 'import math\nA,B,N= map(int,input().split())\n\nmax=0\nif N>B:\n N=B-1\n y=math.floor(A*N/B)-A*math.floor(N/B)\n print(int(y))\nelif N==B:\n N=B-1\n y=math.floor(A*N/B)-A*math.floor(N/B)\n print(int(y))\nelse:\n\ty=math.floor(A*N/B)-A*math.floor(N/B)\n\tprint(int(y))\n '] | ['Wrong Answer', 'Accepted'] | ['s048063762', 's863452277'] | [9176.0, 9200.0] | [2205.0, 24.0] | [183, 260] |
p02696 | u477977638 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n=map(int,input().split())\n\nx=max(b-1,n)\nprint((a*x)//b)\n', 'a,b,n=map(int,input().split())\nx=min(b-1,n)\nprint((a*x)//b)'] | ['Wrong Answer', 'Accepted'] | ['s138556420', 's711440503'] | [9152.0, 9104.0] | [24.0, 23.0] | [61, 59] |
p02696 | u479638406 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\ndef solve():\n a, b, n = map(int, input().split())\n\n ans = 0\n for x in range(-1, n+1, b):\n ans = max(ans, math.floor(a*x/b) - a*math.floor(x/b))\n\n\n return ans\n\n\nprint(solve())\n', 'import math\ndef solve():\n a, b, n = map(int, input().split())\n\n if n < b:\n return math.floor(a*n/b) - a*math.floor(n/b)\n elif n >= b:\n return math.floor(a*(b-1)/b) - a*math.floor((b-1)/b)\n\n\n\nprint(solve())\n'] | ['Wrong Answer', 'Accepted'] | ['s102756621', 's228791954'] | [9088.0, 9180.0] | [2205.0, 21.0] | [206, 229] |
p02696 | u481187938 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['#!usr/bin/env pypy3\nfrom collections import defaultdict, deque\nfrom heapq import heappush, heappop\nfrom itertools import permutations, accumulate, combinations_with_replacement, compress\nimport sys\nimport math\nimport bisect\n\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\n\n\ndef I(): return int(sys.stdin.readline())\n\n\ndef LS(): return [list(x) for x in sys.stdin.readline().split()]\n\n\ndef S():\n res = list(sys.stdin.readline())\n if res[-1] == "\\n":\n return res[:-1]\n return res\n\n\ndef IR(n):\n return [I() for i in range(n)]\n\n\ndef LIR(n):\n return [LI() for i in range(n)]\n\n\ndef SR(n):\n return [S() for i in range(n)]\n\n\ndef LSR(n):\n return [LS() for i in range(n)]\n\n\nsys.setrecursionlimit(1000000)\n\n\ndef main():\n N, M, Q = LI()\n abcd = [LI() for _ in range(Q)]\n ans = 0\n\n for A in combinations_with_replacement(range(1, M + 1), N):\n tmp = 0\n for (a, b, c, d) in abcd:\n tmp += d if (A[b-1] - A[a-1] == c) else 0\n ans = max(ans, tmp)\n print(ans)\n\n\nmain()\n', 'from collections import defaultdict, deque\nfrom heapq import heappush, heappop\nfrom itertools import permutations, accumulate, combinations_with_replacement, compress\nimport sys\nimport math\nimport bisect\n\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\n\n\ndef I(): return int(sys.stdin.readline())\n\n\ndef LS(): return [list(x) for x in sys.stdin.readline().split()]\n\n\ndef S():\n res = list(sys.stdin.readline())\n if res[-1] == "\\n":\n return res[:-1]\n return res\n\n\ndef IR(n):\n return [I() for i in range(n)]\n\n\ndef LIR(n):\n return [LI() for i in range(n)]\n\n\ndef SR(n):\n return [S() for i in range(n)]\n\n\ndef LSR(n):\n return [LS() for i in range(n)]\n\n\nsys.setrecursionlimit(1000000)\n\n\ndef main():\n N, M, Q = LI()\n abcd = [LI() for _ in range(Q)]\n ans = 0\n\n for A in combinations_with_replacement(range(1, M + 1), N):\n tmp = 0\n for (a, b, c, d) in abcd:\n tmp += d if (A[b-1] - A[a-1] == c) else 0\n ans = max(ans, tmp)\n print(ans)\n\n\nmain()\n', 'from collections import defaultdict, deque\nfrom heapq import heappush, heappop\nfrom itertools import permutations, accumulate, combinations_with_replacement, compress\nimport sys\nimport math\nimport bisect\n\n\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\n\n\ndef I(): return int(sys.stdin.readline())\n\n\ndef LS(): return [list(x) for x in sys.stdin.readline().split()]\n\n\ndef S():\n res = list(sys.stdin.readline())\n if res[-1] == "\\n":\n return res[:-1]\n return res\n\n\ndef IR(n):\n return [I() for i in range(n)]\n\n\ndef LIR(n):\n return [LI() for i in range(n)]\n\n\ndef SR(n):\n return [S() for i in range(n)]\n\n\ndef LSR(n):\n return [LS() for i in range(n)]\n\n\nsys.setrecursionlimit(1000000)\n\n\ndef main():\n A, B, N = LI()\n print(int(A / B * min(N, B - 1)))\n\n\nmain()\n'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s108459842', 's920866132', 's940095034'] | [83000.0, 80400.0, 9424.0] | [2209.0, 2209.0, 35.0] | [1043, 1023, 801] |
p02696 | u482743994 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['print(0)', 'from math import ceil\na,b,n=map(int,input().split())\np=n//b\nif p==0:\n print((a*n)//b)\nelse:\n print(a-ceil(a/b))\n'] | ['Wrong Answer', 'Accepted'] | ['s571643230', 's799278744'] | [9004.0, 9164.0] | [18.0, 23.0] | [8, 114] |
p02696 | u488884575 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n = list(map(int, input().split()))\nx = b-1\nt = int(a*x/b) -a*int(x/b)\n\n\nprint(t)\n', 'a,b,n = list(map(int, input().split()))\nx = b-1\nt = int(a*x//b) -a*int(x//b)\n\n\nprint(t)\n', 'a,b,n = list(map(int, input().split()))\nx = b-1\nif x < n:\n t = int(a*x//b) -a*int(x//b)\nelse:\n t = int(a*n//b) -a*int(n//b)\n\nprint(t)\n\n'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s500356876', 's681494270', 's602953395'] | [9060.0, 9092.0, 9112.0] | [20.0, 24.0, 24.0] | [86, 88, 141] |
p02696 | u491762407 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n = map(int,input().split())\n\nx = math.floor(a*n/b)-( a*math.floor(n/b))\ny = math.floor(a*b/b)-( a*math.floor(b/b))\nz = math.floor(a*(b-1)/b)-( a*math.floor((b-1)/b))\n\nif b == 1:\n print(0)\nelif n < b:\n print(x)\nelse:\n print(z)', 'a,b,n = map(int,input().split())\n\nif b == 1:\n print(0)\nelif n < b:\n print(math.floor(a*n/b)+math.floor(n/b))\nelse:\n print(math.floor(a*(b-1)/b)+math.floor((b-1)/b))', 'import math\na,b,n = map(int,input().split())\n\nx = math.floor(a*n/b)-( a*math.floor(n/b))\ny = math.floor(a*b/b)-( a*math.floor(b/b))\nz = math.floor(a*(b-1)/b)-( a*math.floor((b-1)/b))\n\nif b == 1:\n print(0)\nelif n < b:\n print(x)\nelse:\n print(z)'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s069590930', 's184217141', 's234097508'] | [9196.0, 9172.0, 9196.0] | [20.0, 22.0, 20.0] | [239, 173, 251] |
p02696 | u492959898 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n=map(int,(inpur().split())\nx = min(b-1,n)\nprint(int(a*x/b)-a*int(x/b))', 'a,b,n=map(int,input().split())\nx = min(b-1,n)\nprint(int(a*x/b)-a*int(x/b))'] | ['Runtime Error', 'Accepted'] | ['s666666522', 's061205867'] | [8928.0, 9012.0] | [21.0, 20.0] | [75, 74] |
p02696 | u493318999 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\na,b,n = map(int,input().split())\nans = -10000000000 \nfor i in range(0,n+1):\n kari = math.floor(a*i/b) - a*math.floor(i/b)\n if ans < kari:\n ans = kari\n else:\n break\nprint(ans)', 'import math\na,b,n = map(int,input().split())\nif b <= n:\n print(math.floor(a*(b-1)/b)-a*math.floor((b-1)/b))\nelse:\n print(math.floor(a*n/b)-a*math.floor(n/b))'] | ['Wrong Answer', 'Accepted'] | ['s675161342', 's710604762'] | [9176.0, 9172.0] | [25.0, 22.0] | [209, 163] |
p02696 | u494058663 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['from decimal import Decimal\nimport math\na,b,n = map(str,input().split())\n\na = Decimal(a)\nb = Decimal(b)\nn = int(n)\nans = 0\nkouho = [b-1,b,n-1,n]\nfor x in kouho:\n tmp = math.floor((a*x)/b) - a*math.floor(x/b)\n ans = max(ans,tmp)\nprint(ans)', 'from decimal import Decimal\nimport math\na,b,n = map(str,input().split())\n\na = Decimal(a)\nb = Decimal(b)\nn = int(n)\nans = 0\nkouho = [min(b-1,n)]\nfor x in kouho:\n tmp = math.floor((a*x)/b) - a*math.floor(x/b)\n ans = max(ans,tmp)\nprint(ans)'] | ['Wrong Answer', 'Accepted'] | ['s343890509', 's905957204'] | [9944.0, 10068.0] | [28.0, 24.0] | [244, 243] |
p02696 | u497805118 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a, b, n = map(int, input().split(" "))\n\nprint(max([math.floor(a * i / b) - a * math.floor(i / b) for i in range(1, n + 1)]))\n', 'import math\n \na, b, n = map(int, input().split(" "))\ni = min([b-1 , n])\nprint( math.floor(a*i / b) - a * math.floor(i / b) )'] | ['Runtime Error', 'Accepted'] | ['s069080879', 's076737078'] | [9100.0, 9172.0] | [22.0, 22.0] | [125, 124] |
p02696 | u505025514 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['l = list(map(int,input().split()))\na = l[0]\nb = l[1]\nn = l[2]\n\ndef floor(a,b,x):\n p = (a*x)//b - a*(x//b)\n return p\n\nmax = 0\nmaxn = 0\nfor i in range(n+1):\n c = floor(a,b,i)\n if c >= max:\n max = c\n maxn = i\n\nprint(maxn)', 'l = list(map(int,input().split()))\na = l[0]\nb = l[1]\nn = l[2]\n\ndef floor(a,b,x):\n p = (a*x)//b - a*(x//b)\n return p\n\nmax = 0\nif b == 1:\n max = 0\nelif n <= b-1:\n max = floor(a,b,n)\nelif n > b-1:\n for i in range(b-1,n+1,b):\n c = floor(a,b,i)\n if c >= max:\n max = c\n\nprint(max)'] | ['Wrong Answer', 'Accepted'] | ['s891843817', 's417765269'] | [9112.0, 9212.0] | [2205.0, 19.0] | [244, 314] |
p02696 | u508164527 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\nA,B,N = (int(x) for x in input().split())\na = (N//B)*B-1\nif a < 0:\n ans = math.floor(A*0/B) - A*math.floor(0/B)\nelse:\n ans = math.floor(A*a/B) - A*math.floor(a/B)\nif ans > math.floor(A*N/B)-A*math.floor(a/B):\n re = ans\nelse:\n re = math.floor(A*N/B)-A*math.floor(a/B)\nprint(re)\n\n', 'import math\nA,B,N = (int(x) for x in input().split())\na = (N//B)*B-1\nif a < 0:\n a = 0\n ans = (A*a)//B - A*math.floor(a/B)\nelse:\n ans = (A*a)//B - A*math.floor(a/B)\n\nif ans < (A*N)//B - A*math.floor(N/B):\n re = (A*N)//B - A*math.floor(N/B)\nelse:\n re = ans\nprint(re)\n\n'] | ['Wrong Answer', 'Accepted'] | ['s934685683', 's923682522'] | [9136.0, 9100.0] | [21.0, 24.0] | [294, 271] |
p02696 | u509405951 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import numpy as np\nA, B, N = map(int, input().split())\n\nx = np.arange(1, max(10**6,N+1))\nprint(int(np.max(np.floor(A*x/B)-A*np.floor(x/B))))', 'import math\nA, B, N = map(int, input().split())\n\nif (B == 1):\n print(0)\nelif (B > N+1):\n x = N\n print((A*x)//B-A*(x//B))\nelse:\n x = N-N%(B-1)\n print((A*x)//B-A*(x//B))'] | ['Runtime Error', 'Accepted'] | ['s210350949', 's258572769'] | [58320.0, 9188.0] | [125.0, 22.0] | [140, 172] |
p02696 | u511268447 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ["if __name__ == '__main__':\n from sys import stdin\n # from collections import defaultdict\n import math\n input = stdin.readline\n\n import random\n\n while True:\n # a, b, n = map(int, input().split())\n a = random.randint(1, 10**6)\n b = random.randint(1, 10**12)\n n = random.randint(1, 10**12)\n if b > n:\n print(int(math.floor(a*n/b)-a*math.floor(n/b)))\n exit()\n\n if b >= 10**6:\n ans = 0\n for i in (b-1, n+1, b):\n temp = math.floor(a*i/b)-a*math.floor(i/b)\n if ans < temp:\n ans = temp\n print(int(ans))\n exit()\n\n ans = int(math.floor(a*n/b)-a*math.floor(n/b))\n i = math.floor(n/b)*b-1\n for _ in range(2*10**6):\n temp = math.floor(a*i/b)-a*math.floor(i/b)\n if ans < temp:\n ans = temp\n i -= b\n if i <= 0:\n print(int(ans))\n exit()\n print(int(ans))\n\n\n\n", 'if __name__ == \'__main__\':\n from sys import stdin\n # from collections import defaultdict\n import math\n input = stdin.readline\n\n # import random\n\n a, b, n = map(int, input().split())\n """\n a = random.randint(1, 10**6)\n b = random.randint(1, 10**6)\n n = random.randint(1, 10**12)\n """\n # print(a, b, n)\n \n if b > n:\n # print(\'a\')\n print(int(math.floor((a*n)/b) - a*math.floor(n/b)))\n exit()\n print(int(math.floor((a*(b-1))/b)))'] | ['Wrong Answer', 'Accepted'] | ['s096777237', 's104911252'] | [9500.0, 9136.0] | [22.0, 21.0] | [1035, 492] |
p02696 | u511379665 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['from math import gcd\n\na,b,n=map(int,input().split())\nt=a*b//gcd(a,b)\n\nans=[]\n\nfor i in range(1,t+1):\n y=int(a*i/b)-a*int(i/b)\n ans.append(y)\n\nn%=t\nans=ans[:t]\nprint(max(ans))\n', '\na,b,n=map(int,input().split())\n\ndef f(x):\n return a*x//b-a*(x//b)\n\nprint(f(min(n,b-1)))'] | ['Wrong Answer', 'Accepted'] | ['s341870297', 's512880065'] | [192620.0, 9192.0] | [2211.0, 18.0] | [181, 91] |
p02696 | u513929200 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A = int(input())\nB = int(input())\nN = int(input())\nprint(int(A*(N-1)/B)-A*int((N-1)/B))', 'A = int(input())\nB = int(input())\nN = int(input())\nprint(int(A*(N-1)/B)-A*int((N-1)/B))', 'A,B,N=map(int,input().split())\nif N+1>=B:\n T=int(A*(B-1)/B)\n print(T)\nelse:\n T=int(A*N/B)\n print(T)'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s863206827', 's903569964', 's475560360'] | [9164.0, 9168.0, 9172.0] | [24.0, 21.0, 23.0] | [87, 87, 111] |
p02696 | u515874757 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n=map(int, input().split())\nprint(max(list( a*x/b//1 - x/b//1*a for x in range(1,n+1) )))\n', 'a,b,n=map(int, input().split())\n\nx=min(b-1,n)\n\nprint(int(a*x/b))'] | ['Wrong Answer', 'Accepted'] | ['s888051931', 's295430962'] | [247568.0, 9092.0] | [2214.0, 20.0] | [94, 64] |
p02696 | u519339498 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ["'''\nCreated on 2020/08/29\n\n@author: harurun\n'''\ndef main():\n import sys\n pin=sys.stdin.readline\n pout=sys.stdout.write\n perr=sys.stderr.write\n \n A,B,N=map(int,pin().split())\n t=int(B/A)\n ans=0\n for x in range(t,B+1):\n ans=max(ans,int(A*x/B)-A*int(x/B))\n print(ans)\n return \nmain()", "'''\nCreated on 2020/08/29\n\n@author: harurun\n'''\ndef main():\n import sys\n pin=sys.stdin.readline\n pout=sys.stdout.write\n perr=sys.stderr.write\n\n A,B,N=map(int,pin().split())\n x=min(B-1,N)\n ans=int(A*x/B)-A*int(x/B)\n print(ans)\n return\nmain()\n"] | ['Wrong Answer', 'Accepted'] | ['s783555073', 's126242015'] | [9132.0, 9080.0] | [2206.0, 29.0] | [294, 259] |
p02696 | u520843951 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import time\n\ndef floor(y):\n return int(y)\n\ndef main():\n t1 = time.time()\n\n a, b, n = map(int, input().split())\n ans = [floor(a*x/b) - a*floor(x/b) for x in range(1, n+1)]\n print(max(ans))\n\n t2 = time.time()\n\n print(f"経過時間：{t2-t1}")\n\nif __name__ == "__main__":\n main()', 'import math\na, b, n = map(int, input().split())\nx = min(b-1, n)\nprint(math.floor(a*(x%b)/b))'] | ['Wrong Answer', 'Accepted'] | ['s778556192', 's946512114'] | [58920.0, 9084.0] | [2207.0, 23.0] | [301, 92] |
p02696 | u521602455 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A,B,N=map(int,input().split())\nans=0\nprint(int(A*(B-1)/B)-A*int((B-1)/B))\nif B>=N:\n for i in range(0,10**6):\n x=N-i\n if x<0:\n break\n tmp=int(A*x/B)-A*int(x/B)\n ans=max(ans,tmp)\n #print(ans)\nelif B<N:\n for i in range(0,10**6):\n x=N-i\n if x<0:\n break\n tmp=int(A*x/B)-A*int(x/B)\n ans=max(ans,tmp)\n for i in range(0,10**6):\n x=B-i\n if x<0:\n break\n tmp=int(A*x/B)-A*int(x/B)\n ans=max(ans,tmp)\n #print(ans)', 'A,B,N=map(int,input().split())\nans=0\nif B>=N:\n for i in range(0,10**6):\n x=N-i+100\n if x<0:\n break\n tmp=int(A*x/B)-A*int(x/B)\n ans=max(ans,tmp)\n print(ans)\nelif B<N:\n for i in range(0,10**6):\n x=N+100-i\n if x<0:\n break\n tmp=int(A*x/B)-A*int(x/B)\n ans=max(ans,tmp)\n for i in range(0,10**6):\n x=B+100-i\n if x<0:\n break\n tmp=int(A*x/B)-A*int(x/B)\n ans=max(ans,tmp)\n print(ans)', 'A,B,N=map(int,input().split())\nif B<=N:\n print(int(A*(B-1)/B)-A*int((B-1)/B))\nelse:\n print(int(A*(N)/B)-A*int(N/B))'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s369105784', 's510115698', 's021993772'] | [9248.0, 9260.0, 9200.0] | [1555.0, 1733.0, 23.0] | [532, 505, 121] |
p02696 | u526094365 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\n\nA, B, N = map(int, input().split())\n\n\nans1 = 0\n\nx = int(B/A)\nwhile x <= N and x <= B:\n ans = int((A * x) / B) - A * int(x / B)\n print(((A * x) / B), (x / B))\n ans1 = max(ans1, ans)\n x += 1\nprint(ans1)\n', 'import math\n\nA, B, N = map(int, input().split())\n\n\nans1 = 0\n\nif N > B - 1:\n x = B-1\n print(int((A * x) / B) - A * int(x / B))\nelif N <= B - 1:\n x = N\n print(int((A * x) / B) - A * int(x / B))\n\n\n'] | ['Wrong Answer', 'Accepted'] | ['s667971019', 's238800241'] | [38196.0, 9164.0] | [2491.0, 22.0] | [226, 206] |
p02696 | u531219227 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A,B,N = map(int,input().split())\nmax_num = 0\nnum = 0\nfor i in range(1,N+1):\n if (A*i//B) - A*(i//B) > max_num:\n max_num = (A*i//B) - A*(i//B)\n num = i\n \nprint(i)', 'A,B,N = map(int,input().split())\nnum = min(B-1,N)\n\nprint((A*num//B)-A*(num//B))'] | ['Wrong Answer', 'Accepted'] | ['s690643868', 's668523462'] | [9176.0, 9160.0] | [2206.0, 24.0] | [171, 79] |
p02696 | u531220228 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['solved_flag = False\nif B==1:\n ans = 0\n solved_flag = True\nelse:\n if B <= N:\n x = B-1\n else:\n x = N\n\nif not solved_flag:\n ans = math.floor(A*x/B) - A*math.floor(x/B)\nprint(ans)', 'import math\n\nA, B, N = map(int, input().split())\n\nsolved_flag = False\nif B==1:\n ans = 0\n solved_flag = True\nelse:\n if B <= N:\n x = B-1\n else:\n x = N\n\nif not solved_flag:\n ans = math.floor(A*x/B) - A*math.floor(x/B)\nprint(ans)'] | ['Runtime Error', 'Accepted'] | ['s458475035', 's822200469'] | [9108.0, 9068.0] | [22.0, 24.0] | [204, 254] |
p02696 | u534308356 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A, B, N = map(int, input().split())\n\nans = 0\nfor x in range(B):\n A_x = A * x\n left_ = int(A_x / B)\n right_ = A * int(x / B)\n fnc_ = left_ - right_\n if fnc_ <= N:\n ans = max(ans, fnc_)\n \n\n # print(" x", x)\n \n # print("right_", right_)\n \n\n\nprint(ans)\n\n', 'A, B, N = map(int, input().split())\n\nans = 0\n\nx = min(N, B-1)\n\nA_x = A * x\nans = int(A_x / B) - A * int(x / B)\n\nprint(ans)\n'] | ['Wrong Answer', 'Accepted'] | ['s127789621', 's366003472'] | [8972.0, 8940.0] | [2205.0, 21.0] | [360, 123] |
p02696 | u539514977 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A,B,N = map(int,input().split())\nx = B-1\na = 0\nwhile x >= (B-1)*9/10:\n if a < A*x//B - A*(x//B):\n a = A*x//B - A*(x//B)\n x -= 1\n else:\n x -= 1\nprint(a)\n', 'A,B,N = map(int,input().split())\nprint(min(N, B-1))\n', 'A,B,N = map(int,input().split())\nx = 0\na = 0\nwhile x <= B-1:\n if a < A*x//B - A*(x//B):\n a = A*x//B - A*(x//B)\n x += 1\n else:\n x += 1\nprint(a)\n', 'A,B,N = map(int,input().split())\nx = min(N, B-1)\na = A*x//B - A*(x//B)\nprint(a)\n'] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s695096710', 's770524564', 's981660899', 's458745732'] | [9172.0, 9012.0, 9164.0, 9032.0] | [2205.0, 20.0, 2205.0, 22.0] | [163, 52, 154, 80] |
p02696 | u540761833 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A,B,N = map(int,input().split())\nans = max((A*N)//B-A*(N//B),(A*(B-1))//B)\nprint(ans)', 'A,B,N = map(int,input().split())\nif N >= B-1:\n ans = max((A*N)//B-A*(N//B),(A*(B-1))//B)\nelse:\n ans = A*N//B - A*(N//B)\nprint(ans)'] | ['Wrong Answer', 'Accepted'] | ['s413757292', 's070618956'] | [9168.0, 8936.0] | [23.0, 20.0] | [85, 136] |
p02696 | u542605091 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['n, m = map(int, input().split())\ncount = 0\nif n % 2 == 0:\n for i in range(int(n/2)):\n print(i+1, n-i-1)\n count += 1\n if count == m:\n break;\nelse:\n for i in range(int((n-1)/2)):\n print(i+1, n-i-2)\n count += 1\n if count == m:\n break;', 'a, b, n = map(int, input().split())\nif n < b:\n print(a*n//b)\nelse:\n print((a*(b-1))//b)'] | ['Runtime Error', 'Accepted'] | ['s788345603', 's607984516'] | [9200.0, 9108.0] | [25.0, 20.0] | [301, 93] |
p02696 | u545368057 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n = map(int, input().split())\n\ndef f(x):\n return (a*(x%b)-(a*b)%b)//b\n\nans = f(min(n,b-1))', 'a,b,n = map(int, input().split())\n"""\nfloor(ax/b) - a*floor(x/b)\n= (ax-(ax)%b)/b - a*(x-x%b)/b\n= (a*(x%b)-(ax)%b)/b\n"""\ndef f(x):\n return (a*(x%b)-(a*b)%b)//b\n\nans = f(min(n,b-1))\nprint(ans)'] | ['Wrong Answer', 'Accepted'] | ['s597091734', 's031306772'] | [9156.0, 9084.0] | [21.0, 25.0] | [97, 193] |
p02696 | u546338822 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['def main():\n a,b,n = map(int,input().split())\n if b>n:\n print(int(a*(n/b-n//b)))\n else:\n print(int(a*((b-1)/b))\n\n\nif __name__ == "__main__":\n main()', 'def main():\n a,b,n = map(int,input().split())\n if b>n:\n print(int(a*(n/b-n//b)))\n else:\n print(int(a*((b-1)/b)))\n\n\nif __name__ == "__main__":\n main()'] | ['Runtime Error', 'Accepted'] | ['s359889729', 's272033856'] | [9032.0, 9180.0] | [20.0, 22.0] | [174, 175] |
p02696 | u546618578 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ["import math\n\na, b, n = map(int, input().split())\n\nif n < b:\n print('a')\n ans = math.floor(a*n/b) - a * math.floor(n/b)\n print(ans)\nelse:\n ans = a - a // b - 1\n print(ans)", "import math\n\na, b, n = map(int, input().split())\n\nif n < b:\n print('a')\n ans = math.floor(a*n/b) - a * math.floor(n/b)\n print(ans)\nelse:\n ans = a - (a-1) // b - 1\n print(ans)", 'import math\n\na, b, n = map(int, input().split())\n\nif n < b:\n ans = math.floor(a*n/b) - a * math.floor(n/b)\n print(ans)\nelse:\n ans = a - (a-1) // b - 1\n print(ans)'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s907881095', 's931699632', 's622216118'] | [9180.0, 9120.0, 9172.0] | [21.0, 22.0, 23.0] | [185, 189, 174] |
p02696 | u548123110 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\n\n\ndef main():\n a,b,n = map(int,input().split())\n m = math.floor(a * 0 /b) - a * math.floor(0/b)\n for i in range(1,b):\n if m < math.floor(a * i / b) - a * math.floor(i/b):\n\n m = math.floor(a * i / b) - a * math.floor(i/b)\n print(m)\nif __name__ == "__main__":\n main()\n', 'import math\n\n\ndef main():\n a,b,n = map(int,input().split())\n m = math.floor(a * 0 /b) - a * math.floor(0/b)\n for i in range(1,min(b-1,n)+1):\n if m < math.floor(a * i / b) - a * math.floor(i/b):\n m = math.floor(a * i / b) - a * math.floor(i/b)\n break\n print(m)\nif __name__ == "__main__":\n main()\n', 'import math\n\n\ndef main():\n a,b,n = map(int,input().split())\n # m = math.floor(a * 0 /b) - a * math.floor(0/b)\n \n \n \n i = min(b-1,n)\n m = a*i//b - a*(i//b)\n \n print(m)\nif __name__ == "__main__":\n main()\n'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s132315911', 's590872907', 's323200926'] | [9096.0, 9004.0, 9024.0] | [2205.0, 671.0, 22.0] | [311, 339, 379] |
p02696 | u551058317 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A, B, N = [int(v) for v in input().strip().spilt(" ")]\n\nif N < B:\n\tprint(int(A * N * B) - A * int(N / B))\nelse:\n print(int(A * (B - 1) * B) - A * int((B - 1) / B))', 'A, B, N = [eval(v) for v in input().strip().split(" ")]\n\nif N < B:\n print(int(A * N / B) - A * int(N / B))\nelse:\n print(int(A * (B - 1) / B) - A * int((B - 1) / B))'] | ['Runtime Error', 'Accepted'] | ['s059148291', 's909951210'] | [9048.0, 9100.0] | [25.0, 23.0] | [166, 170] |
p02696 | u552741877 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\na,b,n = map(int, input().split())\n\ndef floor(t):\n return math.floor(t)\n\nx = b - 1\n\nmax = floor(a * x / b) - a * floor(x / b)\nprint(max)\n', 'import math\na,b,n = map(int, input().split())\n\ndef floor(t):\n return math.floor(t)\n\nx = b - 1\nif x > n:\n x = n\n\nmax = floor(a * x / b) - a * floor(x / b)\nprint(max)\n'] | ['Wrong Answer', 'Accepted'] | ['s649015383', 's395959021'] | [9128.0, 9060.0] | [23.0, 21.0] | [149, 167] |
p02696 | u556589653 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\ndef equation(a,b,n):\n return math.floor((a*x)/b)-A*math.floor(x/B)\nd,e,f = map(int,input().split())\nX = equation(d,e,f)\nY = equation(d,e,e-1)\nprint(max(X,Y))', 'A,B,N = map(int,input().split())\nx = math.gcd(N,B)\nK = math.floor(N/B)\nif K == 0:\n print(math.floor(A*N/B)-A*math.floor(N/B))\nelse:\n alpha = B*(K+1)-1\n if alpha > N:\n alpha = N\n print(math.floor(alpha/B)-A*math.floor(alpha/B))', 'import math\ndef equation(a,b,n):\n return math.floor((a*n)/b)-a*math.floor(n/b)\nd,e,f = map(int,input().split())\nK = min(e-1,f)\nprint(equation(d,e,K))\n'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s457620045', 's479569730', 's947357586'] | [9132.0, 9052.0, 9088.0] | [20.0, 23.0, 22.0] | [170, 245, 151] |
p02696 | u560988566 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\n\na, b, n = map(int, input().split())\n\nk = n//b\n\nans = math.floor(a*(k*b-1)/b) - a*(k-1)\n\nprint(ans)', 'import math\n\na, b, n = map(int, input().split())\n\nans = math.floor(a*min(b-1, n)/b)\n\nprint(ans)'] | ['Wrong Answer', 'Accepted'] | ['s628705422', 's063108095'] | [9024.0, 9092.0] | [27.0, 24.0] | [111, 95] |
p02696 | u561862393 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import sys\ninput = sys.stdin.readline\nimport numpy as np\nimport time\n\n\n\n\n\ndef make_table(n, m):\n Table = [None]*n\n for i in range(n):\n rem = np.random.randint(1,m+1)\n Table[i] = rem\n return Table\n\nt0 = time.time()\nn, m, q = map(int, input().split())\nLis = [[int(e) for e in input().split()] for _ in range(q)]\n\nSum_cor = []\nfor i in range(10000000000):\n if m >=6:\n Table = make_table(n,m)\n else:\n Table = make_table(n,m)\n Table.sort()\n d_sum = 0\n for l in Lis:\n if Table[l[1]-1]-Table[l[0]-1] == l[2]:\n d_sum+=l[3]\n Sum_cor.append(d_sum)\n t1 = time.time()\n if t1-t0 >1.8:\n print(max(Sum_cor))\n break\n', 'import sys\ninput = sys.stdin.readline\n\n\na, b, c= map(int, input().split())\n\n\n#f_table = [a*t//b for t in range(b)]\n\nif c >= b:\n print((a * (b-1)) // b)\n\nelse:\n x = c\n c_amari = c%b\n c_sho = c//b\n ans =(a * c_amari) //b\n print(ans)\n'] | ['Runtime Error', 'Accepted'] | ['s126150975', 's219313692'] | [99168.0, 9168.0] | [2209.0, 21.0] | [887, 249] |
p02696 | u563676207 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['# input\nA, B, N = map(int, input().split())\n\n# process\nx = 0\nif B <= N:\n x = B-1\nelse:\n x = N\n\n# output\nprint(x)\nprint(A*x//B - A*(x//B))\n', '# input\nA, B, N = map(int, input().split())\n\n# process\nx = 0\nif B <= N:\n x = B-1\nelse:\n x = N\n\n# output\nprint(A*x//B - A*(x//B))\n'] | ['Wrong Answer', 'Accepted'] | ['s860573062', 's786746050'] | [9040.0, 9160.0] | [22.0, 22.0] | [144, 135] |
p02696 | u563838154 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n=map(int,input().split())\nscore=0\nif (n<b):\n print( int(a*n/b))\nelif(b＝＝１):\n print(0)\nelse:\n c = int(n/b)\n score = 0\n for i in range(1,c+1):\n n_ = b*i-1\n t = int(a*n_/b)-a*int(n_/b)\n score = max(score,t)\n t = int(a*n/b)-a*int(n/b)\n score = max(score,t)\n print(score)', 'a,b,n=map(int,input().split())\nscore=0\nif (n<b):\n print( int(a*n/b))\nelif(b==1):\n print(0)\nelse:\n c = int(n/b)\n score = 0\n for i in range(1,c+1):\n n_ = b*i-1\n t = int(a*n_/b)-a*int(n_/b)\n score = max(score,t)\n t = int(a*n/b)-a*int(n/b)\n score = max(score,t)\n print(score)'] | ['Runtime Error', 'Accepted'] | ['s011244631', 's304916693'] | [8928.0, 9144.0] | [24.0, 22.0] | [322, 316] |
p02696 | u571537830 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a, b, n = map(int, input().split())\n\nx = max(b-1, n)\n\nprint((a*x)//b)', 'a, b, n = map(int, input().split())\n\nx = min(b-1, n)\n\nprint((a*x)//b)'] | ['Wrong Answer', 'Accepted'] | ['s828932248', 's616340621'] | [9024.0, 9092.0] | [26.0, 29.0] | [69, 69] |
p02696 | u573234244 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n = map(int,input().split())\n\nif b >= n:\n t = int(a * n / b) - a * int(n/b)\n for i in range(100000):\n t_ = int(a * (n+i) / b) - a * int((n+i)/b)\n if t_ > t:\n t = t_\nelse:\n t = int(a * n / b) - a * int(n/b)\n \nprint(t)', 'a,b,n = map(int,input().split())\n\nif b > n:\n t = int(a * n / b) - a * int(n/b)\nelse:\n x = b-1\n t = int(a * x / b) - a * int(x/b)\n \nprint(t)'] | ['Wrong Answer', 'Accepted'] | ['s011453709', 's080606808'] | [9184.0, 9168.0] | [86.0, 21.0] | [257, 151] |
p02696 | u573673983 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A,B,N = (int(i) for i in input().split())\nmax_num = -10**100\ntmp_num = 0\ncnt = 1\nflg = False\nwhile flg == False:\n tmp_num = math.floor(A*cnt/B) - A*math.floor(cnt/B)\n #print(tmp_num)\n if tmp_num > max_num :\n max_num = tmp_num\n cnt += 1\n else:\n flg = True\nprint(max_num)', 'a, b, n = map(int, input().split())\nif n >= b - 1:\n print(int(a - a / b))\nelse:\n print(int(a * n / b) - a * int(n / b))'] | ['Runtime Error', 'Accepted'] | ['s353531308', 's132095213'] | [9032.0, 9052.0] | [21.0, 22.0] | [283, 125] |
p02696 | u573678402 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a, b, n = map(int, input().split(" "))\n\nmax_score = 0\ny = a // b\nfor x in range(y - 100, y + 200):\n score = a * x // b - a * ( x // b )\n if score > max_score:\n max_score = score\nprint(max_score)\n', 'a, b, n = map(int, input().split(" "))\n\nmax_score = 0\ny = min(b, n)\n\nfor x in range(max(y - 100000, 1) , min(y + 200000, n+1)):\n score = a * x // b - a * ( x // b )\n if score > max_score:\n max_score = score\nprint(max_score)\n'] | ['Wrong Answer', 'Accepted'] | ['s642749970', 's391850206'] | [9164.0, 9180.0] | [24.0, 131.0] | [208, 237] |
p02696 | u576927476 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import sys\n\n\na,b,n = (int(i) for i in input().split())\n\n\nans = b-1\n\n\n\nprint(ans)\n', 'import sys\n\n\na,b,n = (int(i) for i in input().split())\n\n\nif n < b-1:\n ans = (a*n//b)\n\nelse:\n ans = ((b-1)*a)//b\n\n\n\nprint(ans)\n'] | ['Wrong Answer', 'Accepted'] | ['s350807598', 's025593002'] | [9152.0, 9156.0] | [19.0, 20.0] | [81, 132] |
p02696 | u577766140 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['list=input().split(" ")\nA=int(list[0])\nB=int(list[1])\nN=int(list[2])\n\nif B>N:\n B=N-1\n\nprint(int(A*B/N) - int(B/N)*A)', 'list=input().split(" ")\nA=int(list[0])\nB=int(list[1])\nN=int(list[2])\n\nif N>=B:\n N=B-1\n\nprint(int(A*N/B) - int(N/B)*A)'] | ['Wrong Answer', 'Accepted'] | ['s710915644', 's626429892'] | [9124.0, 9152.0] | [21.0, 21.0] | [119, 120] |
p02696 | u580273604 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A,B,N=map(int,input().split())\n\n#c=[0]*N\ns=0\nprint(max(N,(A*N)//B-A*(N//B)))\n\nexit\nfor i in range(1,N+1):\n if s<(A*i)//B-A*(i//B):\n s=(A*i)//B-A*(i//B)\n\nprint(s)', 'A,B,N=map(int,input().split())\n#if B==1:print(0);exit()\nif N>=B:print((A*(B-1))//B)\nelse:\n print((A*N)//B-A*(N//B))'] | ['Wrong Answer', 'Accepted'] | ['s665695758', 's985780469'] | [9128.0, 9108.0] | [2205.0, 26.0] | [188, 116] |
p02696 | u581187895 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['\ndef resolve():\n def f(x):\n res = (A*x)//B - A*(x//B)\n return res\n\n A, B, N = map(int, input().split())\n x = min(B-1, N)\n print(f(x))\n\nif __name__ == "__main__":\n resolve():', '\ndef resolve():\n def f(x):\n res = (A*x)//B - A*(x//B)\n return res\n\n A, B, N = map(int, input().split())\n x = min(B-1, N)\n print(f(x))\n\nif __name__ == "__main__":\n resolve()'] | ['Runtime Error', 'Accepted'] | ['s613527991', 's975297772'] | [8924.0, 9080.0] | [20.0, 23.0] | [202, 201] |
p02696 | u590212853 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['#!/usr/bin/python3\n\nimport math\n\ninput_1 = input()\na = int(input_1.split(" ")[0])\nb = int(input_1.split(" ")[1])\nn = int(input_1.split(" ")[2])\n\n\n\nscore = math.floor(a/b*math.min(b-1, n))\nprint(score)', '#!/usr/bin/python3\n\nimport math\n\ninput_1 = input()\na = int(input_1.split(" ")[0])\nb = int(input_1.split(" ")[1])\nn = int(input_1.split(" ")[2])\n\n\n\nscore = math.floor(a/b*min(b-1, n))\nprint(score)'] | ['Runtime Error', 'Accepted'] | ['s962538887', 's356556005'] | [9024.0, 9152.0] | [20.0, 24.0] | [253, 248] |
p02696 | u591143370 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\nA,B,N = map(int, input().split())\ns=0\nx=1\nmf=math.floor\nwhile True:\n q=mf(A*x/B)-A*mf(x/B)\n if s<=q:\n s=q\n #print(q)\n x=x+1\n continue\n if s>q:\n print(s)\n break', 'import math\nA,B,N = map(int, input().split())\ns=0\nx=1\nmf=math.floor\nwhile True:\n q=mf(A*x/B)-A*mf(x/B)\n if s<=q:\n s=q\n print(q)\n x=x+1\n continue\n if s>q:\n print(s)\n break\n', 'import math\nA,B,N = map(int, input().split())\n\nmf=math.floor\nif N<B-1:\n q=mf(A*N/B)-A*mf(N/B)\n print(q)\nelse:\n a=math.floor(A*(B-1)/B)\n print(a)'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s234953278', 's667190919', 's428342309'] | [9168.0, 9852.0, 9184.0] | [2205.0, 2217.0, 21.0] | [222, 222, 156] |
p02696 | u593019570 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\na,b,n = map(int,input().split())\nans = max(math.floor(a * (b-1) / b) - a * math.floor((b-1) / b), math.floor(a * n / b) - a * math.floor(n / b))\n \nprint(ans)', 'import math\na,b,n = map(int,input().split())\nc = n // b * b - 1\nans = max(math.floor(a * c / b) - a * math.floor(c / b), math.floor(a * n / b) - a * math.floor(n / b))\n\nprint(ans)', 'a,b,n = map(int,input().split())\nc = n // b * b\nans=0\nif n > b - 1:\n ans = math.floor(a * c / b) - a * math.floor(c / b)\n\nelse:\n \n #print(i+1)\n #print(math.floor(a * (i+1) / b) - a * math.floor((i+1) / b))\n #if math.floor(a * (i+1) / b) - a * math.floor((i+1) / b) > ans:\n # ans = math.floor(a * (i+1) / b) - a * math.floor((i+1) / b)\n ans = math.floor(a * n / b) - a * math.floor(n / b)\nprint(ans)\n ', 'import math\na,b,n = map(int,input().split())\nc = max(0,n // b * b - 1)\nans = math.floor(a * c / b) - a * math.floor(c / b)\n \nprint(ans)\n', 'import math\na,b,n = map(int,input().split())\nc = n // b * b - 1\nans = max(math.floor(a * c / b) - a * math.floor(c / b), math.floor(a * n / b) - a * math.floor(n / b), 0)\n \nprint(ans)', 'import math\na,b,n = map(int,input().split())\nc = max(0,n // b * b - 1)\nans = mmath.floor(a * n / b) - a * math.floor(n / b)\n \nprint(ans)\n', 'print(0)', 'import math\na,b,n = map(int,input().split())\nc = max(0,n // b * b - 1)\nans = mmath.floor(a * c / b) - a * math.floor(c / b)\n \nprint(ans)', 'import math\na,b,n = map(int,input().split())\nc = min(n,b - 1)\nans = math.floor(a * c / b) - a * math.floor(c / b)\n \nprint(ans)'] | ['Wrong Answer', 'Wrong Answer', 'Runtime Error', 'Wrong Answer', 'Wrong Answer', 'Runtime Error', 'Wrong Answer', 'Runtime Error', 'Accepted'] | ['s076121793', 's091224647', 's098045196', 's572116580', 's704613913', 's874037954', 's894000046', 's944735844', 's556369065'] | [9148.0, 9164.0, 9148.0, 9128.0, 9156.0, 9108.0, 9020.0, 9200.0, 9164.0] | [23.0, 24.0, 21.0, 23.0, 21.0, 20.0, 21.0, 20.0, 20.0] | [169, 179, 462, 136, 183, 137, 8, 136, 126] |
p02696 | u594956556 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A, B, N = map(int, input().split())\nprint(min(B-1, N))', 'A, B, N = map(int, input().split())\nprint(A*min(B-1, N)//B)\n'] | ['Wrong Answer', 'Accepted'] | ['s373501606', 's140596686'] | [9152.0, 9092.0] | [21.0, 25.0] | [54, 60] |
p02696 | u595893956 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n = map(int,input().split())\nprint(min(n,b-1)/b*a)', 'a,b,n = map(int,input().split())\nprint(min(n,b-1)*a//b)\n'] | ['Wrong Answer', 'Accepted'] | ['s547721590', 's681522934'] | [9100.0, 9132.0] | [21.0, 23.0] | [54, 56] |
p02696 | u602773379 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['from math import factorial as fact\nimport math\nimport sys\nimport itertools\nimport numpy as np\nfrom collections import Counter\nimport datetime\n\n\n\ndef input1():\n\treturn int(input())\n\n\ndef input2():\n\treturn map(int,input().split())\n\n\ndef input_array():\n\treturn list(map(int,input().split()))\n\ndef keta(N):\n\treturn len(str(N))\n\n\ndef input_daytime(input_time):\n\ttime,distance=input_time.split()\n\tt=time.split(":")\n\tse=str(t[-1]).split(".")\n\tdt1 = datetime.timedelta(hours=int(t[0]),minutes=int(t[1]),seconds=int(se[0]),milliseconds=int(se[1]))\n\treturn dt1\n\ndef combinations(n,r):\n\treturn list(itertools.combinations(range(n),r))\n\n\n\ndef all_sets(num_list):\n\tsubsets=[]\n\tfor i in range(2,len(num_list) + 1):\n\t\tfor c in combinations(num_list, i):\n\t\t\tsubsets.append(c) \n\treturn subsets\n\n\ndef ch(x1):\n\tcf=[]\n\tfor i in range(2,math.sqrt(x1)+1):\n\t\tif x1 % i==0:\n\t\t\tcf.append(i)\n\treturn cf\n\ndef CountOneRoots(x,y):\n\t\n\treturn fact(x+y)/fact(x)/fact(y)\n\n\ndef factorization(n):\n\ttmp=n\n\tcount=0\n\tfor i in range(2,int(n**0.5)+2):\n\t\tif tmp%i==0:\n\t\t\tcnt=0\n\t\t\twhile tmp%i==0:\n\t\t\t\tcnt+=1\n\t\t\t\ttmp//=i\n\t\t\tcount+=1\n\tif tmp!=1:\n\t\tcount+=1\n\n\treturn count\n\t\t\t\n\ndef fl(a,b,x):\n\tx=math.floor(a*x/b)\n\ty=a*math.floor(x/b)\n\t\n\n\n\n# abcd=[]\n# A=[0]*n\n\n# \tabcd.append(input_array())\n\na,b,n=input2()\nif b>n:\n\tb_ans=fl(a,b,n)\nelse:\n\tb_ans=fl(a,b,b-1)\n\n\n# \tans=fl(a,b,i)\n# \tif ans> b_ans:\n# \t\tb_ans=ans\n# if i<n:\n# \tans=fl(a,b,n)\n# \tif ans> b_ans:\n# \t\tb_ans=ans\nprint(b_ans)\n\n', 'from math import factorial as fact\nimport math\nimport sys\nimport itertools\nimport numpy as np\nfrom collections import Counter\nimport datetime\n\n\n\ndef input1():\n\treturn int(input())\n\n\ndef input2():\n\treturn map(int,input().split())\n\n\ndef input_array():\n\treturn list(map(int,input().split()))\n\ndef keta(N):\n\treturn len(str(N))\n\n\ndef input_daytime(input_time):\n\ttime,distance=input_time.split()\n\tt=time.split(":")\n\tse=str(t[-1]).split(".")\n\tdt1 = datetime.timedelta(hours=int(t[0]),minutes=int(t[1]),seconds=int(se[0]),milliseconds=int(se[1]))\n\treturn dt1\n\ndef combinations(n,r):\n\treturn list(itertools.combinations(range(n),r))\n\n\n\ndef all_sets(num_list):\n\tsubsets=[]\n\tfor i in range(2,len(num_list) + 1):\n\t\tfor c in combinations(num_list, i):\n\t\t\tsubsets.append(c) \n\treturn subsets\n\n\ndef ch(x1):\n\tcf=[]\n\tfor i in range(2,math.sqrt(x1)+1):\n\t\tif x1 % i==0:\n\t\t\tcf.append(i)\n\treturn cf\n\ndef CountOneRoots(x,y):\n\t\n\treturn fact(x+y)/fact(x)/fact(y)\n\n\ndef factorization(n):\n\ttmp=n\n\tcount=0\n\tfor i in range(2,int(n**0.5)+2):\n\t\tif tmp%i==0:\n\t\t\tcnt=0\n\t\t\twhile tmp%i==0:\n\t\t\t\tcnt+=1\n\t\t\t\ttmp//=i\n\t\t\tcount+=1\n\tif tmp!=1:\n\t\tcount+=1\n\n\treturn count\n\t\t\t\n\ndef fl(a,b,x):\n\tb1=x//b\n\tx=math.floor(a*x/b)\n\ty=math.floor(b1)\n\treturn x-y\n\t\n\n\n\n# abcd=[]\n# A=[0]*n\n\n# \tabcd.append(input_array())\n\na,b,n=input2()\nif b>n:\n\tb_ans=fl(a,b,n)\n\t# print(b_ans)\nelse:\n\tb_ans=fl(a,b,b-1)\n\nfor i in range(0,n,b):\n\tans=fl(a,b,i)\n\t# print(ans)\n\tif ans> b_ans:\n\t\tb_ans=ans\n\telse:\n\t\tbreak\n# if i<n:\n# \tans=fl(a,b,n)\n# \tif ans> b_ans:\n# \t\tb_ans=ans\nprint(b_ans)\n\n'] | ['Wrong Answer', 'Accepted'] | ['s739111767', 's775424746'] | [27156.0, 26924.0] | [104.0, 107.0] | [1631, 1686] |
p02696 | u607563136 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n = map(int,input().split())\n\ny = 0\n\nfor x in range(1,n+1):\n if x%b!=0:\n temp = ((a*x)//b) - a*(x//b)\n else:\n temp = 0\n if y < temp:\n y = temp\n ans = x\n \nprint(ans)', 'a,b,n = map(int,input().split())\nx=min(b-1,n)\nprint(((a*x)//b) - a*(x//b))'] | ['Runtime Error', 'Accepted'] | ['s188611434', 's862401446'] | [9180.0, 9152.0] | [2205.0, 31.0] | [208, 74] |
p02696 | u608007704 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A,B,N=map(int,input().split())\n\nans=0\nfor x in range(A*3):\n \n ans=max(ans,A*x//B-A*(x//B))\nprint(ans)', 'A,B,N=map(int,input().split())\n\nans=-100000\nfor x in range(A):\n \n ans=max(ans,(A*x//B)-A*(x//B))\n if x==N:break\nx=B-1\nif x>N:x=N\nans=max(ans,(A*x//B)-A*(x//B))\nprint(ans)'] | ['Wrong Answer', 'Accepted'] | ['s472092750', 's755225465'] | [9040.0, 9064.0] | [1084.0, 415.0] | [143, 213] |
p02696 | u608355135 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\na,b,n=map(int,input().split())\nmax=0\npre=0\nif b//a==0:\n st=1\nelse:\n st=b//a\ncheck=0\nfor i in range(0,n+1,st):\n f=math.floor(a*i/b)-a*math.floor(i/b)\n if f>=max:\n max=f\n if f==0:\n check+=1\n if check>st:\n break\n\nprint(max)\n', 'import math\na,b,n=map(int,input().split())\nmax=0\npre=0\nif b//a-1<=0:\n st=1\nelse:\n st=b//a-1\ncheck=0\nfor i in range(0,n+1,st):\n f=math.floor(a*i/b)-a*math.floor(i/b)\n if f>max:\n max=f\n if f==0:\n check+=1\n if check>st+2:\n break\nprint(max)'] | ['Wrong Answer', 'Accepted'] | ['s312816562', 's475352377'] | [9192.0, 9192.0] | [693.0, 691.0] | [272, 275] |
p02696 | u609307781 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ["# D\n\ninp = input().split(' ')\nA, B, N = int(inp[0]), int(inp[1]), int(inp[2])\n\nalpha, beta = math.floor(A/B), A%B\nif B-1 < N:\n x = B-1\nelse:\n x = N\n \nprint(math.floor(A*x/B) - A * math.floor(x/B))", "# D\n\nimport math\ninp = input().split(' ')\nA, B, N = int(inp[0]), int(inp[1]), int(inp[2])\n\nalpha, beta = math.floor(A/B), A%B\nif B-1 < N:\n x = B-1\nelse:\n x = N\n \nprint(math.floor(A*x/B) - A * math.floor(x/B))"] | ['Runtime Error', 'Accepted'] | ['s293438888', 's757925601'] | [9188.0, 9188.0] | [24.0, 24.0] | [205, 217] |
p02696 | u612261372 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['from math import floor\nA, B, N = map(int,input().split())\n\nx=0\npre=floor(A*x/B)-A*floor(x/B)\nmax_x=0\nmax_i=pre\n\nwhile True:\n\tx +=1\n\tcur=floor(A*x/B)-A*floor(x/B)\n\t\n\tif (cur < pre)and(x<=N):\n\t\tprint(x-1)\n\t\tbreak\n\telif(x>N):\n\t\tprint(max_x)\n\t\tbreak\n\telse:\n\t\tif max_i < cur:\n\t\t\tmax_i = cur\n\t\t\tmax_x = x\n\t\tpre = cur', 'from math import floor\nA, B, N = map(int,input().split())\n\nx=max(N,B-1)\nprint(floor(A*x/B)-A*floor(x/B))', 'from math import floor\nA, B, N = map(int,input().split())\n\nx=min(N,B-1)\nprint(floor(A*x/B)-A*floor(x/B))'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s516467252', 's685178961', 's791257383'] | [9096.0, 9164.0, 9096.0] | [2205.0, 22.0, 22.0] | [326, 104, 104] |
p02696 | u616468898 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\nA, B, N = list(map(int, input().split()))\nminx = min([B-1, N])\nprint(math.floor(A*minx/B) - A*math.floor(minx*B))', 'import math\nA, B, N = list(map(int, input().split()))\nminx = min([B-1, N])\nprint(math.floor(A*minx/B) - A*math.floor(minx/B))'] | ['Wrong Answer', 'Accepted'] | ['s056793911', 's546899826'] | [9084.0, 9140.0] | [21.0, 22.0] | [125, 125] |
p02696 | u617037231 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\nfrom math import floor\nA,B,N = map(int,input().split())\nmaxi = 0\nNpower = 0\ndiff = 0\nS = N\nwhile S/10 >= 1:\n Npower += 1\n S /=10\nif Npower >= 8: \n for i in range(0,10**6+10**5):\n maxi = max(floor((A*i)/B)-A*floor(i/B),maxi)\n for i in range(N-10**6-10**5-10**4-10**3-10**2,N+1):\n maxi = max(floor((A*i)/B)-A*floor(i/B),maxi)\nelse:\n for i in range(0,N+1):\n maxi = max(floor((A*i)/B)-A*floor(i/B),maxi)\nprint(max(maxi-1,0))', 'import math\nfrom math import floor\nA,B,N = map(int,input().split())\nmaxi = 0\nNpower = 0\ndiff = 0\nS = N\nwhile S/10 >= 1:\n Npower += 1\n S /=10\nif Npower >= 7:\n for i in range(0,10**6+3*10**5):\n maxi = max(int((A*i)/B)-A*int(i/B),maxi)\n for i in range(N-10**6,N+1):\n maxi = max(int((A*i)/B)-A*int(i/B),maxi)\nelse:\n for i in range(0,N+2):\n maxi = max(int((A*i)/B)-A*int(i/B),maxi)\nprint(max(maxi,0))', 'import math\nA,B,N = mips()\nK = N-1\nprint(max(math.floor(A*N/B)-A*math.floor(N/B),math.floor(A*K/B)-A*math.floor(K/B),0))', 'import math\nA,B,N = map(int,input().split())\nmaxi = -100000\nNpower = 0\ndiff = 0\nwhile N > 1:\n N /=10\n Npower += 1\nif Npower >= 6:\n diff = N-1000\nfor i in range(diff,N+1):\n maxi = max(math.floor(A*i/B)-A*math.floor(i/B),maxi,0)\nprint(maxi)\n', 'import math\nfrom math import floor\nA,B,N = map(int,input().split())\nmaxi = 0\nNpower = 0\ndiff = 0\nS = N\nwhile S/10 >= 1:\n Npower += 1\n S /=10\nif Npower >= 7:\n for i in range(0,10**6+10**5):\n maxi = max(int((A*i)/B)-A*int(i/B),maxi)\n for i in range(N-2*10**6,N+1):\n maxi = max(int((A*i)/B)-A*int(i/B),maxi)\nelse:\n for i in range(0,N+2):\n maxi = max(int((A*i)/B)-A*int(i/B),maxi)\nprint(max(maxi,0))\n', 'import math\nfrom math import floor\nA,B,N = map(int,input().split())\nmaxi = 0\nNpower = 0\ndiff = 0\nS = N\nwhile S/10 >= 1:\n Npower += 1\n S /=10\nif Npower >= 7:\n for i in range(0,10**6+10**5):\n maxi = max(int((A*i)/B)-A*int(i/B),maxi)\n for i in range(N-2*10**6,N+1):\n maxi = max(int((A*i)/B)-A*int(i/B),maxi)\nelse:\n for i in range(0,N+1):\n maxi = max(int((A*i)/B)-A*int(i/B),maxi)\nprint(0)', 'import math\nA,B,N = map(int,input().split())\nmaxi = -100000\nNpower = 0\ndiff = 0\nwhile N > 1:\n N /=10\n Npower += 1\nif Npower >= 6:\n diff = N-1000\nfor i in range(diff,N+1):\n maxi = max(math.floor(A*i/B)-A*math.floor(i/B),maxi,0)\nprint(maxi)', 'import math\nA,B,N = map(int,input().split())\nmaxi = -100000\nNpower = 0\nwhile N > 1:\n N /=10\n Npower += 1\nif Npower >= 6:\n diff = N-1000\nelse:\n diff = 0\nfor i in range(diff,N+1):\n maxi = max(math.floor(A*i/B)-A*math.floor(i/B),maxi,0)\nprint(maxi)', 'import math\nA,B,N = mips()\nmaxi = -100000\nfor i in range(0,N+1):\n maxi = max(math.floor(A*i/B)-A*math.floor(i/B),maxi)\nprint(maxi)', 'import math\nfrom math import floor\nA,B,N = map(int,input().split())\nmaxi = 0\nNpower = 0\ndiff = 0\nS = N\nwhile S/10 >= 1:\n Npower += 1\n S /=10\nif Npower >= 8: \n for i in range(0,10**6+10**5):\n maxi = max(floor((A*i)/B)-A*floor(i/B),maxi)\n for i in range(N-10**6-10**5-10**4-10**3-10**2,N+1):\n maxi = max(floor((A*i)/B)-A*floor(i/B),maxi)\nelse:\n for i in range(0,N+1):\n maxi = max(floor((A*i)/B)-A*floor(i/B),maxi)\nprint(max(maxi+1,0))\n', 'import math\nfrom math import floor\nA,B,N = map(int,input().split())\ndef f(x):\n return floor(A*x/B) - A*floor(x/B)\nprint(f(min(B-1,N)))'] | ['Wrong Answer', 'Wrong Answer', 'Runtime Error', 'Runtime Error', 'Wrong Answer', 'Wrong Answer', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Wrong Answer', 'Accepted'] | ['s208985769', 's244568270', 's312148177', 's379827456', 's490697277', 's692571798', 's830573494', 's941280985', 's955122771', 's984733905', 's935877298'] | [9236.0, 9232.0, 9100.0, 9184.0, 9176.0, 9216.0, 9192.0, 9224.0, 9104.0, 9228.0, 9040.0] | [1253.0, 1407.0, 20.0, 21.0, 2089.0, 2015.0, 22.0, 22.0, 23.0, 1265.0, 21.0] | [468, 431, 120, 249, 432, 421, 248, 256, 133, 469, 135] |
p02696 | u620157187 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A, B, N = map(int, input().split())\nif N >= B-1:\n result = B-1\nelse:\n result = N\n \nprint(result)', 'A, B, N = map(int, input().split())\nif N >= B-1:\n result = B-1\nelse:\n result = N\n \nprint(min(B-1, N))', 'A, B, N = map(int, input().split())\nif B == 1:\n result = 0\nelif N >= B-1:\n result = B-1\nelse:\n result = N\n \nprint(result)', 'A, B, N = map(int, input().split())\nif B == 1:\n result = 0\nelif B-1 >= N:\n result = min(A, B)-1\nelse:\n result = int(A*N/B) - A*int(N/B)\n \nprint(result)', 'A, B, N = map(int, input().split())\nif B == 1:\n result = 0\nelif N >= B - 1:\n result = int(A*(B-1)/B) - A*int((B-1)/B)\nelse:\n result = int(A*N/B) - A*int(N/B)\n \nprint(result)'] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s033160751', 's529721186', 's644217479', 's810412800', 's487747393'] | [9044.0, 9100.0, 9172.0, 9176.0, 9116.0] | [23.0, 18.0, 19.0, 22.0, 20.0] | [105, 110, 133, 163, 185] |
p02696 | u620238824 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a, b, n = map(int, input().split())\n\nc = min(b - 1, n)\n\n\nprint(((a * c) / b) // 1 - (a * ((c / b) // 1)))', 'a, b, n = map(int, input().split())\n\nc = min(b - 1, n)\n\nprint(int(((a * c) / b) // 1 - (a * ((c / b) // 1))))'] | ['Wrong Answer', 'Accepted'] | ['s775271680', 's193965158'] | [9160.0, 9012.0] | [27.0, 26.0] | [122, 126] |
p02696 | u622847899 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\n\nA,B,N=map(int,input().split())\n\nmax = 0\nfor i in range(B):\n value = math.floor(A*i/B) - A*math.floor(i/B)\n if value > max:\n max=value\nprint(max)\n', 'import math\n\nA,B,N=map(int,input().split())\n\ndef f(x):\n return math.floor(A*x/B) - A*math.floor(x/B)\nprint(f(min(N,B-1)))\n'] | ['Wrong Answer', 'Accepted'] | ['s286913587', 's468975883'] | [9036.0, 9076.0] | [2205.0, 20.0] | [171, 125] |
p02696 | u626228246 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n = map(int,input().split())\n#if b%n != 0:\n\t#print((a*n)//b - ((n//b)*a))\n#else:\nn = b-1\nprint((a*n)//b - ((n//b)*a))\n\t', 'a,b,n = map(int,input().split())\nif b <= n:\n\tprint(a)\n#else:\n\t#print((a*n)//b - ((n//b)*a))', 'a,b,n = map(int,input().split())\nl = (a*n)//b - ((n//b)*a)\nn = b-1\nm = (a*n)//b - ((n//b)*a)\nprint(max(l,m))\n\t', 'a,b,n = map(int,input().split())\nif n >= b:\n\tn = b-1\n\tprint((a*n)//b - ((n//b)*a))\nelse:\n\tprint((a*n)//b - ((n//b)*a))\n\t'] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s142721375', 's327161590', 's998520133', 's378147139'] | [9136.0, 9172.0, 9100.0, 9108.0] | [26.0, 29.0, 26.0, 26.0] | [123, 91, 110, 120] |
p02696 | u626529075 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import math\n\na, b, n = (int(x) for x in input().split())\n\nif b > n:\n print(math.floor(b * n / b) - a * math.floor(n / b))\nelse:\n print(math.floor(a * (b -1) / b) - a * math.floor((b -1) / b))', 'import math\n\na, b, n = (int(x) for x in input().split())\n\nif b > n:\n print(math.floor(a * n / b) - a * math.floor(n / b))\nelse:\n print(math.floor(a * (b -1) / b) - a * math.floor((b -1) / b))'] | ['Wrong Answer', 'Accepted'] | ['s588271794', 's991400472'] | [9176.0, 9120.0] | [22.0, 23.0] | [197, 197] |
p02696 | u627600101 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A, B, N = map(int,input().split())\nimport math\n\nx1 = N\nx3 = min(N,B-1)\ndef f(x): \n t = math.floor((A*x)/B) - A * math.floor(x/B)\n return int(t)\nprint(max(f(x1),f(x3)))\nprint(max(3,3,2))', 'A, B, N = map(int,input().split())\nimport math\nx1 = N\nx2 = min(N,B-1)\ndef f(x): \n return A*x//B - A*(x//B)\nprint(max(f(x1),f(x2)))'] | ['Wrong Answer', 'Accepted'] | ['s985538474', 's595954735'] | [9124.0, 9168.0] | [22.0, 20.0] | [191, 133] |
p02696 | u629350026 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n = map(int, input().split())\nsumtemp=0\nsummax=0\nfor x in range(1,b):\n sumtemp=int(a*x/b)-a*int(x/b)\n if sumtemp>summax:\n summax=sumtemp\nprint(sumtemp)', 'a,b,n = map(int, input().split())\nsumtemp=0\nsummax=0\nfor x in range(1,n+1-b):\n sumtemp=int(a*x/b)-a*int(x/b)\n if sumtemp>summax:\n summax=sumtemp\nprint(sumtemp)', 'a,b,n=map(int,input().split())\nif n>=b:\n print(int(a*(b-1)/b))\nelse:\n print(int(a*n/b))'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s925921549', 's982539797', 's854382788'] | [9056.0, 9176.0, 9164.0] | [2205.0, 2206.0, 20.0] | [168, 172, 89] |
p02696 | u629607744 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['def i():\n return int(input())\ndef i2():\n return map(int,input().split())\ndef s():\n return str(input())\ndef l():\n return list(input())\ndef intl():\n return list(int(k) for k in input().split())\n\na,b,n=i2()\nprint( a*(b-1)//b )', 'def i():\n return int(input())\ndef i2():\n return map(int,input().split())\ndef s():\n return str(input())\ndef l():\n return list(input())\ndef intl():\n return list(int(k) for k in input().split())\n\na,b,n=i2()\nif b<=n:\n\tprint( a*(b-1)//b )\nelse:\n\tprint( a*n//b )'] | ['Wrong Answer', 'Accepted'] | ['s466612210', 's976858610'] | [9096.0, 9164.0] | [22.0, 24.0] | [238, 271] |
p02696 | u632609425 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A,B,N=map(int,input().split())\nresult=0\nfor x in range(0,n+1):\n\ta=int(A*x/B)-A*int(x/B)\n\tif a>result:\n\t\tresult=a\nprint(result)', 'A,B,N=map(int,input().split())\nif B!=1:\n\tp=(N+1)//B\n\tresult=0\n\tif p!=0:\n\t\tfor a in range(1,p+1):\n\t\t\tx=a*B-1\n\t\t\ts=(A*x)//B - A*(a-1)\n\t\t\tif result < s:\n\t\t\t\tresult=s\n\telse:\n\t\tresult=A*N//B -A*(N//B)\n\tprint(result)\nelse:\n\tprint(0)'] | ['Runtime Error', 'Accepted'] | ['s302397716', 's086075196'] | [9172.0, 9204.0] | [24.0, 24.0] | [126, 226] |
p02696 | u634079249 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import sys\nimport os\nimport math\nimport bisect\nimport collections\nimport itertools\n\nii = lambda: int(sys.stdin.buffer.readline().rstrip())\nil = lambda: list(map(int, sys.stdin.buffer.readline().split()))\nfl = lambda: list(map(float, sys.stdin.buffer.readline().split()))\niln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]\n\niss = lambda: sys.stdin.buffer.readline().decode().rstrip()\nsl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))\nisn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]\n\nlcm = lambda x, y: x * y / math.gcd(x, y)\n\nMOD = 10 ** 9 + 7\nMAX = float(\'inf\')\n\n\ndef f(A, B, x):\n return math.floor(A * x / B) - A * math.floor(x / B)\n\n\ndef main():\n if os.getenv("LOCAL"):\n sys.stdin = open("input.txt", "r")\n\n A, B, N = il()\n ret = 0\n mi = math.floor(B / N) + math.floor(A / N)\n for n in range(0, B):\n ret = max(ret, f(A, B, n))\n print(ret)\n\n\nif __name__ == \'__main__\':\n main()\n', 'import sys\nimport os\nimport math\nimport bisect\nimport collections\n\nii = lambda: int(sys.stdin.buffer.readline().rstrip())\nil = lambda: list(map(int, sys.stdin.buffer.readline().split()))\nfl = lambda: list(map(float, sys.stdin.buffer.readline().split()))\niln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]\n\niss = lambda: sys.stdin.buffer.readline().decode().rstrip()\nsl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))\nisn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]\n\nlcm = lambda x, y: x * y / math.gcd(x, y)\n\nMOD = 10 ** 9 + 7\nMAX = float(\'inf\')\n\n\ndef f(A, B, x):\n return math.floor(A * x / B) - A * math.floor(x / B)\n\n\ndef main():\n if os.getenv("LOCAL"):\n sys.stdin = open("input.txt", "r")\n\n A, B, N = il()\n ret = 0\n for n in range(N, B):\n ret = max(ret, f(A, B, n))\n print(ret)\n\n\nif __name__ == \'__main__\':\n main()\n', 'import sys\nimport os\nimport math\nimport bisect\nimport collections\nimport itertools\n\nii = lambda: int(sys.stdin.buffer.readline().rstrip())\nil = lambda: list(map(int, sys.stdin.buffer.readline().split()))\nfl = lambda: list(map(float, sys.stdin.buffer.readline().split()))\niln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]\n\niss = lambda: sys.stdin.buffer.readline().decode().rstrip()\nsl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))\nisn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]\n\nlcm = lambda x, y: x * y / math.gcd(x, y)\n\nMOD = 10 ** 9 + 7\nMAX = float(\'inf\')\n\n\ndef f(A, B, x):\n return math.floor(A * x / B) - A * math.floor(x / B)\n\n\ndef main():\n if os.getenv("LOCAL"):\n sys.stdin = open("input.txt", "r")\n\n A, B, N = il()\n print(f(A, B, min(B - 1, N)))\n\n\nif __name__ == \'__main__\':\n main()\n'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s253653397', 's739037080', 's832779981'] | [9504.0, 9384.0, 9560.0] | [2206.0, 2205.0, 23.0] | [1001, 937, 900] |
p02696 | u636502712 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n=map(int,input().split())\nimport math\nans=0\nfor i in range(1,a+1):\n ans=max(ans,math.floor(a*i/b)-a*math.floor(i/b))\nprint(ans)', 'a,b,n=map(int,input().split())\nimport math\nans=0\nd=min(n,b)\ne=b-1\nif b>d:\n print(math.floor(a*d/b)-a*math.floor(d/b))\nelse:\n print(math.floor(a*e/b)-a*math.floor(e/b))'] | ['Wrong Answer', 'Accepted'] | ['s867502027', 's490088126'] | [9164.0, 9180.0] | [557.0, 22.0] | [135, 173] |
p02696 | u639343026 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import sys\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\n\na,b,x=MAP()\n\ndef f(n):\n return (a*n)//b-a*(n//b)\n\nans=0\npre=0\nnow=x//2\nans=f(now)\ni=1\nwhile True:\n i+=1\n if x//(2**i)==0:\n break\n pre_1=f(now-x//(2**i))\n pre_2=f(now+x//(2**i))\n if pre_1<pre_2:\n ans=pre_2\n now=now+x//(2**i)\n else:\n ans=pre_1\n now=now-x//(2**i)\n\n\nfor i in range(now-10**5,now+10**5):\n pre=f(i)\n if ans<pre:\n ans=pre\nans2=ans\nans=0\npre=0\nnow=x//2\nans=f(now)\ni=1\nwhile True:\n i+=1\n if x//(2**i)==0:\n break\n pre_1=f(now-x//(2**i))\n pre_2=f(now+x//(2**i))\n if i==2:\n pre_1,pre_2=pre_2,pre_1\n if pre_1<pre_2:\n ans=pre_2\n now=now+x//(2**i)\n else:\n ans=pre_1\n now=now-x//(2**i)\nfor i in range(now-10**5,now+10**5):\n pre=f(i)\n if ans<pre:\n ans=pre\n \nif ans<ans2:\n ans=ans2\nprint(ans)', 'import sys\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\n\na,b,x=MAP()\n\ndef f(n):\n return (a*n)//b-a*(n//b)\n\nans=0\npre=0\nnow=x//2\nans=f(now)\ni=1\nwhile True:\n i+=1\n if x//(2**i)==0:\n break\n pre_1=f(now-x//(2**i))\n pre_2=f(now+x//(2**i))\n if pre_1<pre_2:\n ans=pre_2\n now=now+x//(2**i)\n else:\n ans=pre_1\n now=now-x//(2**i)\n\nfor i in range(now-1000,now+1000):\n pre=f(i)\n if ans<pre:\n ans=pre\nprint(ans)\n\n\n', 'import sys\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\n\na,b,x=MAP()\n\ndef f(n):\n return (a*n)//b-a*(n//b)\n\nans=f(x)\n\nfor i in range(x-b-1000,x-b+1000):\n pre=f(i)\n if ans<pre:\n ans=pre\n\nfor i in range(x-b//a-1000,x-b//a-1000):\n pre=f(i)\n if ans<pre:\n ans=pre\n\nprint(ans)\n', 'import sys\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\n\na,b,x=MAP()\n\ndef f(n):\n return (a*n)//b-a*(n//b)\n\nif b<=x:\n print(f(b-1))\nelse:\n print(f(x))\n'] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s117667545', 's262143869', 's423509687', 's200935921'] | [9324.0, 9236.0, 9208.0, 9188.0] | [187.0, 23.0, 21.0, 22.0] | [1033, 598, 429, 289] |
p02696 | u645487439 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a, b, n = map(int, input().split())\nx = b - 1\n\nprint((a * x) // b)\n', 'a, b, n = map(int, input().split())\n\nif b > n:\n x = n\nelse:\n x = b - 1\n\nprint((a * x) // b)\n'] | ['Wrong Answer', 'Accepted'] | ['s480475053', 's524470247'] | [9144.0, 9088.0] | [23.0, 19.0] | [67, 98] |
p02696 | u646110634 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['import sys\nA, B, N = map(int, input().split())\n\nif N < B :\n print(N * A // B - A * N // B)\n sys.exit()\nelse :\n print(((B-1) * A // B) - A * ((B-1) // B))', 'A, B, N = map(int, input().split())\n\nans = set()\nstart = B - 1\n\nfor i in range(1, N + 1, B):\n ans.add(int(i * A / B) - A * int(i / B))\n \nprint(max(ans))', 'A, B, N = map(int, input().split())\n\nif N < B :\n print(N * A // B - A * (N // B))\nelse :\n print((B-1) * A // B - A * ((B-1) // B))'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s077849967', 's676494408', 's623725940'] | [9176.0, 9124.0, 8988.0] | [20.0, 2205.0, 20.0] | [156, 154, 132] |
p02696 | u648092704 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['def f(a, b, x):\n return a*x//b - a*(x//b)\n\na, b, n = map(int, input().split())\n\nt1 = f(a, b, n)\nt2 = f(a, b, n - n%b - 1)\nt = max(t1, t2)\n\nprint(t)', 'def f(a, b, x):\n return (a*x)//b - a*(x//b)\n\na, b, n = map(int, input().split())\n\nt1 = f(a, b, n)\nt2 = f(a, b, max(1, n - n%b - 1))\nt = max(t1, t2)\n\nprint(t)'] | ['Wrong Answer', 'Accepted'] | ['s491094676', 's370620085'] | [9160.0, 9116.0] | [21.0, 21.0] | [150, 160] |
p02696 | u649326276 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['def nibutan(minval,maxval) :\n if maxval-minval<3 :\n return minval;\n elif (func(minval)-func((minval)//2+1))*(func((minval+maxval)//2+1)-func((minval+maxval)//2))<0 :\n return nibutan(minval,(minval+maxval)//2);\n else :\n return nibutan((minval+maxval)//2+1,maxval);\n\ndef func(x) :\n global a,b;\n return (a*x)//b-a*(x//b);\n\na,b,n = list(map(int,input().split()));\nans = nibutan(1,n);\nprint(max(func(ans),func(ans+1),func(ans+2)));', 'def func(x) :\n global a,b;\n return (a*x)//b-a*(x//b);\n\na,b,n = list(map(int,input().split()));\n\nif n < b :\n print(func(n));\nelse :\n print(func(b-1));'] | ['Wrong Answer', 'Accepted'] | ['s370611355', 's991029203'] | [9036.0, 9076.0] | [24.0, 22.0] | [462, 161] |
p02696 | u649439030 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n=map(int,input().split())\nprint((a*(n-1)/b)-(a*int((n-1)/b)))', 'a,b,n=map(int,input().split())\nif n>=b:\n x=b-1\nelse:\n x=n\nprint(int(a*x/b)-a*int(x/b))'] | ['Wrong Answer', 'Accepted'] | ['s995442197', 's263804533'] | [9164.0, 9168.0] | [21.0, 22.0] | [66, 92] |
p02696 | u651109406 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['global A, B\nA, B, N = map(int, input().split())\n\ndef f(num):\n return(A * num) // B - A * (num // B)\n\nprint(max(f(N - N % B - 1), f(N)))\n', 'A, B, N = map(int, input().split())\n\ntmp = 0\na = 0\ni = 0\n\nif B > A:\n for i in range(B - 1, N + 1, B):\n if (s := (A * i) // B - A * (a)) > 0:\n tmp = max(s, tmp)\n else:\n break\n\nif i >= N - B:\n for i in range(N, N - N % B - 2, -1):\n if (s := (A * i) // B - A * (i // B)) > 0:\n tmp = max(s, tmp)\n else:\n break\n\nprint(tmp)\n', 'global A, B\nA, B, N = map(int, input().split())\n\ndef f(num):\n return(A * num) // B - A * (num // B)\n\nprint(f(min(B - 1, N)))'] | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s330424361', 's614412845', 's096425948'] | [9104.0, 8972.0, 9012.0] | [22.0, 20.0, 21.0] | [139, 392, 127] |
p02696 | u652569315 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n=map(int,input().split())\nl=a//b\nif n>=b-1:\n if a%b>0:\n print(a-l-1,1)\n else:\n print(a-1)\nelse:\n print(int(a*n//b)-a*(n//b),2)', 'a,b,n=map(int,input().split())\nl=a//b\nif b==1:\n print(0)\n exit()\nif n>=b-1:\n if a%b>0:\n print(a-l-1)\n else:\n print(a-1)\nelse:\n print(int((a*n)//b)-a*(n//b))'] | ['Wrong Answer', 'Accepted'] | ['s936106388', 's769794517'] | [9112.0, 9180.0] | [23.0, 22.0] | [140, 167] |
p02696 | u652908807 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['#-*- coding: utf-8 -*-\na,b,n = map(int,input().split())\nif n>=b:\n n = b - 1\n print(int(a*n/b)-(a*n/b))\n exit():\nelse:\n print(int(a*n/b))\n exit():', '#-*- coding: utf-8 -*-\nimport math\na,b,n = map(int,input().split())\nx = min(b-1,n)\nans = math.floor(a*x//b)-a*math.floor(x/b)\nprint(ans)'] | ['Runtime Error', 'Accepted'] | ['s965078329', 's208636287'] | [8812.0, 9036.0] | [18.0, 22.0] | [160, 136] |
p02696 | u653807637 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['def naive(a, b, n):\n\tans = 0\n\tfor i in range(1, n + 1):\n\t\tans = max(ans, int((a * i) / b) - a * int(i / b))\n\treturn ans\n\ndef main(a, b, n):\n\tans = 0\n\ttmp = []\n\tfor i in range(max(n + 1 - a * 10 - 1, 1), n + 1):\n\t\tans = max(ans, int((a * i) / b) - a * int(i / b))\n\treturn ans\n\n\nn = 10000\nfor a in range(1, 10):\n\tfor b in range(1, 100):\n\t\tif naive(a, b, n) != main(a, b, n):\n\t\t\tprint(a, b, naive(a, b, n), main(a, b, n))\n\na, b, n = list(map(int, input().split()))\nprint(main(a, b, n))', 'def val(a, b, x):\n\treturn (a * x) // b - a * (x // b)\n\ndef naive(a, b, n):\n\tans = 0\n\tfor i in range(1, n + 1):\n\t\tans = max(ans, int((a * i) / b) - a * int(i / b))\n\treturn ans\n\ndef main(a, b, n):\n\t\treturn max(val(a, b, n), val(a, b, (n // b) * b - 1), val(a, b, n - 1))\n\n# n = 100\n# for a in range(1, 100):\n# \tfor b in range(1, 1000):\n# \t\tif naive(a, b, n) != main(a, b, n):\n# \t\t\tprint(a, b, naive(a, b, n), main(a, b, n))\n\na, b, n = list(map(int, input().split()))\nprint(main(a, b, n))\n\n# a, b, n = 100, 1000, 100000\n# if naive(a, b, n) != main(a, b, n):\n# \tprint(a, b, naive(a, b, n), main(a, b, n))', 'def val(a, b, x):\n\treturn (a * x) // b - a * (x // b)\n\ndef naive(a, b, n):\n\tans = 0\n\tfor i in range(1, n + 1):\n\t\tans = max(ans, val(a, b, i))\n\treturn ans\n\ndef main(a, b, n):\n\t\treturn max(val(a, b, n), val(a, b, max((n // b) * b - 1, 1)), val(a, b, max(n - 1, 0)))\n\n# n = 10\n# for a in range(1, 1000):\n# \tfor b in range(1, 1000):\n# \t\tif naive(a, b, n) != main(a, b, n):\n# \t\t\tprint(a, b, naive(a, b, n), main(a, b, n))\n\na, b, n = list(map(int, input().split()))\nprint(main(a, b, n))\n'] | ['Time Limit Exceeded', 'Wrong Answer', 'Accepted'] | ['s286748613', 's797190320', 's706564611'] | [8876.0, 9044.0, 9204.0] | [2205.0, 21.0, 22.0] | [482, 600, 481] |
p02696 | u655048024 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n = map(int,input().split())\nans = -100000\nfor i in range(n+1):\n ans= max(ans,((a*i/b)//1-a*(i/b)//1))\nprint(ans)', 'a,b,n = map(int,input().split())\nif(b<=n):\n print(int((a*(b-1)/b)//1))\nelse:\n print(int((a*n/b)//1))\n\n'] | ['Wrong Answer', 'Accepted'] | ['s340330591', 's170809525'] | [9176.0, 9124.0] | [2205.0, 22.0] | [118, 104] |
p02696 | u656391577 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A, B, N = map(int, input().split())\n\ndef floor(t):\n return int(t)\n\nprint(floor((A*(B-1))/B) - A*floor((B-1)/B))', 'A, B, N = map(int, input().split())\n\ndef floor(t):\n return int(t)\n\nlist = []\n\nif N+1 > B:\n print(floor((A*(B-1))/B) - A*floor((B-1)/B))\nelse:\n print(floor((A*N/B) - A*floor(N/B)))'] | ['Wrong Answer', 'Accepted'] | ['s632264518', 's176015841'] | [9172.0, 9112.0] | [20.0, 22.0] | [114, 188] |
p02696 | u667084803 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A, B, N = map(int, input().split())\n\ndef calc(x):\n return (A*x)//B - A*(x//B)\n\nprint(max(calc(B-1), calc(N)))', 'A, B, N = map(int, input().split())\n\ndef calc(x):\n return (A*x)//B - A*(x//B)\n\nprint(calc(min(N,B-1)))'] | ['Wrong Answer', 'Accepted'] | ['s972106323', 's120066065'] | [9168.0, 9164.0] | [21.0, 23.0] | [110, 103] |
p02696 | u667427469 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ["def floor(a):\n return int(a)\n\nif __name__ == '__main__':\n abn = input()\n abn = abn.split()\n a = int(abn[0])\n b = int(abn[1])\n n = int(abn[2])\n\n max_amount = 0\n for i in range(0,min(b-1,n)):\n amount = floor(a*i/b) -a*floor(i/b)\n print(amount)\n max_amount = max(max_amount,amount)\n\n print(max_amount)\n", "def floor(a):\n return int(a)\n\nif __name__ == '__main__':\n abn = input()\n abn = abn.split()\n a = int(abn[0])\n b = int(abn[1])\n n = int(abn[2])\n\n max_amount = 0\n for i in range(1,b):\n amount = floor(a*i/b) -a*floor(i/b)\n max_amount = max(max_amount,amount)\n\n print(max_amount)\n", "def floor(a):\n return int(a)\n\nif __name__ == '__main__':\n abn = input()\n abn = abn.split()\n a = int(abn[0])\n b = int(abn[1])\n n = int(abn[2])\n\n x = min(b-1,n)\n ans = floor(a*x/b)-a*floor(x/b)\n\n print(ans)\n"] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s011153082', 's352456803', 's822730453'] | [9372.0, 9132.0, 9084.0] | [2213.0, 2205.0, 21.0] | [347, 316, 232] |
p02696 | u670180528 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a,b,n=map(int,input().split())\nf=lambda x:(a*x)//b-a*(x//b)\nprint(max(f(b-1),f(n)))', 'a,b,n=map(int,input().split())\nf=lambda x:(a*x)//b-a*(x//b)\nprint(f(min(b-1,n)))'] | ['Wrong Answer', 'Accepted'] | ['s473726041', 's299908931'] | [9060.0, 9008.0] | [23.0, 20.0] | [83, 80] |
p02696 | u671446913 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a, b, n = map(int, input().split())\nprint(n)\n', 'a, b, n = map(int, input().split())\n\nx = min(b. n)\nprint(int(a * x / b))\n', 'a, b, n = map(int, input().split())\n\nx = min(b - 1, n)\nprint(int(a * x / b))\n'] | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s127124077', 's868471996', 's186695788'] | [9132.0, 9092.0, 9128.0] | [21.0, 19.0, 18.0] | [45, 73, 77] |
p02696 | u673101577 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ["import math\n\nA, B, N = map(int, input().split(' '))\n\n\ndef calc(a, b, x):\n return math.floor((a * x) / b) - a * math.floor(x / b)\n\n\n_max = calc(A, B, 0)\nfor _x in range(1, N + 1):\n _temp = calc(A, B, _x)\n # print(_x, _max, _temp)\n if _temp == 0:\n break\n elif _temp > _max:\n _max = _temp\n\n# print('answer')\nprint(_max)\n\n", "import math\n\nA, B, N = map(int, input().split(' '))\n\n\nif math.floor(N / B) > 0:\n ans_x = B - 1\nelse:\n ans_x = N\n\nl = math.floor((A * ans_x) / B)\nr = A * math.floor(ans_x / B)\n\nans = l - r\n\nprint(ans)\n"] | ['Wrong Answer', 'Accepted'] | ['s872003292', 's339729423'] | [9184.0, 9016.0] | [23.0, 20.0] | [347, 235] |
p02696 | u674190122 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['a, b, n = [int(x) for x in input().split()]\nx = min(b - 1, n)\nanswer = floor(a * x / b) - a * floor(x / b)\nprint(answer)', 'from math import floor\na, b, n = [int(x) for x in input().split()]\nx = min(b - 1, n)\nanswer = floor(a * x / b) - a * floor(x / b)\nprint(answer)'] | ['Runtime Error', 'Accepted'] | ['s461550988', 's574063008'] | [9120.0, 9036.0] | [24.0, 21.0] | [120, 143] |
p02696 | u674343825 | 2,000 | 1,048,576 | Given are integers A, B, and N. Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non- negative integer x not greater than N. Here floor(t) denotes the greatest integer not greater than the real number t. | ['A,B,N = map(int,input().split())\nprint(min(N,B-1))', 'A,B,N = map(int,input().split())\nx = min(N,B-1)\nans = int(A*x/B) - A*int(x/B)\nprint(ans)'] | ['Wrong Answer', 'Accepted'] | ['s426722020', 's159662611'] | [8976.0, 9104.0] | [21.0, 20.0] | [50, 88] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.